Java并发编程（五）---线程通信

前言

上一篇我们介绍了死锁的发生条件，以及避免死锁的方式。其中 破坏占有且等待的处理是，通过一个单例类一次性申请所有资源，直到成功。如while (!Allocator.getAllocator().applyResource(this, target)) { return; } 如果在并发量比较小的情况下，还可以接受，如果并发量比较大的话，就会大量的消耗CPU的资源。这时候，我们应该引入线程通信，主要是 等待-唤醒机制。
线程通信

下面我们通过一个例子来说明。场景说明：
图书馆里，有一本书叫《Java 高并发实战》，小A早上的时候把这本书借走了，小B中午的时候去图书馆找这本书，这里小A和小B分别是两个线程，他们都要看的书是共享资源。
通过共享对象通信

小B去了图书馆，发现这本书被借走了，他回到家，等了几天，再去图书馆找这本书，发现这本书已经被归还了，他顺利借走了书。
用程序模拟的话，就是线程小A调用setCanBorrow方法将canBorrow设为true，线程小B调用getCanBorrow获取。在这里线程A和B必须获得
指向同一个LibraryTest1共享实例的引用，如果持有的对象指向不同的LibraryTest1实例，那么彼此将不能检测到对方的信号。

public class LibraryTest1 {
    //是否可借
    private boolean canBorrow = false;
    synchronized boolean getCanBorrow() {
        return canBorrow;
    }
    synchronized void setCanBorrow(boolean canBorrow) {
        this.canBorrow = canBorrow;
    }
}

   

忙等待

其实小A在小B走后一会就把书还回去了，小B却在几天后才去找书，为了早点借到书（减少延迟），小B可能在图书馆等着，每隔几分钟(while循环),他就去检查这本书有没有被还回，这样只要小A一还回书，小B马上就会知道。

public class LibraryTest1 {
         final LibraryTest1 libraryTest1 = new LibraryTest1();
           while (!libraryTest1.getCanBorrow()) {
            //空等
             return;
        }
}


wait(),notify()和notifyAll()

很多次后，小B发现自己这样做太累了，身体有点吃不消，不过很快，学校图书馆系统改进，加入了短信通知功能（notify()）,只要小A一还回书，图书馆会立马通知小B，这样小B就可以在家睡觉等短信了。

//是否可借
  private boolean canBorrow = false;

    synchronized String borrowBook() throws InterruptedException {
        if (!canBorrow) {
            wait();
            return null;
        }
        canBorrow = false;
        return "Java 高并发实战";
    }

    synchronized void giveBackBook() {
        this.canBorrow = true;
        notify();
    }


如上程序，canBorrow 初始为false时（书本已经被小A借走），小A 还书（调用giveBackBook方法）之后，书的可借状态为可借，并且调用notify()通知等待线程（系统发短信给小B）需要注意的两点是：

    wait()，notify() 和或者notifyAll() 都需要在同步代码块中调用（就是消息只能由图书管理系统发出），不能再同步代码块之外调用，否则，会抛出IllegalMonitorStateException异常。
    notify() 是随机的通知等待队列里的某一个线程，而notifyAll()是通知等待队列里的所有线程。一般而言最好调用notifyAll()，而不要调用notify()。因为，通知时，只是表示通知时间点条件满足，等线程执行时，条件可能已经不满足了，线程的执行时间与通知时间不重合，如果调用notify()的话很快能不能通知到我们期望通知的线程。

wait()与sleep() 的相同点与不同点

相同点：都会让当前线程挂起一段时间，让渡CPU的执行时间，等待再次调度
不同点：

    wait(),notify(),notifyAll()一定是在synchronized{}内部调用，等待和通知的对象必须要对应。而sleep可以再任何地方调用
    wait 会释放锁对象的“锁标志”，当调用某一对象的wait()方法后，会使当前线程暂停执行，并将当前线程放入对象等待池中。知道调用notifyAll()方法，而sleep则不会释放，也就是说在休眠期间，其他线程仍然不能访问共享数据。
    wait可以被唤醒，sleep的只能等其睡眠结束
    wait()是在Object 类里，而sleep是在Thread 里的

丢失的信号

学校图书馆系统是这么设计的，当一本书被还回来的时候，会给等待着发送短信，并且只会发一次，如果没有等待者，他也会发（只不过没有接受者）。问题出现了，因为短信只会发一次，当书被还回来的时候，没有人等待借书，他会发一条空短信，但是之后有等待借此本书的同学永远也不会再收到短信，导致这些同学会无休止的等待，为了避免这个问题，我们等待的时候先打个电话问问图书管理员是否继续等待if（!wasSignalled）。

public class LibraryTest3 {
    private MonitorObject monitorObject = new MonitorObject();
    private boolean canBorrow = false;
    private boolean wasSignalled = false;

    String borrowBook() throws InterruptedException {
        synchronized (monitorObject) {
            if (!canBorrow||!wasSignalled) {
                wait();
                return null;
            }
            canBorrow = false;
            return "Java 高并发实战";
        }
    }

    void giveBackBook() {
        synchronized (monitorObject) {
            this.canBorrow = true;
            this.wasSignalled = true;
            notifyAll();
        }
    }
}



notify()和notifyAll()方法不会保存调用它们的方法，因为当这两个方法被调用时，有可能没有线程处于等待状态，通知信号过后便丢弃了。因此，如果一个线程先于被通知线程调用wait()前调用notify()，等待的线程就将错过这个信号。在某些情况下，这可能使得等待线程永久等待，不再被唤醒。所以，为了避免丢失信号，我们需要将信号保存到信号类里。这里的管理员就是信号类。
假唤醒

图书馆系统还有一个BUG：系统会偶尔给你发条错误短信，说书可以借了（其实不可以借），我们之前已经该图书馆管理员打过电话了，他说让我们等短信。我们很听话，一等到短信（其实是bug引起的错误短信），就去借书了，到了图书馆后发现这书根本没有还回来！我们很郁闷，但也没有办法呀，学校不修复BUG，我们得聪明点：每次在收到短信后，再打电话问问书到底能不能借while（!canBorrow||!wasSignalled）。

 String borrowBook() throws InterruptedException {
        synchronized (monitorObject) {
            while (!canBorrow||!wasSignalled) {
                wait();
                return null;
            }
            canBorrow = false;
            return "Java 高并发实战";
        }
    }

   

就像案例里说的，有时候线程会被莫名奇妙的唤醒，为了防止假唤醒，保存信号的成员变量将在一个while循环里接收检查。而不是在if表达式里。
不要对常量字符串或全局对象调用wait()

因为如果使用常量字符串的话。JVM/编译器内部会把常量字符串转成同一个对象，
这意味着即使你有2个不同的MyWaitNotify3实例，它们都是引用了相同的空字符串实例。同时也意味着存在这样的风险，在第一个MyWaitNotify3实例调用doWait()会被第二个MyWaitNotify3实例上调用doNotify()的线程唤醒。

public class MyWaitNotify3 {

    String monitorObject = "";
    boolean isSignaled = false;

    public void doWait() {
        synchronized (monitorObject) {
            while (!isSignaled) {
                try {
                    monitorObject.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //清楚标记，继续执行
            isSignaled = false;
        }
    }

    public void doNotify() {
        synchronized (monitorObject) {
            isSignaled = true;
            monitorObject.notifyAll();
        }
    }

}


总结

本文主要介绍了线程之间的通信，通过一个现实中的场景再现了这5种场景，其中等待-通知机制是线程通信的核心机制。工作中用轮询的方式来等待某个状态，很多情况下都可以用等待-通知机制。


作者：码农飞哥
微信公众号：码农飞哥