第一节等待/通知机制

1.1不使用等待/通知机制实现线程间的通讯
1.2什么是等待/通知机制
1.3等待/通知机制的实现
1.4方法wait()锁释放与notify()锁不释放
1.5当interrupt()遇到wait()方法
1.6只通知一个线程
1.7唤醒所有线程
1.8方法wait(long)的使用
1.9通知过早
1.10等待wait的条件发生变化
1.11生产者/消费者模式实现
1.12通过管道进行线程间通信：字节流
1.13通过管道进行线程间通信：字符流
1.14实战：等待/通知之交叉备份

1.1不使用等待/通知机制实现线程间通信　　

本小节中使用了sleep()与while(true)实现了多线程间的通信。

原理:有一公共类，内有List集合，并提供add()方法向其中添加元素。

线程A开启后每一秒钟调用add()方法

线程B开启后一直循环查询List的大小，当超过定值时抛出异常终止线程。

弊端：线程B不停的while语句轮询机制检查某一条件，浪费CPU。

若轮询时间小，CPU资源更加浪费，若轮询时间过大，则可能无法得到预想的值。

1.2什么是等待/通知机制

1.3等待/通知机制的实现

　　方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法用来将当前线程置入“预执行队列”中，并且在wait()所在的代码行处停止执行，直到接到通知或被中断为止。

在调用wait()之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步代码块中执行wait()方法。在执行wait()方法后，当前线程释放锁。在从wait()返回前，线程与其他线程竞争重新获得锁。若在调用wait()时没有持有适当的锁，则会抛出IllegalMonitorStateException，他是RuntimeException的一个子类，因此不需要try/catch进行捕捉异常。

　　方法notify()也要在同步方法或同步代码块中调用，即在调用前，线程也必须获得该对象的对象级别锁。如果调用notify()时没有持有适当的锁，也会抛出IllegalMonitorStateException异常。该方法用来通知那些可能等待该对象的对象锁的其他线程，如果有多个线程等待，则由线程规划器随机挑选出一个呈wait状态的线程，对其发出通知notify，并使它等待获取该对象的对象锁。需要说明的是，在执行notify()方法后，当前线程不会马上释放该对象锁，呈wait状态的线程也并不能马上获取该对象锁，要等到执行notify()方法的线程将程序执行完毕，也就是退出synchronized代码块后，当前线程才会释放锁，而呈wait状态所在的线程才能获取该对象锁。当第一个获得了该对象锁的wait线程运行完毕以后，它会释放掉该对象锁，此时如果该对象没有再次使用notify语句，则即便该对象以及空闲，其他wait状态等待的线程由于没有得到该对象的通知，还会继续阻塞在wait状态，直到这个对象发出一个notify或notifyAll。

　　简而言之：

wait()使线程停止运行，notify()使停止的线程继续运行。
wait()与notify()都需要对象级别的锁存在才能调用。
wait()执行后，当前线程立即释放对象锁，notify()执行后，需等待同步代码执行完毕才能够释放对象锁，并唤醒其他线程。

　　注：wait()与notify()都是Object的方法，在“等待”跟“通知”时，均是由锁对象自己来调用wait()与notify()的。

　　wait()方法可以使调用该方法的线程释放共享资源的锁，然后从运行状态退出，进入等待队列，知道被再次唤醒。

　　notify()方法可以随机唤醒等待队列中等待同一共享资源的“一个”线程，并使该线程退出等待队列，进入可运行状态，仅通知“一个”线程。

　　notifyAll()可以使所有正在等待队列中等待统一资源的“全部”线程从等待状态退出，进入可运行状态。此时，优先级最高的那个线程最先执行，但也有可能是随机执行，这取决于JVM实现。

　　线程的几个状态：

　　1）新创建一个线程对象后，再调用它的start()方法，系统会为此线程分配CPU资源，使其处于Runnable（可运行）状态，这是一个准备运行的阶段，如果线程抢占到CPU资源，此时线程处于Running（运行）状态。

　　2）Runnable状态和Running状态可以互相切换，因为有可能线程运行一段时间后，有其他高优先级的线程抢占了CPU资源，这是线程就从Running状态转化为Runnable状态。

　　　　线程进入Runnable状态大体分为以下5种情况：

调用sleep()方法后经过的时间超过了指定的休眠时间。
线程调用的阻塞IO已经返回，阻塞方法执行完毕。
线程成功获得了试图同步的监视器。
线程正在等待某个通知，其他线程发出了通知。
处于挂起状态的线程调用了resume恢复方法。

　　3）Blocked是阻塞的意思，例如遇到一个IO操作，此时CPU处于空闲状态，可能会转而把CPU时间片分给其他线程，这时也可以成为“暂停”状态。Blocked状态结束后，进入Runnable状态，等待系统重新分配资源。

　　　　出现阻塞的情况大体分为以下5中：

　　　　　　线程调用sleep()方法，主动放弃占用的处理器资源。

　　　　　　线程调用阻塞式IO方法，在该方法返回前，该线程被阻塞。

　　　　　　线程试图获得一个同步监视器，但该同步监视器正在被其他线程所持有。

　　　　　　线程等待某个通知。

　　　　　　线程调用suspend()方法将该线程挂起，此方法容易死锁，尽量避免使用。

　　4）run()方法运行结束后进入销毁阶段，整个线程执行完毕。

　　　注：每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列。就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程。一个线程被唤醒才会进入就绪队列，等待CPU的调度，反之一个线程被wait后，就会进入阻塞队列，等待下一次唤醒。

1.4方法wait()锁释放与notify()锁不释放

当方法wait()被执行完后，锁会被自动释放，但执行完notify()方法后，锁不自动释放。

　　注：sleep()方法不释放锁，notify()方法执行后，必须方法所在的synchronized代码执行完毕后才释放锁。

1.5当interrupt方法遇到wait方法　

当线程呈wait()状态时，调用线程对象的interrupt()方法会出现InterruptedException异常。

注：

　　1）执行完同步代码块就会释放对象的锁。

　　2）在执行同步代码块的过程中，遇到异常而导致线程终止，锁也会被释放。

　　3）在执行同步代码块的过程中，执行了锁所属对象的wait()方法，这个线程就会释放对象锁，而这个线程就会进入线程等待池中，等待被唤醒。

1.6只通知一个线程

调用notify()一次只随机唤醒一个线程。（前提是这两个线程使用同一个对象锁）。

1.7唤醒所有线程

调用notifyAll()方法会唤醒所有的线程。（这些线程全都是使用一个对象锁）。

1.8方法wait(long)的使用

带一个参数的wait(long)方法的功能是等待某一时间内是否有线程对锁进行唤醒，如果超过这个时间就自动唤醒。

注：也可以在long的时间内被其他线程唤醒（这些线程公用一个对象锁）。

1.9通知过早

如果通知过早可能会打断程序正常的运行逻辑。

可能会出现，还没有wait，就已经notify的情况。这样就失去通知的意义了。

1.10等待wait的条件发生变化

若wait等待的条件发生了变化，也容易造成程序逻辑的混乱。

这个是结合到具体的逻辑判断与数据删减的情况才会涉及到。

这里是使用while()判断替换了if()判断解决的问题（但是目前我没想明白为啥。。）

1.11生产者/消费者模式实现

变形一：一生产与一消费——操作值：

　　生产者：一个专门用来提供服务，并且在服务提供完成后唤醒消费者。

　　消费者：专门用来消费服务，并且在消费完之后唤醒生产者。

变形二：多生产与多消费——操作值-假死：

　　“假死”的现象就是线程进入了WAITING等待状态，如果全部线程都进入了WAITING状态（死锁），则程序就不再执行任何业务功能了，整个项目呈停止状态。

　　案例中出现假死的现象是由于仅仅唤醒了同类（生产者唤醒了生产者，消费者唤醒了消费者）的现象大量出现导致的。

变形三：多生产与多消费——操作值：

　　解决上一小节的假死问题的方式是，将notify()方法改为notifyAll()方法，这样就会通知所有的线程，避免出现假死状态。

变形四：一生产与一消费——操作栈：

　　以List集合模拟栈，限制为栈的容量是否为1（最大值为1），进行生产/消费。

变形五：一生产与多消费——操作栈：解决wait条件改变与假死。

　　同上例的基础条件，但是消费者变为多个。

　　解决条件改变是将if改为while（这里还不太明白），解决假死是将notify()改为notifyAll()。

变形六：多生产与一消费：操作栈

变形七：多生产与多消费：操作栈

　　六和七，在解决条件改变与假死之后，只需修改执行方法就ok，说明，生产者与消费者模型中目前出现的问你就是通过这两个方式来解决的。

　　注：wait条件改变：while()替代if()，假死：notifyAll()替代notify()

1.12通过管道进行线程间通信：字节流

　　java中有各种各样的输入/输出流Stream，使我们能够很方便的对数据进行操作，其中管道流（pipeStream）是一种特殊的流，用在不同管道间直接传送数据。

　　一个线程发送数据到输出管道，一个线程从输入管道接收数据。通过不同线程间的管道通信，而无须借助于类似临时文件之类的东西。

　　四种管道流：

　　　　1）PipedInputStream/PipedOutputStream

　　　　2）PipedReader/PipedWriter

　　使用流的new PipedInputStream().connect(new PipedOutputStream)或者：new PipedOutputStream().connect(new PipedInputStream())。可以实现Stream之间的通信链接。

　　注：当读取的数据没有值时，会阻塞，知道数据被写入之后才会继续运行。

1.13通过管道进行线程间通信：字符流　　

　　与上面的例子是一致的（流不一样）。

1.14实战：等待/通知之交叉备份

　　要求：

　　　　创建20个线程，十个线程将数据备份到数据库A，十个线程将数据备份到数据库B，且备份A与备份B是交叉进行的。同时还要求有序。

　　数据库代码：

public class DBTools {

    volatile private boolean prevIsA = false;

    synchronized public void backupA() {

        try {

            while (prevIsA == true) {

                wait();

            }

            for (int i = 0; i < 5; i++) {

                System.out.println("☆☆☆☆☆");

            }

            prevIsA = true;

            notifyAll();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

    synchronized public void backupB() {

        try {

            while (prevIsA == false) {　　　　//用while代替if防止出现条件改变的情况

                wait();

            }

            for (int i = 0; i < 5; i++) {

                System.out.println("*****");

            }

            prevIsA = false;

            notifyAll();　　　　　　　　　　　　//用notifyAll()替换notify()防止出现“假死”

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

}

线程代码1：

public class BackupA extends  Thread{

    private DBTools db;

    public BackupA(DBTools db) {

        this.db = db;

    }

    @Override

    public void run() {

        db.backupA();

    }

}

线程代码2：

public class BackupB extends Thread {

    private DBTools db;

    public BackupB(DBTools db) {

        this.db = db;

    }

    @Override

    public void run() {

        db.backupB();

    }

}

执行代码：

public class Main {

    public static void main(String[] args) throws Exception{

        DBTools dbTools = new DBTools();

        for (int i = 0; i < 20; i++) {

            BackupB output = new BackupB(dbTools);

            output.start();

            BackupA input = new BackupA(dbTools);

            input.start();

        }

    }

}

执行结果：

第二节方法join的使用

2.1学习方法join前的铺垫
2.2用join()方法来解决问题
2.3方法join与异常
2.4方法join(long)的使用
2.5方法join(long)与sleep(long)的区别
2.6方法join()后面的代码提前运行：出现意外
2.7方法join()后面的代码提前运行：解释意外

场景应用：主线程创建子线程，但是若主线程先于子线程终结，且想获得子线程中的值时，就需要join方法，作用：等待线程对象毁灭

2.1学习方法join前的铺垫

　场景实例：

2.2用join()方法来解决

　　只要在上例的代码start()后面加join()方法即可实现输出的要求。

　　方法join的作用是使所属的线程对象x正常执行run()方法中的任务，而使当前线程z进行无限期的阻塞，等待线程x销毁后再继续执行线程z后面的代码。

2.3方法join与异常

方法join()与interrupt()如果遇到就会出现异常。

　　注：因调用join()而无限阻塞的线程必须与调用interrupt()的线程保持一致。

2.4方法join(long)的使用　　

　　join(long)中的参数是设定等待时间。

　　join(long)与sleep(long)的区别：在同步上表现不一致。（调用者也不一样）

2.5方法join(long)与sleep(long)的区别

　　join的源码中是通过调用wait(long)来实现的，具有释放锁的功能：

 public final synchronized void join(long millis)

    throws InterruptedException {

        long base = System.currentTimeMillis();

        long now = 0;

        if (millis < 0) {

            throw new IllegalArgumentException("timeout value is negative");

        }

        if (millis == 0) {

            while (isAlive()) {

                wait(0);

            }

        } else {

            while (isAlive()) {

                long delay = millis - now;

                if (delay <= 0) {

                    break;

                }

                wait(delay);

                now = System.currentTimeMillis() - base;

            }

        }

    }