一、多线程的创建和启动

1、继承至Thread类，重写run方法

public class ThreadDemo extends Thread {
	public void run(){
		for(int i=0;i<10;i++){
			System.out.println(Thread.currentThread().getName()+"..."+i);
		}
	}
}

public class ThreadMain {

	public static void main(String[] args) {
		ThreadDemo td1=new ThreadDemo();
		ThreadDemo td2=new ThreadDemo();
		
		td1.start();
		td2.start();

	}
}

2、实现Runnable接口

public class ThreadDemo implements Runnable {
	public void run(){
		for(int i=0;i<10;i++){
			System.out.println(Thread.currentThread().getName()+"..."+i);
		}
	}
}

public class ThreadMain {

	public static void main(String[] args) {
		ThreadDemo td=new ThreadDemo();
		Thread t1=new Thread(td);
		Thread t2=new Thread(td);
		t1.start();
		t2.start();
	}
}

注意：多线程的是通过start()方法来启动，start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态，什么时候运行是由操作系统决定的。

二、线程的状态

1. 新建状态（New）：新创建了一个线程对象。

2. 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

3. 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。

4. 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
   （一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
   （二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
   （三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5. 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

三、线程同步

1.同步方法 

 即有synchronized关键字修饰的方法。 

 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 

 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

	public synchronized void Test(){
		System.out.println("这是同步方法");
	}

2.同步代码块

 即有synchronized关键字修饰的语句块。 

 被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

	public void Test(){
		synchronized (object) {
			System.out.println("这是同步代码块");
		}		
	}

3、死锁

产生死锁的条件：

1. 有至少一个资源不能共享

2. 至少有一个任务必须持有一个资源并且等待获取另一个被别的任务持有的资源

3. 资源不能任务抢占

4. 必须有循环等待

public class Lock {
	Object locka="a";
	Object lockb="b";
}

public class DeadLockTest implements Runnable{
	Lock lock=new Lock();
	boolean flag;
	public DeadLockTest(boolean flag){
		this.flag=flag;
	}
	public void run() {
		if(flag){
			while(true)
			synchronized (lock.locka) {
				System.out.println(Thread.currentThread().getName()+"getlocka");
				synchronized (lock.lockb) {	
					System.out.println(Thread.currentThread().getName()+"getlockb");
				}
			}
		}else{
			while(true)
			synchronized (lock.lockb) {
				System.out.println(Thread.currentThread().getName()+"getlockb");
				synchronized (lock.locka) {
					System.out.println(Thread.currentThread().getName()+"getlocka");
				}
			}
		}	
	}	
}

public class DeadLockMain {

	public static void main(String[] args) {
		DeadLockTest dt1=new DeadLockTest(true);
		DeadLockTest dt2=new DeadLockTest(false);
		
		Thread t1=new Thread(dt1);
		Thread t2=new Thread(dt2);
		
		t1.start();
		t2.start();
	}

}

多线程小结