目录
Callable
ReentrantLock
Semaphore
CountDownLatch
JUC即 java.util.concurrent，其中存放了一些进行多线程编程时有用的类
Callable
Callable是一个接口，在我们实现Runnable创建线程时，Runnable关注的是其过程，而不关注其执行结果（其返回值为void），而Callable会关注执行结果，Callable提供了call方法，其返回值就是线程执行任务得到的结果
因此，当我们在编写多线程代码时，希望得到线程种代码的返回值时，就可以使用Callable
例如：一个线程需要实现 1 + 2 + 3 + ... + 100，并返回其结果
若我们使用实现Runnable的方式创建线程时：
public class Demo1 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
int ret = 0;
for (int i = 1; i <= 100; i++) {
ret += i;
}
}
});
t.start();
t.join();
}
}若此时主线程需要获取到其计算结果，则需要使用一个成员变量来保存结果
public class Demo1 {
private static int sum = 0;
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
int ret = 0;
for (int i = 1; i <= 100; i++) {
ret += i;
}
sum = ret;//保存结果
}
});
t.start();
t.join();
System.out.println(sum);
}
}而若我们使用Callable时：
Callable<V> 其中泛型参数表示返回值的类型
Callable<Integer> callable = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
int ret = 0;
for (int i = 1; i <= 100; i++) {
ret += i;
}
return ret;
}
};此时就不必引入额外的成员变量了，直接使用返回值即可
然而，Thread未提供构造函数来传入callable
此时，我们需要使用 FutureTask 来作为Thread和callable的“粘合剂”
将callable实例使用FutureTask包装一下，再在构造方法传入FutureTask：
此时线程就会执行FutureTask内部的Callable中的call方法，计算完成后，就将结果放入FutureTask对象中
FutureTask<V> 泛型参数表示结果的类型
此时在主线程中调用FutureTask中的get()方法（带有阻塞功能），等待计算完毕，从FutureTask中获取到结果
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Demo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable<Integer> callable = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
int ret = 0;
for (int i = 1; i <= 100; i++) {
ret += i;
}
return ret;
}
};
FutureTask<Integer> futureTask = new FutureTask<>(callable);
Thread t = new Thread(futureTask);
t.start();
//此时无需使用join,使用futureTask中的get()方法获取到结果
System.out.println(futureTask.get());
}
}观察两种实现方式，我们可以发现：
使用Callable和FutureTask，使代码简化了很多，且不用使用成员变量来保存结果
Callable和Runnable相对，都是描述一个“任务”，Callable描述的是带有返回值的任务，Runnable描述的是不带返回值的任务
Callable通常需要搭配FutureTask使用，FutureTask用来保存Callable的返回结果
ReentrantLock
ReentrantLock是一种可重入互斥锁，与synchronized类似，都是用来实现互斥效果，保证线程安全的
ReentrantLock的用法：
lock()：加锁，若获取不到锁就死等
unlock()：解锁
tryLock(超时时间)：加锁，若获取不到锁，等待时间一定后就放弃加锁
当我们在使用ReentrantLock时，需要加锁和解锁两个操作，因此当我们在加锁后，很容易忘记解锁，例如在unlock之前，触发了异常 或 return语句，此时就可能不会执行unlock
因此，为了保证unlock的执行，我们可以将其放在finally中
例如：
ReentrantLock lock = new ReentrantLock();
lock.lock();
try{
//执行代码
}finally {
lock.unlock();
}synchronzied使用时无需手动释放锁，ReentrantLock使用时需要手动释放，使用起来更加灵活，但也容易漏掉unlock
为什么有了synchronized后，还有ReentrantLock?
1. ReentrantLock提供了tryLock操作。lock直接进行加锁，当加锁失败时，就阻塞，而tryLock尝试进行加锁，若加锁失败，等待一定时间后，不阻塞，直接放弃加锁，返回 false，表示加锁失败
2. ReentrantLock提供了公平锁的实现（遵循“先来后到”规则，即等待时间长的线程先获取到锁）。通过队列来记录加锁线程的先后顺序，ReentrantLock默认是非公平锁，在构造方法中传入true 则可设置为公平锁
3. 更强大的唤醒机制。synchronized，搭配wait和notify来实现等待唤醒，每次随机唤醒一个等待的线程；而ReentrantLock，搭配Condition类来实现通知等待机制，可以更精确控制唤醒某个指定的线程
Semaphore
信号量Semaphore，用来表示“可用资源的个数”，其本质就是一个计数器
当申请资源时，可用资源数 -1（信号的P操作）
当释放资源时，可用资源数 +1（信号的V操作）
Semaphore中的加减计算操作都是原子的，可以在多线程环境下直接使用
信号量也是操作系统提供的机制，JVM对其对应的API进行封装，因此我们可用直接通过Java代码来调用这里的相关操作
Semaphore类中acquire()方法表示申请资源（P操作），release()方法表示释放资源（V操作）
例如：
public class Demo2 {
public static void main(String[] args) {
Semaphore semaphore = new Semaphore(5);//有5个可用资源
for (int i = 0; i < 10; i++) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
try{
System.out.println("申请资源");
semaphore.acquire();
System.out.println("获取到资源");
Thread.sleep(1000);
System.out.println("释放资源");
semaphore.release();
}catch (InterruptedException e){
e.printStackTrace();
}
}
});
t.start();
}
}
}
CountDownLatch
同时等待多个任务执行结束
例如，构造CountDownLatch实例latch，初始化n表示有n个任务需要完成。
在任务执行完毕时，调用countDown()方法，告知latch当前任务执行完毕，则CountDownLatch内部的计数器 -1
在主线程中调用latch.await()，阻塞等待所有任务都执行完毕（计数器为0）
import java.util.Random;
import java.util.concurrent.CountDownLatch;
public class Demo3 {
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(10);//此时有10个任务需要完成
for (int i = 0; i < 10; i++) {
int id = i;
Thread t = new Thread(()->{
Random random = new Random();
int time = (random.nextInt(5) + 1) * 1000;//执行任务的时间
try {
Thread.sleep(time);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(id + "任务执行结束");
//告知latch执行结束
latch.countDown();
});
t.start();
}
//通过await来等待所有任务执行结束
latch.await();
System.out.println("所有任务都已执行完成");
}
}
