文章目录
- JUC
- 什么是JUC
- Callable 接口
- 理解 Callable
- 理解FutureTask
- ReentrantLock
- 信号量 Semaphore
- CountDownLatch
JUC
什么是JUC
JUC的全称为: java.util.concurrent.
JUC是Java并发工具包的一部分。它提供了一组并发编程工具和类，用于处理多线程编程和并发任务。
Callable 接口
这个接口非常类似于Runnable接口.
关于Runnable我们都知道,通过Runnable可以表示一个具体的任务,我们通过Runnable的run方法来描述接下来的代码要做什么事情.
Callable也是类似的效果,但是与Runnable相比,Callable提供了call方法,与Runnable的run方法相比,call方法带有返回值,而run方法是void.
因此,如果你是期望创建线程,让这个线程来返回一个结果,那么使用Callable要比Runnable要更方便一些.
比如说创建一个线程,让这个线程计算 1+2+3+…+1000.
使用Runnable的代码:
package javaEE.thread;
public class B {
private static int result;
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
int sum = 0;
for (int i = 0; i < 1000; i++) {
sum += i;
}
result = sum;
});
t.start();
t.join();
System.out.println(result);
}
}
使用Callable的代码:
package javaEE.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class C {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable<Integer> callable = new Callable<Integer>() {
@Override
public Integer call() {
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();
// FutureTask的作用:
// 后续我们需要使用FutureTask来拿到最后的结果.
// futureTask.get()就能拿到call方法的返回值
// futureTask.get()带有阻塞功能,当线程t还没执行完,get就会阻塞
// 直到t执行完毕,get才能返回.get就相当于"带有返回结果"的join.
System.out.println(futureTask.get());
}
}
注意:Thread不能传入Callable作为参数~
需要使用FutureTask传入Thread.
理解 Callable
Callable和Runnable相对,都是描述一个"任务",Callable描述的是带有返回值的任务,Runnable描述的是不带返回值的任务.
Callable通常需要搭配FutureTask来使用,FutureTask用来保存Callable的返回结果,因为Callable往往是在另一个线程中执行的,啥时候执行完并不确定.
FutureTask就可以负责这个等待结果出来的工作.
理解FutureTask
想象去吃麻辣烫,当餐点好后,后厨就开始做了,同时前台会给你一张"小票",这个小票就是FutureTask,后面我们可以随时凭这张小票来查看自己的这份麻辣烫做好了没.
ReentrantLock
ReentrantLock为可重入互斥锁.
ReentrantLock是一种经典风格的锁,它提供lock和unlock方法来完成加锁和解锁.
package javaEE.thread;
import java.util.concurrent.locks.ReentrantLock;
public class D {
private static int count = 0;
public static void main(String[] args) throws InterruptedException {
ReentrantLock locker = new ReentrantLock();
Thread t1 = new Thread(()->{
for (int i = 0; i < 50000; i++) {
locker.lock();
count++;
locker.unlock();
}
});
Thread t2 = new Thread(()->{
for (int i = 0; i < 50000; i++) {
locker.lock();
count++;
locker.unlock();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(count);
}
}
使用ReentrantLock时要保证unlock能被执行到~
我们在开发过程中大部分情况下都是使用synchronized就可以了,那为啥还要搞一个ReentrantLock呢?
ReentrantLock相比synchronized还是有一些区别差异的.
-
synchronized属于是关键字(底层是通过JVM的C++代码实现的).
ReentrantLock则是标准库提供的类,它是通过Java代码来实现的. -
synchronized通过代码块控制加锁解锁,ReentrantLock通过调用lock/unlock方法来完成.unlock可能会遗漏,所以一般要把unlock放到finally中.
-
ReentrantLock提供了tryLock这样的加锁风格,前面介绍的加锁,都是发现锁被别人占用了,就阻塞等待.
tryLock在加锁失败的时候,不会阻塞,而是直接返回,通过返回值来反馈是加锁成功还是失败.(相当于给了程序员更多的可操作空间) -
ReentrantLock还提供了公平锁的实现.默认为非公平锁,我们可以在构造方法中传入参数,把它设置成公平锁.
-
ReentrantLock还提供了功能更强的"等待通知机制".
synchronized是通过Object的wait/notify来实现等待-唤醒,每次唤醒的是一个随机等待的线程.
ReentrantLock搭配Condition类实现等待-唤醒,可以更精确的控制唤醒某个指定的线程.
ReentrantLock和synchronized分别在什么场景下使用?
- 锁竞争不激烈的时候,使用synchronized,效率更高,自动释放更方便.
- 锁竞争激烈的时候,使用ReentrantLock,搭配tryLock更灵活控制加锁的行为,而不是死等.
- 如果需要使用公平锁,使用ReentrantLock.
信号量 Semaphore
信号量,用来表示"可用资源的个数",本质上是一个计数器.
系统申请资源时计数器+1(也称为"P"操作),释放资源时计数器-1(也称为"V"操作).
如果计数器为0了,系统还尝试申请资源,此时就会出现阻塞,直到有其他线程释放资源.
Semaphore的PV操作中的加减计数器操作都是原子的,可以在多线程环境下直接使用.
操作系统本身提供了信号量实现,JVM把操作系统的信号量封装了一下~
package javaEE.thread;
import java.util.concurrent.Semaphore;
public class E {
public static void main(String[] args) throws InterruptedException {
// 括号里写的就是可用资源个数,计数器的初始值.
Semaphore semaphore = new Semaphore(3);
semaphore.acquire(); // 申请资源
System.out.println("申请资源");
semaphore.acquire(); // 申请资源
System.out.println("申请资源");
semaphore.acquire(); // 申请资源
System.out.println("申请资源");
semaphore.release(); // 释放资源
System.out.println("释放资源");
semaphore.acquire(); // 申请资源
System.out.println("申请资源");
}
}
我们也可以通过Semaphore来实现类似加锁的效果.
package javaEE.thread;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.ReentrantLock;
public class D {
private static int count = 0;
public static void main(String[] args) throws InterruptedException {
// ReentrantLock locker = new ReentrantLock(true);
// 设置可用资源数为1
Semaphore semaphore = new Semaphore(1);
Thread t1 = new Thread(()->{
for (int i = 0; i < 50000; i++) {
// locker.lock();
try {
semaphore.acquire(); // 申请一个资源
count++;
semaphore.release(); // 释放一个资源
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
// locker.unlock();
}
});
Thread t2 = new Thread(()->{
for (int i = 0; i < 50000; i++) {
// locker.lock();
try {
semaphore.acquire(); // 申请一个资源
count++;
semaphore.release(); // 释放一个资源
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
// locker.unlock();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(count);
}
}
运行结果为:100000.也是正确的~
CountDownLatch
同时等待N个任务结束.
很多时候,我们需要把一个大的任务,拆成多个小任务,使用多线程/线程池执行.
如何衡量,所有的任务都执行完毕了?
此时我们就可以使用CountDownLatch来达成这个效果.
package javaEE.thread;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class F {
public static void main(String[] args) throws InterruptedException {
// 通过线程池创建2个线程
ExecutorService executorService = Executors.newFixedThreadPool(2);
// 构造方法的数字,就是拆分出来的任务个数
CountDownLatch countDownLatch = new CountDownLatch(4);
for (int i = 0; i < 4; i++) {
int id = i;
executorService.submit(() -> {
System.out.println("任务" + id + "开始执行");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("任务" + id + "结束执行");
// 完毕 over!!
countDownLatch.countDown();
});
}
// 当countDownLatch收到了4个"完成",此时所有的任务就完成了.
// await => all wait
// await 这个词也是计算机术语,它在Python/js 中的意思是async wait(异步等待).在这里不是这个意思哦~
countDownLatch.await();
System.out.println("所有任务执行完毕");
}
}
本文到这里就结束了~
