Java多线程编程四(线程间通信)

本文主要讲述如何解决非线程安全问题，感谢java多线程核心编程一书，为本系列文章提供参考借鉴

一、等待和通知机制

1.经过前面的知识学习，我们先来看一下如果才能让两个线程互相通信数据呢？

编码两个线程如下：

public class NotifyThread extends Thread {
    private List<String> list;
    public NotifyThread(List<String> list) {
        this.list = list;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            list.add(String.valueOf(i));
            System.out.println("添加了" + (i + 1) + "个元素");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class BeCalledThread extends Thread {
    private List<String> list;
    public BeCalledThread(List<String> list) {
        this.list = list;
    }
    @Override
    public void run() {
        while (true) {
            System.out.println("判断大小");
            if (list.size() == 5) {
                System.out.println("list的大小等于5了，此线程要推出了");
                return;
            }
        }
    }
}

    public static void main (String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        NotifyThread notifyThread = new NotifyThread(list);
        BeCalledThread beCalledThread = new BeCalledThread(list);
        notifyThread.start();
        beCalledThread.start();
    }

其中NotifyThread线程和BeCalledThread共享一个list，NotifyThread线程每一秒向list里添加数据，而BeCalledThread线程则检测list的大小，结果如下：

由于BeCalledThread一直在不停快速的查询list的大小，所以导致NotifyThread前添加数据的日志无法呈现出来，很快的就被覆盖掉里，由此可知，这样的做法是非常消耗资源的，所以就诞生里“等待/通信“机制来解决优化这个问题。

2.等待/通信机制

简单通俗的讲，等待通信机制就是：线程a和线程b，线程a执行任务的前提需要某个条件成立，而这个条件并不成立，线程a并不需要隔一段一段时间或者是不停去查询这个条件是否成立，而是进入等待状态，而线程b或者是多个线程执行任务的时候将线程a需要的条件构建成立来了，此时会通知正在等到的线程a，告诉线程a此条件已经成立，然后线程a就可以做相关的操作了。（就好比酒店里，客人点餐，服务员不需要不停询问厨房是否做好，而是等待厨房做好了通知服务员来取餐）

下面介绍一下相关方法:

• 方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法用来将当前线程置入“预执行队列“中，并且在wait()所在的代码行处停止执行，直到接到通知或者被中断位置。在调用wait()之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait()方法。在执行wait()方法后，当前线程释放锁。在从wait()返回前，线程与其他线程竞争重新获得锁。如果调用wait()时没有持有适当的锁，则抛出IllegalMonitorStateException,它是RuntimeException的一个子类，因此，不需要try-catch语句进行捕捉异常。
• 方法notify()也要在同步方法或同步块中调用，即在调用前，线程也必须获得该对象的对象级别锁。如果调用notify()时没有持有适当的锁，也会抛出lllegalMonitorStateException。该方法用来通知那些可能等待该对象的对象锁的其他线程，如果有多个线程等待，则由线程规划器随机挑选出其中一个呈wait状态的线程，对其发出通知notify，并使它等待获取该对象的对象锁。需要说明的时，在执行notify()方法后，当前线程不会马上释放该对象锁，呈wait状态的线程也并不能马上获取该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出synchronized代码块后，当前线程才会释放锁，而呈wait状态所在的线程才可以获取该对象锁。当第一个获得了该对象锁的wait线程运行完毕以后，它会释放掉该对象锁，此时如果该对象没有再次使用notify语句，则即便该对象已经空闲，其他wait状态等待的线程由于没有得到该对象的通知，还会继续阻塞在wait状态，直到这个对象发出一个notify或notifyAll。
• 总结：wait使线程停止运行，而notify使停止的线程继续运行。
• 关键字synchronized可以将任何一个Object对象作为同步对象来看，而java为每个Object都实现了wait()和notify()方法，他们必须用在被synchronized同步的Object的临界区内。通过调用wati方法可以使处于临界区的线程进入等待状态，同时释放被同步对象的锁。而notify操作可以唤醒一个因调用了wait操作而处于阻塞状态中的线程，使其进入就绪状态。被重新唤醒的线程会试图重新获取临界区的控制权，也就是锁，并继续执行临界区内wait之后的代码。如果发出notify操作时没有处于阻塞状态中的线程，那么该命令会被忽略。
• wait()方法可以使调用该方法的线程释放共享资源的锁，然后从运行状态退出，进入等待队列，直到被再次唤醒。
• notify()方法可以随机唤醒等待队列中等待同一共享资源的“一个“线程，并使该线程退出等待队列，进入可运行状态，也就是notify()方法仅随机通知“一个“线程。
• notifyAll()方法可以使所有正在等待队列中等待同一共享资源的“全部“线程从等待状态退出，进入可运行状态。此时优先级最高的那个最先执行，但也有可能使随机执行，因为这个要取决与JVM虚拟机的实现。
• wait()方法释放锁，notify()不释放锁，只有执行完notify()所在的同步synchronized代码块以后才释放锁。
• 当线程呈wait()状态时，调用线程对象的interrupt()方法会出现InterruptedException异常。
• 在执行同步代码块的过程中，发生了异常而导致线程终止，锁也会被释放。
• 方法wait(long)方法的功能是等待某一时间内是否有现成对锁进行唤醒，如果超过这个时间则自动唤醒。提醒：在使用wait/notify模式时，还需要注意另一种情况，也就wait等待的条件发生了变化，也容易造成程序逻辑的混乱。

3.方法join的使用

• join()：很多情况下，主线程创建并启动子线程，如果子线程中要进行大量的耗时运算，主线程往往将早于子线程结束之前结束。这时如果主线程想等待子线程执行完成后再结束，如子线程处理一个数据，主线程要取得这个数据中的值，就要使用join()方法了。方法join()的作用是等待线程对象销毁。
• join(long):等待指定时间，过后不再等待。
• 方法join()与interrupt()方法如果彼此遇到，则会出现异常。
• 方法join()是由wait(long)方法来实现的，所有其具有释放锁的特点，也就是当执行join()方法时，会获取到线程本身对象锁，然后再释放。而Thread.sleep(long)方法却不释放锁。

方法join()后面的代码提前运行：出现意外

创建如下代码：

public class ThreadB extends Thread {

    @Override
   synchronized public void run() {
        try {
            System.out.println("begin B ThreadName="+Thread.currentThread().getName()+"  "+System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("  end B ThreadName=" + Thread.currentThread().getName() + "  " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class ThreadA extends Thread {
    private ThreadB b;
    public ThreadA(ThreadB b) {
        this.b = b;
    }
    @Override
    public void run() {
        synchronized (b) {
            try {
                System.out.println("begin A ThreadName="+Thread.currentThread().getName()+"  "+System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println("   end A ThreadName="+Thread.currentThread().getName()+"  "+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public static void main (String[] args) throws InterruptedException {
        ThreadB b = new ThreadB();
        ThreadA a = new ThreadA(b);
        a.start();
        b.start();
        b.join(2000);
        System.out.println("                      main end "+System.currentTimeMillis());
    }

运行结果有两种如下：

结果1

结果2

为了解释这个现象需要更改上诉代码，将main程序中的join方法注释掉运行：

结果1	结果2
结果3

有结果来看，大部分都是`System.out.println(" main end "+System.currentTimeMillis());`先执行，也就是说如果去掉之前的join()方法的注释，那么运行，也就很大几率先运行，由于join是同步方法，也就会获取锁b，然后释放锁b，再由线程A和线程B来争抢锁b，假如线程A先抢到锁b，那么执行打印begin，然后sleep且不释放锁，再打印end，执行完毕并释放锁b，此时再由之前运行的join方法和线程B来争抢锁b，谁抢到就睡运行或者继续运行，结果就出现了一些不确定的打印结果的顺序。