Callable 和 Runnable 相对, 都是描述一个 "任务". Callable 描述的是带有返回值的任务, Runnable描述的是不带返回值的任务.
Callable 通常需要搭配 FutureTask 来使用. FutureTask 用来保存 Callable 的返回结果. 因为Callable 往往是在另一个线程中执行的, 啥时候执行完并不确定.
FutureTask 就可以负责这个等待结果出来的工作

2.与Runnable的区别与联系

Callable 是一个 interface . 相当于把线程封装了一个 "返回值". 方便程序猿借助多线程的方式计算结果
Callable 和 Runnable 相对, 都是描述一个 "任务". Callable 描述的是带有返回值的任务, Runnable描述的是不带返回值的任务.
Callable 通常需要搭配 FutureTask 来使用. FutureTask 用来保存 Callable 的返回结果. 因为Callable 往往是在另一个线程中执行的, 啥时候执行完并不确定.
FutureTask 就可以负责这个等待结果出来的工作

3.Callable创建线程

具体步骤：

1）定义一个Callable对象，重写带返回值的call方法

2）创建一个FutureTask未来任务对象

3）将任务交给线程执行

4）接收返回值，当前线程阻塞等待FutureTask任务执行完成，并获取结果

package day20220325;

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

public class CallableTest 
    public static void main(String[] args) throws ExecutionException, InterruptedException 
        Callable<Integer> callable = new Callable<Integer>() 

            @Override
            public Integer call() throws Exception 
                int i = 1;
                i = i + 1;
                return  i;
            
        ;
        FutureTask<Integer> task = new FutureTask<>(callable);
        Thread thread = new Thread(task);
        thread.start();
        System.out.println(task.get());

二，CountDownLatch

1.理解

同时等待 N 个任务执行结束.
好像跑步比赛，10个选手依次就位，哨声响才同时出发；所有选手都通过终点，才能公布成绩

2.构造

构造 CountDownLatch 实例, 初始化 10 表示有 10 个任务需要完成.
每个任务执行完毕, 都调用 latch.countDown() . 在 CountDownLatch 内部的计数器同时自减.
主线程中使用 latch.await(); 阻塞等待所有任务执行完毕. 相当于计数器为 0 了.

3.使用场景

等待多个线程全部执行完，在执行某个任务（只能减少，不能增加）

4.实现

package day20220325;

import java.util.concurrent.CountDownLatch;

public class MyCountDownLatch 
    public static void main(String[] args) throws InterruptedException 
        CountDownLatch count = new CountDownLatch(10);
        for(int i = 0;i < 10;i++)
            int j = i;
            new Thread(new Runnable() 
                @Override
                public void run() 
                    System.out.println(j);
                    count.countDown();
                
            ).start();
        
        count.await();
        System.out.println("main");

三，Semaphore

1.理解

信号量, 用来表示 "可用资源的个数". 本质上就是一个计数器.
Semaphore 的 PV 操作中的加减计数器操作都是原子的, 可以在多线程环境下直接使用

理解信号量

可以把信号量想象成是停车场的展示牌: 当前有车位 100 个. 表示有 100 个可用资源.

当有车开进去的时候, 就相当于申请一个可用资源, 可用车位就 -1 (这个称为信号量的 P 操作)

当有车开出来的时候, 就相当于释放一个可用资源, 可用车位就 +1 (这个称为信号量的 V 操作)

如果计数器的值已经为 0 了, 还尝试申请资源, 就会阻塞等待, 直到有其他线程释放资源.

2.构造

3.实现

package day20220325;

import java.util.concurrent.Semaphore;

public class MySemaphore 
    public static void main(String[] args) 
        Semaphore semaphore = new Semaphore(4);
        Runnable runnable = new Runnable() 
            @Override
            public void run() 
                try 
                    System.out.println("申请资源");
                    semaphore.acquire();
                    System.out.println("我获取到资源了");
                    Thread.sleep(1000);
                    System.out.println("我释放资源了");
                    semaphore.release();
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
            
        ;
        for (int i = 0; i < 20; i++) 
            Thread t = new Thread(runnable);
            t.start();