java并发编程（一）

wait：在调用wait方法时，线程必须要持有被调用对象的锁（monitor），当调用wait方法后，线程就会释放掉该对象的锁（monitor）

sleep：在调用Thread类的sleep方法时，线程是不会释放掉对象的锁的。

notify：当调用对象的notify方法时，它会随机唤醒该对象等待集合（wait set）中的任意一个线程。

notifyAll：当调用对象的notifyAll方法时，它会唤醒该对象等待集合（wait set）中的所有线程。

 示例：

编写一个多线程程序：

1. 存在一个对象，该对象有一个int类型的成员变量counter，初始值为0；

2. 创建两个线程，其中一个线程对该对象的成员变量counter增1，另一个线程对该对象的成员变量counter减1；

3. 输出该对象成员变量counter每次变化后的值。确保输出的顺序应为：1010101010...

public class MyObject {

	private int counter;

	/**
	 * 加 1
	 * 这里的synchronized锁的是多个线程操作MyObject类的同一个实例
	 */
	public synchronized void increase() {
		// 可以走到这里，表示拿到了锁
		if (counter != 0) {
			try {
				/*
				 * counter 不是我们需要的值，就要调用wait把这个锁释放掉，
				 * 让其他的线程拿到这个锁
				 * */
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		// 可以走到这里，表示当前线程拿到了锁，另外一个线程在wait等待中
		// 需要把值加 1
		counter++;
		System.err.println(counter);
		// 唤醒另一个线程
		notify();
	}

	/**
	 * 减 1
	 */
	public synchronized void decrease() {
		if (counter == 0) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		counter--;
		System.err.println(counter);
		notify();
	}
}

public class IncreaseThread extends Thread {

	private MyObject myObject;

	public IncreaseThread(MyObject myObject) {
		this.myObject = myObject;
	}

	@Override
	public void run() {
		for (int i = 0; i < 30; i++) {
			try {
				Thread.sleep((long) (Math.random() * 1000));   // Thread.sleep(1000L); 注意这种用法一定要带L
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			myObject.increase();
		}
	}
}

public class DeCreaseThread extends Thread {

	private MyObject myObject;

	public DeCreaseThread(MyObject myObject) {
		this.myObject = myObject;
	}

	@Override
	public void run() {
		for (int i = 0; i < 30; i++) {
			try {
				Thread.sleep((long) (Math.random() * 1000));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			myObject.decrease();
		}
	}
}

public class MyMain {

	public static void main(String[] args) {
		MyObject myObject = new MyObject();

		Thread increaseThread = new IncreaseThread(myObject);
		Thread deCreaseThread = new DeCreaseThread(myObject);

		increaseThread.start();
		deCreaseThread.start();
	}
}

 4. 假如创建两个IncreaseThread线程类的对象和两个DeCreaseThread线程类的对象，一共有4个线程执行增加和减少操作，结果还是我们期望的1010101010吗？

public class MyMain {

	public static void main(String[] args) {
		MyObject myObject = new MyObject();

		Thread increaseThread = new IncreaseThread(myObject);
		Thread deCreaseThread = new DeCreaseThread(myObject);
		Thread increaseThread2 = new IncreaseThread(myObject);
		Thread deCreaseThread2 = new DeCreaseThread(myObject);

		increaseThread.start();
		increaseThread2.start();
		deCreaseThread.start();
		deCreaseThread2.start();
	}
}

答案：不是，结果错乱并且程序不结束；

原因：当前counter等于1，线程调用decrease减1，counter等于0了，然后走notify，当前线程结束，

然后又有一个线程进来，是调用increase还是decrease是不确定的，假如调用的是decrease，counter为0，走wait，线程进入等待状态，释放掉对象的锁。此时另外的三个线程（两个增加的和一个减少的）increase和decrease都有可能被执行，假如此时还是decrease线程竞争到了，代码继续走判断counter为0，此线程也走wait，进入等待状态，那么此时就有两个线程在wait等待状态，而且这两个线程都是用于将值减少的线程；

然后继续，刚上一个线程也进行了wait，那么它就把锁释放掉了，此时还有两个线程可以执行，这两个线程都是用于增加的线程，此时这两个线程有一个线程执行increase，代码继续判断counter不等于0为假，继续执行counter++等于1，执行notify，唤醒等待状态中的线程。当前处于等待中的线程有两个，都是用于减少的decrease线程，此时有一个decrease线程被唤醒，继续走代码判断counter等于0为假，执行counter--等于0，执行notify，唤醒等待状态中线程，假如此时又唤醒了另外一个减少的decrease线程，此时不走判断了，唤醒后直接在wait这行代码，继续执行counter--等于-1，等于-1这里开始出错了。

* 此问题看到的重点，需要理解的是，处于等待中的线程被唤醒后，一是必须先竞争到对象的锁，二是竞争到锁后从上一次wait的地方接着执行，在wait前面的变量值可能被其他的线程改变成不是我们期望的原有值了，然而此时代码在继续执行，导致最后的结果也不是我们期望的。

改正后的代码：

public class MyObject {

	private int counter;

	/**
	 * 加 1
	 * 这里的synchronized锁的是多个线程操作MyObject类的同一个实例
	 */
	public synchronized void increase() {
		// 可以走到这里，表示拿到了锁
		while (counter != 0) {
			try {
				/*
				 * counter 不是我们需要的值，就要调用wait把这个锁释放掉，
				 * 让其他的线程拿到这个锁
				 * */
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		// 可以走到这里，表示当前线程拿到了锁，另外一个线程在wait等待中
		// 需要把值加 1
		counter++;
		System.err.println(counter);
		// 唤醒另一个线程
		notify();
	}

	/**
	 * 减 1
	 */
	public synchronized void decrease() {
		while (counter == 0) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		counter--;
		System.err.println(counter);
		notify();
	}
}

总结：

1：当调用wait时，首先需要确保调用了wait方法的线程已经持有了对象的锁。

2：当调用wait后，该线程就会释放掉这个对象的锁，然后进入到等待状态。

3：当线程调用了wait后进入到等到状态时，它就可以等待其他线程调用相同对象的notify或notityAll方法来使自己被唤醒。

4：一旦这个线程被其他线程唤醒后，该线程就会与其他线程一同开始竞争这个对象的锁（公平竞争）；只有当该线程获取到了这个对象的锁后，线程才会继续从它上次等待的位置接着往下执行。

5：调用wait方法的代码片段需要放在一个synchronized块或是synchronized方法中，这样才可以确保线程在调用wait方法前已经获取到了对象的锁。

6：当调用对象的notify方法时，它会随机唤醒该对象等待集合（wait set）中的任意一个线程，当某个线程被唤醒后，它就会与其他线程一同竞争对象的锁。

7：当调用对象的notifyAll方法时，它会唤醒该对象等待集合（wait set）中的所有线程，这些线程被唤醒后，又会开始竞争对象的锁。

8：在某一时刻，只有唯一一个线程可以拥有对象的锁。