2 Java 里实现线程间通信

最新推荐文章于 2024-05-11 10:24:57 发布

_kaifei

最新推荐文章于 2024-05-11 10:24:57 发布

阅读量358

点赞数

分类专栏： Java&Spring 文章标签： java

本文链接：https://blog.csdn.net/hukfei/article/details/77009213

版权

Java&Spring 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

如何让两个线程依次执行
如何让两个线程按照指定的方式有序交叉运行
四个线程 A B C D其中 D 要等到 A B C 全执行完毕后才执行而且 A B C 是同步运行的
三个运动员各自准备等到三个人都准备好后再一起跑
子线程完成某件任务后把得到的结果回传给主线程

在正常情况下，每个子线程完成各自的任务就可以结束了。不过有的时候，我们希望多个线程协同工作来完成某项任何，这时就涉及到了线程间的通信了。

1 如何让两个线程依次执行

假设有两个线程，一个是线程 A，另一个是线程 B，两个线程分别依次打印 1-3 三个数字。

代码示例

private static void demo1() {
    Thread A = new Thread(new Runnable() {
        @Override
        public void run() {
            printNumber("A");
        }
    });

    Thread B = new Thread(new Runnable() {
        @Override
        public void run() {
            printNumber("B");
        }
    });

    A.start();
    B.start();
}
private static void printNumber(String threadName) {
    int i=0;
    while (i++ < 3) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(threadName + "print:" + i);
    }
}

可以看到 A 和 B 是同时打印的。
那么，如果我们希望 B 在 A 全部打印完后再开始打印，可以利用 thread.join() 方法。

private static void demo2() {
    Thread A = new Thread(new Runnable() {
        @Override
        public void run() {
            printNumber("A");
        }
    });

    Thread B = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("B 开始等待 A");
            try {
                A.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            printNumber("B");
        }
    });

    B.start();
    A.start();
}

得到结果如下：

B 开始等待 A
A print: 1
A print: 2
A print: 3

B print: 1
B print: 2
B print: 3

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

还是上面的例子，我们现在希望 A 在打印完 1 后，再让 B 打印 1, 2, 3，最后再回到 A 继续打印 2，3。这种需求下，显然 Thread.join() 已经不能满足了。我们需要更加细粒度的锁来控制执行顺序。

这里，我们可以利用 object.wait() 和 object.notify() 两个方法来实现。

private static void demo3() {
    Object lock = new Object();
    Thread A = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("INFO: A 等待锁");
            synchronized (lock) {
                System.out.println("INFO: A 得到了锁 lock");
                System.out.println("A 1");
                try {
                    System.out.println("INFO: A 准备进入等待状态，放弃锁 lock 的控制权");
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("INFO: 有人唤醒了 A, A 重新获得锁 lock");
                System.out.println("A 2");
                System.out.println("A 3");
            }

        }
    });
    Thread B = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("INFO: B 等待锁");
            synchronized (lock) {
                System.out.println("INFO: B 得到了锁 lock");
                System.out.println("B 1");
                System.out.println("B 2");
                System.out.println("B 3");

                System.out.println("INFO: B 打印完毕，调用 notify 方法");
                lock.notify();
            }
        }
    });
    A.start();
    B.start();
}

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

我们希望达到的目的是：A B C 三个线程同时运行，各自独立运行完后通知 D；对 D 而言，只要 A B C 都运行完了，D 再开始运行。针对这种情况，我们可以利用 CountdownLatch 来实现这类通信方式。

它的基本用法是：

创建一个计数器，设置初始值，CountdownLatch countDownLatch = new CountDownLatch(threadNum)
在 等待线程 里调用 countDownlatch.await() 方法，进入等待状态，直到计数值变成 0
在 其他线程 里调用 countDownLatch.countDown() 方法，该方法会将计数值减 1
当 其他线程 的 countDown() 方法把计数值变成 0 时，等待线程 里的 countDownLatch.await() 立即退出，继续执行下面的代码

private static void runDAfterABC() {
    int worker = 3;
    CountDownLatch countDownLatch = new CountDownLatch(worker);

    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();
            }

        }
    }).start();

    for (char threadName='A'; threadName <= 'C'; threadName++) {
        final String tN = String.valueOf(threadName);
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(tN + "is working");
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    e.printStackTrace();
                }

                System.out.println(tN + "finished");
                countDownLatch.countDown();
            }
        }).start();
    }
}

4 三个运动员各自准备，等到三个人都准备好后，再一起跑

针对线程 A B C 各自开始准备，知道三者都准备完毕，然后再同时运行，也就是要实现一种线程之间相互等待的效果。

上面的 CountDownLatch 可以用来倒计数，但当计数完毕，只有一个线程的 await() 会得到响应，无法让多个线程同时触发。

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

先创建一个公共的 CycliBarrier 对象，设置 同时等待 的线程数，CycliBarrier cycliBarrier = new CycliBarrier(3)
这些线程同时开始自己做准备，自身准备完毕后，需要等待别人准备完毕，这时调用 cycliBarriet.await() 即可开始等待别人
当制定的 同时等待 的线程数都调用了 cycliBarriet.await() 时，意味着这些线程都准备完毕，然后这些线程才同时继续执行

实现代码如下，设想有三个跑步运动员，各自准备好后等待其他人，全部准备好后才开始跑

private static void runABCWhenAllReady() {
    int runner = 3;
    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(rN + "is preparing for time:" + prepareTime);
                try {
                    Thread.sleep(prepareTime);
                } catch (Exception e) {
                    e.printStackTrace();
                }

                try {
                    System.out.println(rN + "is prepared, waiting for others");
                    cyclicBarrier.await(); // 当前运动员准备完毕，等待别人准备好
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }

                System.out.println(rN + "starts running"); // 所有运动员都准备好了，一起开始跑
            }
        }).start();
    }
}

5 子线程完成某件任务后，把得到的结果回传给主线程

在实际开放中，我们经常要创建子线程来做一些耗时的任务，然后把任务的结果回传给主线程调用，这种情况在 Java 里要如何实现呢？

回顾线程的创建，我们一般会把 Runnable 对象传给 Thread 去执行。Runnable 定义如下：

public interface Runnable {
    public abstract void run();
}

可以看到 run() 在执行完后不会返回任何结果。那么希望返回结果呢？这里可以利用另一个类似的接口 Callable

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

可以看出 Callable 最大区别就是返回范型 V 结果
在 Java 里有一个类是配合 Callable 使用的：FutureTask，不过注意，它获取结果的 get 方法会阻塞主线程。

private static void doTaskWithResultInWorker() {
    Callable<Integer> callable = new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
            System.out.println("Task starts");
            Thread.sleep(1000);
            int result = 0;
            for (int i=0; i<=100; i++) {
                result += i;
            }
            System.out.println("Task finished and return result");
            return result;
        }
    };

    FutureTask<Integer> futureTask = new FutureTask<>(callable);
    new Thread(futureTask).start();


    try {
        System.out.println("Before futureTask.get()");
        System.out.println("Result:" + futureTask.get());
        System.out.println("After futureTask.get()");
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
}