目录
1.JUC
1.Callable接口（描述线程任务的接口）
2.Callable接口和Runnable接口区别
2.Reentrant Lock
1.演示基本方法
2.出现异常，如何确保释放锁
3.创建一个公平锁
4.创建一个读写锁
3.Reentrant Lock和Synchronized的区别
4.原子性
5.JUC工具类常用类
1.Semaphore-信号量
以停车场为例
2.CountDownLatch
以颁奖为例
3.CycliBarrier-循环栅栏
1.JUC
java.util.concurrent 包的简称，JDK1.5之后对多线程的一种实现，这个包下放的类都与多线程有关，提供了很多工具类
1.Callable接口（描述线程任务的接口）
用Callable接口创建一个线程
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Callable01 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable<Integer> callable = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println("我是Callable实现的Call方法");
int res = 0;
for (int i = 0; i < 10; i+=2) {
res += i;
}
return res;
}
};
FutureTask<Integer> futureTask = new FutureTask<>(callable);
Thread thread = new Thread(futureTask);
thread.start();
System.out.println(futureTask.get());
}
}
2.Callable接口和Runnable接口区别
1.Callable实现的是Call方法，Runnable实现的是Run方法
2.Callable可以返回一个结果，Runnable没有返回值
3.Callable需要搭配Future task一起使用，Future Task是一个实现了Runnable接口的子类，所以Callable也可以传入Thread
4.Callable可以抛出异常，Runnable不可以
2.Reentrant Lock
是基于CAS实现的一个纯用户态的锁
1.常用的方法：
1.演示基本方法
public static void main(String[] args) throws InterruptedException {
ReentrantLock reentrantLock = new ReentrantLock();
//加锁
reentrantLock.lock();
//死等
reentrantLock.tryLock();
//等一秒
reentrantLock.tryLock(1, TimeUnit.SECONDS);
//释放锁
reentrantLock.unlock();
}2.出现异常，如何确保释放锁
public static void main(String[] args) throws Exception {
ReentrantLock reentrantlock = new ReentrantLock();
reentrantlock.lock();
try {
//模拟业务出现异常
throw new Exception("出现错误！");
}finally {
//无论是否出现异常，锁一定会释放
reentrantlock.unlock();
}
}3.创建一个公平锁
ReentrantLock reentrantLock1 = new ReentrantLock(true);4.创建一个读写锁
public static void main(String[] args) {
//创建
ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
//获取读锁
reentrantReadWriteLock.readLock();
//获取写锁
reentrantReadWriteLock.writeLock();
}3.Reentrant Lock和Synchronized的区别
4.原子性
Java.util.concurrent.atomic包下
5.JUC工具类常用类
1.Semaphore-信号量
指定了资源的数量，申请资源的时候，如果没有空闲资源，那么当前申请资源的线程就必须等待
Semaphore 的 PV 操作中的加减计数器操作都是原子的, 可以在多线程环境下直接使用.
遇到需要指定有限的资源个数时，可以考虑使用Semaphore来处理
以停车场为例
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
public class Demo03 {
private static Semaphore semaphore = new Semaphore(3);
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
int flag = i+1;
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("车辆"+flag+"尝试获取资源");
semaphore.acquire();
System.out.println("车辆"+flag+"获取到了资源");
TimeUnit.SECONDS.sleep(1);
semaphore.release();
System.out.println("车辆"+flag+"释放了资源");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
}
}
}
2.CountDownLatch
CountDownLatch的作用就是可以设置所有的线程都必须到达某一个关键点，然后再执行后续的操作
使用场景：把一个大任务分成若干个小任务，或者是等待一写前置资源的时候，可以考虑用Count DownLoach
以颁奖为例
- 构造 CountDownLatch 实例, 初始化 10 表示有 10 个任务需要完成.
- 每个任务执行完毕, 都调用 latch.countDown() . 在 CountDownLatch 内部的计数器同时自减.
- 主线程中使用 latch.await(); 阻塞等待所有任务执行完毕. 相当于计数器为 0 了.
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public class Demo04 {
public static void main(String[] args) throws InterruptedException {
CountDownLatch count = new CountDownLatch(10);
for (int i = 0; i < 10; i++) {
int flag = i+1;
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("运动员"+flag+"号已出发");
TimeUnit.SECONDS.sleep(1);
System.out.println("运动员"+flag+"号已到达");
count.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
}
count.await();
System.out.println("开始颁奖");
}
}
3.CycliBarrier-循环栅栏
是CountDown Latch的进级版，可以实现线程之间的相互等待
