一、线程的几种状态

线程有四种状态：

• 1.产生（New）：线程对象已经产生，但尚未被启动，所以无法执行。如通过new产生了一个线程对象后没对它调用start()函数之前。
• 2.可执行（Runnable）：每个支持多线程的系统都有一个排程器，排程器会从线程池中选择一个线程并启动它。
  当一个线程处于可执行状态时，表示它可能正处于线程池中等待排排程器启动它；也可能它已正在执行。
  如执行了一个线程对象的start()方法后，线程就处于可执行状态，但显而易见的是此时线程不一定正在执行中。
• 3.死亡（Dead）：当一个线程正常结束，它便处于死亡状态。如一个线程的run()函数执行完毕后线程就进入死亡状态。
• 4.停滞（Blocked）：当一个线程处于停滞状态时，系统排程器就会忽略它，不对它进行排程。

二、线程间的相互作用

线程间的相互作用：线程之间需要一些协调通信，来共同完成一件任务。

Object类中相关的方法有两个notify方法和三个wait方法，因为wait和notify方法定义在Object类中，因此会被所有的类所继承。这些方法都是final的，即它们都是不能被重写的，不能通过子类覆写去改变它们的行为。

1、wait()方法

• wait()方法使得当前线程必须要等待，等到另外一个线程调用notify()或者notifyAll()方法。
• 当前的线程必须拥有当前对象的monitor，也即lock，就是锁。要确保调用wait()方法的时候拥有锁，即，wait()方法的调用必须放在synchronized方法或synchronized块中。
• 线程调用wait()方法，释放它对锁的拥有权，然后等待另外的线程来通知它（通知的方式是notify()或者notifyAll() 方法），这样它才能重新获得锁的拥有权和恢复执行。

2、wait()与sleep()比较

• 当线程调用了wait()方法时，它会释放掉对象的锁。
• 另一个会导致线程暂停的方法：Thread.sleep()，它会导致线程睡眠指定的毫秒数，但线程在睡眠的过程中是不会释放掉对象的锁的。

3、notify()方法

• notify()方法会唤醒一个等待当前对象的锁的线程。如果多个线程在等待，它们中的一个将会选择被唤醒。这种选择是随意的，和具体实现有关。（线程等待一个对象的锁是由于调用了wait方法中的一个）。
• 被唤醒的线程是不能被执行的，需要等到当前线程放弃这个对象的锁。被唤醒的线程将和其他线程以通常的方式进行竞争，来获得对象的锁。也就是说，被唤醒的线程并没有什么优先权，也没有什么劣势，对象的下一个线程还是需要通过一般性的竞争。
• notify()方法应该是被拥有对象的锁的线程所调用。换句话说，和wait()方法一样，notify()方法要求在调用时线程已经获得了对象的锁，因此对这两个方法的调用需要放在synchronized方法或 synchronized块中。

4、一个线程变为一个对象的锁的拥有者是通过下列三种方法：

• 1.执行这个对象的synchronized实例方法。
• 2.执行这个对象的synchronized语句块。这个语句块锁的是这个对象。
• 3.对于Class类的对象，执行那个类的synchronized、static方法。

三.实例代码分析

public class Demo {
	private volatile int signal;
	public void set(int value) {
		this.signal = value;
	}
	public int get() {
		return signal;
	}
	
	public static void main(String[] args) {
		Demo d = new Demo();
		new Thread(new Runnable() {
			@Override
			public void run() {
				synchronized (d) {
					System.out.println("修改状态的执行。。。");
					try {
						Thread.sleep(5000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					d.set(1);
					System.out.println("修改状态。。。");
					d.notify();
				}
			}
		}).start();


		new Thread(new Runnable() {
			@Override
			public void run() {
				synchronized (d) {
					//等待signal为1开始执行，否则不能执行
					while(d.get() != 1) {
						try {
							d.wait();
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
					//当信号为1的时候，执行代码
					System.out.println("模拟代码的执行。。。"+d.get());
				}
			}
		}).start();
	}
}

public class Demo2 {
	private volatile int signal;
	//notify和wait必须放在同步方法或者同步代码块里面执行
	public synchronized void set() {
		this.signal = 1;
		System.out.println("叫醒线程之后休眠开始。。。。");
		//notify();//notify方法会随机叫醒一个处于wait状态的线程
		notifyAll();//notifyAll叫醒所有处于wait状态的线程，争夺到时间片的线程只有一个
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	public synchronized int get() {
		System.out.println(Thread.currentThread().getName()+"   执行了。。。   ");
		if(signal!=1) {
			try {
				wait();//调用wait方法的时候会释放拿到的锁
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+"   执行完毕");
		return signal;
	}

	public static void main(String[] args) {
		Demo2 d = new Demo2();
		Target1 t1 = new Target1(d);
		Target2 t2 = new Target2(d);

		new Thread(t2).start();
		new Thread(t2).start();
		new Thread(t2).start();
		new Thread(t2).start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		new Thread(t1).start();
	}
}

public class Target1 implements Runnable{
	private Demo2 demo2;
	public Target1(Demo2 demo2) {
		this.demo2 = demo2;
	}
	@Override
	public void run() {
		demo2.set();
	}
}

public class Target2 implements Runnable{
	private Demo2 demo2;
	public Target2(Demo2 demo2) {
		this.demo2 = demo2;
	}
	@Override
	public void run() {
		demo2.get();
	}
}

原文