Java 多线程（三）—— 线程间通信

╰+哭是因爲堅強的太久メ 2022-03-21 06:50 333阅读 0赞

知识点：

1.  `myThread.join()`：使当前线程阻塞，当 myThread 线程执行结束后，阻塞的线程再继续；
2.  `object.wait()`：使当前线程阻塞，前提是必须先获得锁，一般配合synchronized 关键字使用。
3.  `object.notify()`：随机唤醒一个等待（对象的）单个线程；如果有多个线程等待一个对象，这个方法只会唤醒其中一个线程，选择哪个线程取决于操作系统对多线程管理的实现。一般配合synchronized 关键字使用。
4.  `object.notifyAll()`：唤醒所有等待（对象的）线程，哪一个线程将会第一个唤醒取决于操作系统的实现。一般配合synchronized 关键字使用。  
    一般在 synchronized 同步代码块里使用 wait()、notify/notifyAll() 方法。
5.  由于 wait()、notify/notifyAll() 在synchronized 代码块执行，说明当前线程一定是获取了锁的。  
    `当线程执行wait()方法时候，会释放当前的锁，然后让出CPU，进入等待状态。 只有当 notify/notifyAll() 被执行时候，才会唤醒一个或多个正处于等待状态的线程，然后继续往下执行，直到执行完synchronized 代码块的代码或是中途遇到wait() ，再次释放锁。 也就是说，notify/notifyAll() 的执行只是唤醒沉睡的线程，而不会立即释放锁，锁的释放要看代码块的具体执行情况。所以在编程中，尽量在使用了notify/notifyAll() 后立即退出临界区，以唤醒其他线程`。
6.  `notify()` 和`wait()` 的顺序不能错，如果A线程先执行 `notify()` 方法，B线程在执行 `wait()` 方法，那么B线程是无法被唤醒的。
7.  `CountdownLatch`：是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。  
    `CyclicBarrier`,  
    `FutureTask`,  
    `Callable` 等。

`注：文中大写字母AB等，均代表线程。`

# 目录 #

*  如何保证 B 在 A 任务完成后在执行？
 *  2.如何让两个线程按照指定方式有序交叉运行呢？
 *  3.四个线程 A B C D，其中 D 要等到 A B C 全执行完毕后才执行，而且 \* A B C 是同步运行的
 *  4.线程 A B C 各自开始准备，直到三者都准备完毕，然后再同时运行 
 *  5.子线程完成某件任务后，把得到的结果回传给主线程

#### 1.如何保证 B 在 A 任务完成后在执行？ ####

final Thread t1 = new Thread() { 
        @Override
        public void run() { 
            for (int i = 0; i < 5; i ++) { 
                System.out.println(getName() + ".t1." + i);
            }
        }
    };
    
    Thread t2 = new Thread() { 
        @Override
        public void run() { 
            for (int i = 0; i < 5; i ++) { 
                if (i == 2) { 
                    try { 
                        t1.join();       // t1插队先执行
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
                System.out.println(getName() + ".t2." + i);
            }
        }
    };
    
    t1.start();
    t2.start();

输出结果如下：

> Thread-0.t1.0  
> Thread-1.t2.0  
> Thread-0.t1.1  
> Thread-0.t1.2  
> Thread-0.t1.3  
> Thread-0.t1.4  
> Thread-1.t2.1  
> Thread-1.t2.2  
> Thread-1.t2.3  
> Thread-1.t2.4

`t1.join();` 方法会让线程`t2`一直等待知道`t1`任务执行完毕。

#### 2.如何让两个线程按照指定方式有序交叉运行呢？ ####

Thread t1 = 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");
            }
        }
    }, "A");
    
    
    Thread t2 = 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();
            }
        }
    }, "B");
    
    t1.start();
    t2.start();

输出结果如下：

> A 1  
> B 1  
> B 2  
> B 3  
> A 2  
> A 3

这正是我们期望的结果。  
注意：如果当前的线程不是此对象的所有者（即在同步代码块中，用哪个对象锁，就用哪个对象调用 wait、notify 方法），却欲想调用该对象的`notify()`、`wait()`方法，会抛出异常`IllegalMonitorStateException`。

#### 3.四个线程 A B C D，其中 D 要等到 A B C 全执行完毕后才执行，而且 \* A B C 是同步运行的 ####

public static void demo2() { 
        int workerNumber = 3;
        final CountDownLatch countDownLatch = new CountDownLatch(workerNumber);
    
        new Thread(new Runnable() { 
            @Override
            public void run() { 
                System.out.println("D is waiting for other three threads");
                try { 
                    countDownLatch.await();
                    System.out.println("All done, D starts working");
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
    
            }
        }, "D").start();
    
        for (char charName = 'A'; charName <= 'C'; charName ++) { 
            final String threadName = String.valueOf(charName);
    
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    System.out.println(threadName + " is working");
                    try { 
                        Thread.sleep(100);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    System.out.println(threadName + " finished");
                    countDownLatch.countDown();
                }
            }, threadName).start();
        }
    }

输出结果如下：

> D is waiting for other three threads  
> A is working  
> B is working  
> C is working  
> C finished  
> B finished  
> A finished  
> All done, D starts working

#### 4.线程 A B C 各自开始准备，直到三者都准备完毕，然后再同时运行 ####

为了实现线程间互相等待这种需求，我们可以利用 `CyclicBarrier` 数据结构，它的基本用法是：

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

public static void demo3() { 
        int threadNumber = 3;
        final CyclicBarrier cyclicBarrier = new CyclicBarrier(threadNumber);
        final Random random = new Random();
    
        for (char charName = 'A'; charName <= 'C'; charName ++) { 
    
            final String threadName = String.valueOf(charName);
    
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    long prepareTime = random.nextInt(10000) + 100;
                    System.out.println(threadName + "正在等待中……" + prepareTime + "ms");
                    try { 
                        Thread.sleep(prepareTime);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
    
                    try { 
                        System.out.println(threadName + "准备完毕, 等待其他线程");
                        cyclicBarrier.await(); // 当前线程准备完毕，等待其他线程
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) { 
                        e.printStackTrace();
                    }
    
                    System.out.println(threadName + "开始执行！"); // 所有线程都准备好了，同时运行
    
                }
            }, threadName).start();
        }
    }

输出结果如下：

> A正在等待中……1634ms  
> C正在等待中……8244ms  
> B正在等待中……7459ms  
> A准备完毕, 等待其他线程  
> B准备完毕, 等待其他线程  
> C准备完毕, 等待其他线程  
> C开始执行！  
> A开始执行！  
> B开始执行！

参考：  
[Java 里如何实现线程间通信？][Java]  
[什么时候使用CountDownLatch][CountDownLatch]

[Java]: http://wingjay.com/2017/04/09/Java%E9%87%8C%E5%A6%82%E4%BD%95%E5%AE%9E%E7%8E%B0%E7%BA%BF%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1%EF%BC%9F/
[CountDownLatch]: http://www.importnew.com/15731.html