JUC这里就是指（java.util.concurrent）
concurrent 就是并发的意思
这个包里的内容，主要就是一些多线程相关的组件

1. Callable 接口

Callable 也是一种创建线程的方式
适合与想让某个线程执行一个逻辑，并且返回结果的时候
相比之下，Runnable 不关注结果

这个和Runnable 方法很像
call 方法是 Callable 中的核心方法
返回值就是 Integer，期望值这个线程能够返回一个整数

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

public class ThreadDemo35 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //定义了任务
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i <= 1000; i++) {
                    sum += i;
                }
                return sum;
            }
        };
        //把任务放到线程中进行执行
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();

        //此处的 get 就能获取到 callable 里面的返回结果
        //由于线程是并发执行的，执行到主线的 get 的时候，t 线程可能还没执行完
        //没执行完的话，get 就会阻塞
        System.out.println(futureTask.get());
    }
}

futureTask 在这里就是相当于让一个线程跑起来，我们来等待结果

就相当于去吃饭，扫码点单后会给你一个小票，可以凭小票取餐
点餐完成后，后厨就相当于一个线程，就开始执行了
这个过程中，我们需要等出餐
等餐好了，就可以那小票取餐

这个时候 futureTask 就相当于拿着小票换执行结果

---

这个时候我们创建线程的方式有增加了一种

线程创建的方式：

1. 继承 Thread，重写 run（创建单独的类，也可以匿名内部类）
2. 实现 Runnable，重写 run（创建单独的类，也可以匿名内部类）
3. 实现 Callable，重写 call（创建单独的类，也可以匿名内部类）
4. 使用 lambda 表达式
5. ThreadFactory 线程工厂
6. 线程池

2. ReentrantLock

可重⼊互斥锁，和 synchronized 定位类似，都是⽤来实现互斥效果，保证线程安全

ReentrantLock 的⽤法：
• lock()：加锁，如果获取不到锁就死等
• trylock(超时时间)：加锁，如果获取不到锁，等待⼀定的时间之后就放弃加锁
• unlock()：解锁

ReentrantLock lock = new ReentrantLock();
-----------------------------------------
lock.lock();
try {
	// working
} finally {
	lock.unlock()
}

---

ReentrantLock 的优势：

1. ReentrantLock ，在加锁的时候，有两种方式
   lock，tryLock（给了更多的可操作空间）
2. ReentrantLock ，提供了公平锁的实现（默认情况下是非公平锁）
3. ReentrantLock 提供了更强大的等待通知机制
   搭配了Condition 类，实现等待通知，可以更精确控制唤醒某个指定的线程

虽然 ReentrantLock 有上述优势，但是在加锁的时候，首选还是 synchronized
但是很明显，ReentrantLock 使用更复杂，尤其容易忘记解锁

3. 信号量

信号量也是操作系统中，比较重要的概念

信号量，就是一个计数器，描述了“可用资源”的个数

---

举个栗子：
可以把信号量想象成是停⻋场的展⽰牌：
当前有⻋位 100 个，表⽰有 100 个可⽤资源
当有⻋开进去的时候，就相当于申请⼀个可⽤资源，可⽤⻋位就 -1 (这个称为信号量的 P 操作)
当有⻋开出来的时候，就相当于释放⼀个可⽤资源，可⽤⻋位就 +1 (这个称为信号量的 V 操作)
如果计数器的值已经为 0 了，还尝试申请资源，就会阻塞等待，直到有其他线程释放资源

---

英语中 P 操作 用 acquire
V 操作 用 release

---

锁，本质上就是属于一种特殊的信号量
锁就是 可用资源为 1 的信号量
加锁操作，P 操作，1 变成 0
解锁操作，V 操作，0 变成 1
这其实就是二元信号量

---

操作刺痛，提供了 信号量 实现，提供了 api，JVM 封装了这样的 api，就可以在 java 代码中使用了

public class ThreadDemo36 {
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore = new Semaphore(4);
        semaphore.acquire();
        System.out.println("P 操作");
        semaphore.acquire();
        System.out.println("P 操作");
        semaphore.acquire();
        System.out.println("P 操作");
        semaphore.acquire();
        System.out.println("P 操作");
        semaphore.acquire();
        System.out.println("P 操作");
        //semaphore.release();
    }
}

这里第五次操作会堵塞

开发中如果遇到了需要申请资源的常见，就可以使用信号量来实现

4. CountDownLatch

CountDownLatch 主要是适用于，多个线程来完成一系列任务的时候，用来衡量任务的进程是否完成
比如把一个大的任务，拆分成多个小的任务，让这些任务并发的去执行

就可以使用 CountDownLatch 来判定说当前这些任务是否都完成了

---

下载一个文件，就可以使用多线程下载
在我们的生活中，很多下载工具的下载速度很慢
相比之下，有一些专业的下载工具，就可以成倍的提升（比如 IDM）

这个时候普通的下载软件，往往和资源服务器，只有一个链接，服务器往往会对于链接传输的速度有限制
而专业的软件，往往是多线程下载，每个线程都建立一个链接，此时就需要把任务进行分割

---

CountDownLatch 主要有两个方法：

1. await ，调用的时候就会阻塞，就会等待其他的线程完成任务，所有的线程都完成了任务之后，此时这个 await 才会返回，才会继续往下走
2. countDown ，告诉 CountDownLatch ，我当前这一个子任务已经完成

public class ThreadDemo37 {
    public static void main(String[] args) throws InterruptedException {
        //10 个选手参赛，await 就会在 10次调用完 countDown 之后才能继续执行
        CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i = 0; i < 10; i++) {
            int id = i;
            Thread t = new Thread(() -> {
                System.out.println("thread " + id);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                //通知说当前的任务执行完毕了
                countDownLatch.countDown();
            });
            t.start();
        }
        countDownLatch.await();
        System.out.println("所有的任务都完成了");
    }
}

如果是 i < 9，这里就会进行阻塞