文章目录
- [1. Callable 接口](#1. Callable 接口)
- [2. ReentrantLock](#2. ReentrantLock)
- [3. 信号量](#3. 信号量)
- [4. CountDownLatch](#4. CountDownLatch)
JUC这里就是指(java.util.concurrent)
concurrent 就是并发的意思
这个包里的内容,主要就是一些多线程相关的组件
1. Callable 接口
Callable 也是一种创建线程的方式
适合与想让某个线程执行一个逻辑,并且返回结果的时候
相比之下,Runnable 不关注结果
这个和Runnable 方法很像
call 方法是 Callable 中的核心方法
返回值就是 Integer,期望值这个线程能够返回一个整数
java
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():解锁
java
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 代码中使用了
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 ,我当前这一个子任务已经完成
java
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,这里就会进行阻塞