一般来说，每个线程自己完成自己的任务就可以了，但有时候，线程的处理会依赖另一个线程的数据，所以就需要线程间通信，来达到同步信息的效果。

下面通过几个例子，配合线程通信的方法来描述一下对他们的理解。

关键字(方法)

Thread.join(),Object.wait(),Object.notify(),CountdownLatch, CyclicBarrier。

介绍

Thread.join()

    private static void demoJoin() {
      final Thread A = new Thread(new Runnable() {
          @Override
          public void run() {
            System.out.println("A");
        }
    });
      Thread B = new Thread(new Runnable() {
          @Override
          public void run() {
              try{
                A.join();
              }catch(InterruptedException e){

              }
            System.out.println("B");
        }
    });
    Thread C = new Thread(new Runnable() {
          @Override
          public void run() {
            System.out.println("C");
        }
    });
      C.start();
      B.start();
      A.start(); 
  }
  结果：CAB,ABC

join的意思是在当前线程执行的过程中，把CPU让给另一个线程来执行。(可以控制线程依次执行)

• A：大哥；B：小弟；C：路人
• 兄弟一场，只要有我B的地方，肯定让A兄先发财。
• 大哥要是已经发财，小弟我就自己努力了
• 路人？他爱在哪在哪，反正小弟永远遵守上面两条

Object.wait(),Object.notify()

B是A的小外甥，A是B的长辈，季节到了，上来一批海货(梭子蟹)，小可爱非常的馋可是又非常懂事，中间的谦让就不说了，最后长辈不吃或者吃了一个之后就给小可爱吃了，小可爱吃够了长辈才吃，下面我们用代码模拟一下这个传统美德。

private static void demoWait() {
        final String lock = "螃蟹";//两人共享一盘梭子蟹
        final Thread A = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println("A----螃蟹1");
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("A----螃蟹2");
                    System.out.println("A----螃蟹3");
                }
            }
        });

        Thread B = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println("B----螃蟹1");
                    System.out.println("B----螃蟹2");
                    System.out.println("B----螃蟹3");
                    lock.notify();
                }
            }
        });
        A.start();
        B.start();
    }
    
    结果：
    A----螃蟹1
    B----螃蟹1
    B----螃蟹2
    B----螃蟹3
    A----螃蟹2
    A----螃蟹3
    

如果不加锁，在执行一个线程的时候另一个会抢占。
wait()方法表示当前线程让出执行权，notify()表示唤醒wait()状态的线程。

CountdownLatch

战争爆发了,D接到命令去保护ABC三个连队撤离。
有一个方案，ABC依次撤离，D最后（ABC依次撤离），实现方式在D中joinC,依次类推。但是那个时候谁先来谁先走呗，这样做效率太慢了，作为D来讲，我只要保证三个部队过去就行，你们仨爱咋办咋办，面向对象对不对。好的，那我掰指头算一下，走完仨就撤。
要模拟这个场景，看来我们需要一个计数器，ABC并行。

 private static void protectedArmy() {
        int armyNum = 3;
        final CountDownLatch countDownLatch = new CountDownLatch(armyNum);
        for (char army = 'A'; army <= 'C'; army++) {
            final String name = String.valueOf(army);
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(name + "部队正在撤离");
                    try {
                        Thread.sleep(100);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println(name + "部队已经撤离");
                    countDownLatch.countDown();
                }
            }).start();
        }
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("D 正在断后（等待其他部队撤离）");
                try {
                    countDownLatch.await();
                    System.out.println("ABC撤离完毕，D可以撤离了");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
    
结果：
D部队正在断后（等待其他部队撤离）
A部队正在撤离
B部队正在撤离
C部队正在撤离
A部队已经撤离
B部队已经撤离
C部队已经撤离
ABC撤离完毕，D可以撤离了

具体实现过程是：
创建一个计数器，设置总的需要等待的线程数，然后再等待线程中调用countDownLatch.await()方法，进入等待状态，直到计数值变成 0;在被等待线程中调用其他线程中调用countDownLatch.countDown()方法，执行一次会将等待数目减去1，当变成0的时候，等待线程不再wait，继续执行之后的代码。

CyclicBarrier

有个赛车比赛，3名选手参赛，人齐才能开始，代码模拟一下。

 private static void runABCWhenAllReady() {
        int runner = 3;
        final CyclicBarrier cyclicBarrier = new CyclicBarrier(runner);
        final Random random = new Random();
        for (char runnerName = 'A'; runnerName <= 'C'; runnerName++) {
            final String rN = String.valueOf(runnerName);
            new Thread(new Runnable() {
                @Override
                public void run() {
                    long prepareTime = random.nextInt(10000) + 100;
                    System.out.println("裁判等了" + prepareTime + "毫秒，" + rN + "选手到了");
                    try {
                        Thread.sleep(prepareTime);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    try {
                        System.out.println(rN + "选手准备好了，在等其他人");
                        cyclicBarrier.await(); // 当前选手准备好，等待其他人
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                    System.out.println(rN + "比赛开始"); // 人齐开始比赛
                }
            }).start();
        }
    }
    
    结果：
    裁判等了133毫秒，A选手到了
    裁判等了1642毫秒，B选手到了
    裁判等了8062毫秒，C选手到了
    A选手准备好了，在等其他人
    B选手准备好了，在等其他人
    C选手准备好了，在等其他人
    C比赛开始
    A比赛开始
    B比赛开始

实现过程：
先创建一个公共 CyclicBarrier 对象，设置同时等待的线程数，这些线程同时开始自己做准备，自身准备完毕后，需要等待别人准备完毕，这时调用cyclicBarrier.await(); 即可开始等待别人；
当指定的同时等待的线程数都调用了cyclicBarrier.await()时，意味着这些线程都准备完毕好，然后这些线程同时继续执行。

CyclicBarrier与CountDownLatch比较

• CountDownLatch:一个线程(或者多个)，等待另外N个线程完成某个事情之后才能执行；
• CyclicBarrier:N个线程相互等待，任何一个线程完成之前，所有的线程都必须等待。
• CountDownLatch:一次性的；CyclicBarrier:可以重复使用。
• CountDownLatch基于AQS；CyclicBarrier基于锁和Condition。本质上都是依赖于volatile和CAS实现的

Callable

如果想在线程结束之后给你结果，可能就要用到Callable和FutureTask。

class Ticket implements Callable<Integer> {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        FutureTask<Integer> ft = new FutureTask<>(ticket);
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + " 的循环变量i的值" + i);
            if (i == 2) {
                new Thread(ft, "有返回值的线程").start();
            }
        }
        try {
            System.out.println("子线程的返回值:" + ft.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

    @Override
    public Integer call() throws Exception {
        int i = 0;
        for (; i < 4; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        return i+10;
    }
}
结果：
main 的循环变量i的值0
main 的循环变量i的值1
main 的循环变量i的值2
有返回值的线程 0
有返回值的线程 1
有返回值的线程 2
有返回值的线程 3
子线程的返回值:14

call方法里并没有打印，但是循环确实运行了。
过程：
(1)创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行 体，并且有返回值。
(2)创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该 FutureTask对象封装了该Callable对象的call()方法的返回值。
(3)使用FutureTask对象作为Thread对象的target创建并启动新线程。
(4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值，调用 get()方法会阻塞线程。

两个线程如何交替运行

两个线程交替打印数字，你打印一个我打印一个，我用锁写了一个实现方法。

class Ticket implements Runnable {
    Object x = "90";
    static int total = 10;
    static Ticket t1 = new Ticket();

    public static void main(String[] args) {
        printMethod();
    }

    static void printMethod() {
        Thread A = new Thread(t1);
        Thread B = new Thread(t1);
        A.setName("A");
        B.setName("B");
        A.start();
        B.start();
    }

    @Override
    public void run() {
        synchronized (x) {
            for (; total < 20; total++) {
                System.out.println(Thread.currentThread().getName() + "------" + total);
                x.notify();
                try {
                    x.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }
    }
}

结果:
A------10
B------10
A------11
B------12
A------13
B------14
A------15
B------16
A------17
B------18
A------19