【JUC】003-走进Callable、CountDownLatch、CyclicBarrier、Semaphore

訾博ZiBo

发布于 2025-01-06 16:41:20

4300

代码可运行

文章被收录于专栏：全栈开发工程师全栈开发工程师

运行总次数：0

代码可运行

一、Callable（简单）

1、官方文档描述

①可以有返回值；

②可以抛出异常；

③方法不同：call()方法（Runnable是run()方法）；

2、启动线程

启动线程的方法只有一个：

new Thread().start();

但是Thread()的参数不能传入callable：

那可怎么办？

我们需要借助Runnable的实现类FutureTask传入Callable：

package com.zibo.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//测试Callable
public class TestCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread myThread = new MyThread();
        FutureTask futureTask = new FutureTask(myThread);
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();//结果会被缓存，提升效率
        //futureTask.get()获取callable的返回值
        System.out.println(futureTask.get());//这个get方法会被阻塞，放到最后
    }
}
class MyThread implements Callable<String>{

    @Override
    public String call() throws Exception {
        System.out.println("call()执行了！" + Thread.currentThread().getName());
        return "123";
    }
}

运行结果：

call()执行了！A
123

注意：

有缓存；结果可能需要等待，会阻塞；

FutureTask：

二、CountDownLatch（“减法”计数器）

1、概述

官方文档介绍：

2、代码演示

代码实现：

package com.zibo.add;

import java.util.concurrent.CountDownLatch;

//线程计数器
public class TestCountDownLatch {
    public static void main(String[] args) throws InterruptedException {
        //创建线程计数器，初始化值为6，也就是说，倒数6条线程，走完结束
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "线程执行完了!");
                //线程执行完毕，线程计数器减1
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
        countDownLatch.await();//等待计数器归零，然后向下执行
        System.out.println("6个线程执行完毕！");
    }
}

运行结果：

0线程执行完了!
4线程执行完了!
3线程执行完了!
2线程执行完了!
1线程执行完了!
5线程执行完了!
6个线程执行完毕！

3、方法简述

countDown()：使得计数器数量减1；

await()：当计数器为0，继续执行下面的方法；

三、CyclicBarrier（“加法”计数器）

1、概述

官方文档介绍：

2、代码演示

（集齐7颗龙珠，召唤神龙！）

代码实现：

package com.zibo.add;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

//“加法”计数器
public class TestCyclicBarrier {
    public static void main(String[] args) {
        //创建计数器，参数1是计数数量，参数2是达到数量时执行的线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("召唤神龙！");
        });
        //走7条线程
        for (int i = 0; i < 7; i++) {
            int finalI = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "搜集了第" + finalI + "颗龙珠！");
                try {
                    cyclicBarrier.await();//等待
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

运行结果：

0搜集了第0颗龙珠！
4搜集了第4颗龙珠！
6搜集了第6颗龙珠！
3搜集了第3颗龙珠！
2搜集了第2颗龙珠！
1搜集了第1颗龙珠！
5搜集了第5颗龙珠！
召唤神龙！

四、Semaphore（计数信号量）

1、概述

官方文档介绍：

2、代码演示

（抢车位：6辆车，3个车位）

代码实现：

package com.zibo.add;

import java.util.concurrent.Semaphore;

//信号量
public class TestSemaphore {
    public static void main(String[] args) {
        //线程数量，停车位3个
        Semaphore semaphore = new Semaphore(3);
        //6个线程执行，6辆车
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                //acquire()：从信号量获取许可证
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "线程拿到许可证，抢到车位，停车！");
                    System.out.println(Thread.currentThread().getName() + "线程释放许可证，开车离开！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //release()：释放许可证，返回到信号量
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}

运行结果：

0线程拿到许可证，抢到车位，停车！
2线程拿到许可证，抢到车位，停车！
2线程释放许可证，开车离开！
1线程拿到许可证，抢到车位，停车！
1线程释放许可证，开车离开！
0线程释放许可证，开车离开！
3线程拿到许可证，抢到车位，停车！
3线程释放许可证，开车离开！
5线程拿到许可证，抢到车位，停车！
5线程释放许可证，开车离开！
4线程拿到许可证，抢到车位，停车！
4线程释放许可证，开车离开！