2.多线程的通信

线程开始运行，拥有自己的栈空间，就如同一个脚本一样，按照既定的代码一步一步得执行。

1. 等待/通知机制

Java多线程的等待/通知机制使基于Object的wait()和notify()、notifyAll()实现的。

等待线程获取对象锁，不满足条件调用wait()释放锁，进入等待状态。另外一个notify线程获取到锁，执行对应的逻辑，改变条件的状态，使wait线程满足条件，调用notify()、notifyAll() 释放锁，唤醒wait的线程。wait的线程执行操作。

/**
 * 1.等待/通知机制
 * 1) 使用 wait()、notify()和 notifyAll()时需要先对调用对象加锁。
 * 2) 调用 wait()方法后，线程状态由 RUNNING 变为 WAITING，并将当前线程放置到对象的等待队列。
 * 3) notify()或 notifyAll()方法调用后，等待线程依旧不会从 wait()返回，需要调用notify()或 notifAll()的线程释放锁之后，等待线程才有机会从 wait()返回。
 * 4) notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll() 方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由 WAITING 变为 BLOCKED。
 * 5) 从 wait()方法返回的前提是获得了调用对象的锁。
 */
public static class WaitAndNotify{
    private static boolean flag = true;
    private static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread waitThread = new Thread(new Wait(),"waitThread");
        waitThread.start();
        Thread.sleep(1000L);

        Thread notifyThread = new Thread(new Notify(),"notifyThread");
        notifyThread.start();
    }

    static class Wait implements Runnable{
        @Override
        public void run() {
            //加锁拥有lock的Monitor
            synchronized (lock){
                //当条件不满足时，继续wait，同时释放lock的锁
                while (flag){
                    try {
                        System.out.println(Thread.currentThread() + "flag is true. wait@ "+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //条件满足，完成工作
                System.out.println(Thread.currentThread() + "flag is false. running@ "+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
            }

        }
    }

    static class Notify implements Runnable{
        @Override
        public void run() {
            synchronized (lock){
                try {
                    //获取lock的锁，然后进行通知，通知时不会释放lock的锁
                    //直到当前线程释放lock后，WaitThread才能从wait方法中返回
                    System.out.println(Thread.currentThread() + "hold lock.notify@ "+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
                    lock.notifyAll();
                    flag = false;
                    Thread.sleep(5000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (lock){
                System.out.println(Thread.currentThread() + "hold lock again. sleep@ "+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
            }
        }
    }
}

2. 信号量

JDK提供了类似信号量的功能类“Semaphore”但本文不是要介绍这个类，而是介绍一种基于volatile关键字的自己实现的信号量通信。

后面会有专门的章节介绍volatile关键字，这里只是做一个简单的介绍。

volatile关键字能够保证内存的可见性，如果用volatile关键字声明了一个变量，在一个线程里面改变了这个变量的值，那其它线程是立马可见更改后的值的。

比如我现在有一个需求，我想让线程A输出0，然后线程B输出1，再然后线程A输出2…以此类推。我应该怎样实现呢？

 /**
 * signal -信号量方式
 * 我想让线程A输出0，然后线程B输出1，再然后线程A输出2…以此类推
 * signal++并不是一个原子操作，所以我们在实际开发中，会根据需要使用synchronized给它“上锁”，或者是使用AtomicInteger等原子类。并且上面的程序也并不是线程安全的，因为执行while语句后，可能当前线程就暂停等待时间片了，等线程醒来，可能signal已经大于等于5了。
 */
public static class SignalDemo{
    private static volatile int signal = 1;

    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        Thread.sleep(1000);
        new Thread(new ThreadB()).start();
    }


    static class ThreadA implements Runnable {
        @Override
        public void run() {
            while (signal < 5) {
                if (signal % 2 == 0) {
                    System.out.println("threadA: " + signal);
                    signal++;
                }
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            while (signal < 5) {
                if (signal % 2 == 1) {
                    System.out.println("threadB: " + signal);
                    signal = signal + 1;
                }
            }
        }
    }
}

3. 管道输入/输出流

管道输入输出流和文件输入输出流或者网络输入输出流不同之处在于，它主要用于线程间数据传输，而传输的介质是内存。

管道是基于“管道流”的通信方式。JDK提供了PipedWriter、 PipedReader、 PipedOutputStream、 PipedInputStream。其中，前面两个是基于字符的，后面两个是基于字节流的。

/**
 * 管道输入输出流
 * 1.线程ReaderThread开始执行，
 * 2.线程ReaderThread使用管道reader.read()进入”阻塞“，
 * 3.线程WriterThread开始执行，
 * 4.线程WriterThread用writer.write("test")往管道写入字符串，
 * 5.线程WriterThread使用writer.close()结束管道写入，并执行完毕，
 * 6.线程ReaderThread接受到管道输出的字符串并打印，
 * 7.,线程ReaderThread执行完毕。
 */
public static class Pipe{

    public static void main(String[] args) throws IOException, InterruptedException {
        PipedWriter writer = new PipedWriter();
        PipedReader reader = new PipedReader();
        writer.connect(reader); // 这里注意一定要连接，才能通信

        new Thread(new ReaderThread(reader)).start();
        Thread.sleep(1000);
        new Thread(new WriterrThread(writer)).start();
    }

    static class ReaderThread implements Runnable{
        private PipedReader reader;
        public ReaderThread(PipedReader reader){
            this.reader = reader;
        }
        @Override
        public void run() {
            System.out.println("this is reader");
            int receive = 0;
            while (true) {
                try {
                    if (((receive = reader.read()) != -1)) {
                        System.out.println((char)receive);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class WriterrThread implements Runnable{
        private PipedWriter writer;
        public WriterrThread(PipedWriter writer) {
            this.writer = writer;
        }
        @Override
        public void run() {
            System.out.println("this is writer");
            try {
                writer.write("test");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

这个很好理解。使用管道多半与I/O流相关。当我们一个线程需要先另一个线程发送一个信息（比如字符串）或者文件等等时，就需要使用管道通信了。

4. 其他类型

4.1. join

参考1.多线程基础

4.2. sleep

参考1.多线程基础

4.3. ThreadLocal

ThreadLocal线程变量，是一个本地线程副本变量工具类。内部是一个弱引用的Map来维护。

ThreadLocal类并不属于多线程间的通信，而是让每个线程有自己”独立“的变量，线程之间互不影响。它为每个线程都创建一个副本，每个线程可以访问自己内部的副本变量。

ThreadLocal底层为Map 实现，key 是当前线程的信息。虽然set(),get()调用没有存取key，但是实际底层代码是set/get的key是当前的线程。

 /**
 * ThreadLocal
 * ThreadLocal线程变量，是一个本地线程副本变量工具类。内部是一个弱引用的Map来维护。
 * ThreadLocal类并不属于多线程间的通信，而是让每个线程有自己”独立“的变量，线程之间互不影响。它为每个线程都创建一个副本，每个线程可以访问自己内部的副本变量。
 */
public static class ThreadLocalDemo {
    public static void main(String[] args) throws InterruptedException {
        ThreadLocal<String> threadLocal = new ThreadLocal<>();
        new Thread(new ThreadA(threadLocal)).start();//ThreadA输出：A
        Thread.sleep(5000L);
        new Thread(new ThreadA.ThreadB(threadLocal)).start();//ThreadB输出：B,注释掉set为B 的输出为null
    }

    static class ThreadA implements Runnable {
        private ThreadLocal<String> threadLocal;
        public ThreadA(ThreadLocal<String> threadLocal) {
            this.threadLocal = threadLocal;
        }
        @Override
        public void run() {
            threadLocal.set("A");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("ThreadA输出：" + threadLocal.get());
        }

        static class ThreadB implements Runnable {
            private ThreadLocal<String> threadLocal;
            public ThreadB(ThreadLocal<String> threadLocal) {
                this.threadLocal = threadLocal;
            }
            @Override
            public void run() {
//                    threadLocal.set("B");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("ThreadB输出：" + threadLocal.get());
            }
        }
    }
}