线程间的通信方法

锁和同步

我们可以使用锁来保证同步。

如果不同步的话，多个线程start后，他们的执行时间和顺序是不确定的。

同步的意思就是 人为的确定 线程间的执行顺序； 可以用加 锁来解决。

用 synchronized 关键字，可同步方法 或者 代码块。

等待和通知

在用锁的时候，如果我们访问的对象是被锁起来了的，这时就是处于 阻塞状态

我们就需要不断的重新去尝试，直到拿到锁为止，这样就比较消耗性能和资源。

可以用 等待 和 通知解决：Object 的 wait（）、 notify（）、 notifyAll（）

wait（） 使一个线程进入 无限等待 或 限时等待 状态，同时会 释放锁。wait（）必须放在同步块 或 同步方法中。

notify（） 用来随机唤醒一个处于 无限等待 或 限时等待 状态的线程。

notifyAll（） 用来唤醒 所有处于 无序等待 或 限时等待 状态的线程。

注意：他们作用的对象要是同一把锁，否则这把锁也是没有用的。

信号量

可以用 volatile 关键字来实现信号量通信。

volatile 关键字：

可以保证内存的可见性，

也就是用 volatile 声明的变量，在以一个线程改变了之后，其他线程使立马可以看见改变后的值的。

public class Signal {
   
    private static volatile int signal = 0;

    static class ThreadA implements Runnable {
   
        @Override
        public void run() {
   
            while (signal <= 50) {
   
                if (signal % 2 == 0) {
   
                    System.out.println("threadA : " + signal);
                    synchronized (this) {
   
                        signal = signal + 1;        // 不是原子操作，所以要加锁
                    }
                }
            }
        }
    }

    static class ThreadB implements Runnable {
   
        @Override
        public void run() {
   
            while (signal <= 50) {
   
                if (signal % 2 == 1) {
   
                    System.out.println("threadB : " + signal);
                    synchronized (this) {
   
                        signal++;     // 不是原子操作，所以要加锁
                    }
                }
            }
        }
    }


    public static void main(String[] args) {
   
        // 交替执行
        new Thread(new ThreadA()).start();      // 输出奇数
        new Thread(new ThreadB()).start();      // 输出偶数。

    } 
}

注意： signal++ 或 signal = signal + 1 并不是一个原子操作。

信号量的应用场景：

在多个线程（2个线程以上）进行通信时，用信号量机制就比较方便了。

管道

是一种基于 管道流 的通信方法。

JDK 里提供了有 基于字符的： PipedReader 、 PipedWriter、

也有 基于字节的： PipedOutoutStream、 PipedInputStream 类。

public class Pipe {
   

    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;
            try {
   
                while ((receive = reader.read()) != -1) {
   
                    System.out.println((char) receive);
                }
            } catch (IOException e) {
   
                e.printStackTrace();
            }
        }
    }

    static class WriterThread implements Runnable {
   
        private PipedWriter writer;

        public WriterThread(PipedWriter writer) {
   
            this.writer = writer;
        }

        @Override
        public void run() {
   
            System.out.println("this is writer");
            int receive = 0;
            try {
   
                writer.write("test");
            } catch (IOException e) {
   
                e.printStackTrace();
            }finally {
   
                try {
   
                    writer.close();
                } catch (IOException e) {
   
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException, IOException {
   
        PipedReader reader = new PipedReader();
        PipedWriter writer = new PipedWriter();
        // 要先链接！！！！
        writer.connect(reader);

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

应用场景：

管道多半都与 IO 有关， 在线程间通信需要传入 字符串 或 文件的话， 就可以使用 管道的方式了。

join（） 方法

在当前线程调用另一个线程的 join（） 方法，就会使当前线程进入 无限时等待 或 限时等待 状态，

直到另一个线程的 任务执行完毕，当线程才会继续往下执行。

public class Join {
   
    static class ThreadA implements Runnable {
   
        @Override
        public void run() {
   
            try {
   
                System.out.println("我是子线程，我先睡5秒。。。");
                Thread.sleep(5000);
                System.out.println("我是子线程，我睡完5秒了。。。");
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }
    }


    public static void main(String[] args) throws InterruptedException {
   
        Thread thread = new Thread(new ThreadA());
        thread.start();
        thread.join();  // thread 方法执行完了，再往下执行。
        System.out.println("如果不加 join 方法， 我会先执行。。。。");
    }

}

ThreadLocal 类

严格来说， ThreadLocal 类并不属于 线程间的通信范畴，只是他可以存储各个独自有的线程的变量，不被其他线程影响。

内部是一个 弱引用的 Map 来维护。最常用的 set（）、get（）方法。

当然可以用私有变量来解决，但这样用 ThreadLocal 类后，可以将静态变量和 线程的状态 关联起来。

应用场景：

数据库的链接，Session的管理，有着大量复杂对象的初始化和关闭，

就可以用 类的静态变量来时线程更为 “轻量” 些。

public class ThreadLocalDemo {
   
    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 {
   
                // 看看是不是太快的原因，输出和set的一样。
                Thread.sleep(3000);
            } 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");
            System.out.println("ThreadB输出：" + threadLocal.get());
        }
    }

    public static void main(String[] args) {
   
        ThreadLocal<String> stringThreadLocal = new ThreadLocal<>();
        new Thread(new ThreadA(stringThreadLocal)).start();
        new Thread(new ThreadB(stringThreadLocal)).start();

    }  

}

InheritableThreadLocal ： 他的子线程也可以存取这个副本值。

参考链接

https://redspider.gitbook.io/concurrent/di-yi-pian-ji-chu-pian/5#5-5-2-sleep-fang-fa