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种场景,其中等待-通知机制是线程通信的核心机制。工作中用轮询的方式来等待某个状态,很多情况下都可以用等待-通知机制。


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