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等待中// 需要把值加 1counter++;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;}@Overridepublic 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;}@Overridepublic 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等待中// 需要把值加 1counter++;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：在某一时刻，只有唯一一个线程可以拥有对象的锁。

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！