1.多线程的基本概念：

有时被称为轻量进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。

2.线程的基本操作：线程的生命周期包括：创建线程 、挂起线程、线程等待、终止线程

3.获取线程状态：

线程状态位于Thread对象的ThreadState属性中。ThreadState属性是一个C#枚举对象。刚开始线程状态为ThreadState.Unstarted,然后我们启动线程,,线程状态会从ThreadState.Running变为ThreadState. WaitSleepJoin。 其中：请注意始终可以通过Thread.CurrentThread静态属性获得当前Thread对象。

4.线程的生命周期：出生、就绪、运行、暂停、死亡

案例：

（1）.使用lock关键字实现线程的同步

     Object thislock = new Object();

     lock (thislock)

     {
       //要加锁运行的代码块
b.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target
c.通过Callable和FutureTask创建线程

       Enter（）：在指定对象上获取排他锁

      }

（2）.使用Monitor类来实现线程同步

     Monitor类的两个方法：

     Exit（）：释放指定对象上的排他锁

（3）.使用Mutex类实现线程同步

     public Mutex（bool initallyOwned）

     ReleseMutex（）：释放Mutex一次

5.多线程的实现方法

a.继承Thread类，重写run方法

实现方式如下：

（a）继承Thread类：

public class ThreadDemo01 extends Thread{

    public ThreadDemo01(){

        //编写子类的构造方法，可缺省

    }

    public void run(){

        //编写自己的线程代码

        System.out.println(Thread.currentThread().getName());

    }

    public static void main(String[] args){ 

        ThreadDemo01 threadDemo01 = new ThreadDemo01(); 

        threadDemo01.setName("我是自定义的线程1");

        threadDemo01.start();       

        System.out.println(Thread.currentThread().toString());  

    }

}

（b）通过实现Runnable接口，实现run方法：

public class ThreadDemo02 {

    public static void main(String[] args){ 

        System.out.println(Thread.currentThread().getName());

        Thread t1 = new Thread(new MyThread());

        t1.start(); 

    }

}

class MyThread implements Runnable{

    @Override

    public void run() {

        // TODO Auto-generated method stub

        System.out.println(Thread.currentThread().getName()+"-->我是通过实现接口的线程实现方式！");

    }   

}

（c）通过Callable和FutureTask创建线程 ：

public class ThreadDemo03 {

 public static void main(String[] args) {

        // TODO Auto-generated method stub

        Callable<Object> oneCallable = new Tickets<Object>();

        FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);

        Thread t = new Thread(oneTask);

        System.out.println(Thread.currentThread().getName());

        t.start();

    }

} 

class Tickets<Object> implements Callable<Object>{

    //重写call方法

    @Override

    public Object call() throws Exception {

        // TODO Auto-generated method stub

        System.out.println(Thread.currentThread().getName()+"-->我是通过实现Callable接口通过FutureTask包装器来实现的线程");

        return null;

    }   

}