文章目录
- 1. Callable 接口
- 2. ReentrantLock
- 3. 信号量
- 4. CountDownLatch
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 就相当于拿着小票换执行结果
这个时候我们创建线程的方式有增加了一种
线程创建的方式：
- 继承 Thread，重写 run（创建单独的类，也可以匿名内部类）
- 实现 Runnable，重写 run（创建单独的类，也可以匿名内部类）
- 实现 Callable，重写 call（创建单独的类，也可以匿名内部类）
- 使用 lambda 表达式
- ThreadFactory 线程工厂
- 线程池
2. ReentrantLock
可重⼊互斥锁，和 synchronized 定位类似，都是⽤来实现互斥效果，保证线程安全
ReentrantLock 的⽤法：
• lock()：加锁，如果获取不到锁就死等
• trylock(超时时间)：加锁，如果获取不到锁，等待⼀定的时间之后就放弃加锁
• unlock()：解锁
ReentrantLock lock = new ReentrantLock();
-----------------------------------------
lock.lock();
try {
// working
} finally {
lock.unlock()
}
ReentrantLock 的优势：
- ReentrantLock ，在加锁的时候，有两种方式
lock，tryLock（给了更多的可操作空间） - ReentrantLock ，提供了公平锁的实现（默认情况下是非公平锁）
- 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 主要有两个方法：
- await ，调用的时候就会阻塞，就会等待其他的线程完成任务，所有的线程都完成了任务之后，此时这个 await 才会返回，才会继续往下走
- 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，这里就会进行阻塞
