Java并发-CountDownLatch、CyclicBarrier、Semaphore、Runnable、Callable、Future、FutureTask总结记录

1、CountDownLatch、CyclicBarrier、Semaphore，都位于java.util.concurrent包中，是并发控制的辅助类，可以控制线程的协同工作；
2、Runnable（java.lang.Runnable）、Callable（java.util.concurrent），作为线程创建相关类；
3、Future（java.util.concurrent），是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。
4、FutureTask（java.util.concurrent），是Future接口的一个唯一实现类；

CountDownLatch

• 一主和一组线程，主线程阻塞，等待所有子线程执行完成，但是子线程并不会阻塞；
• 主线程初始化指定计数器 CountDownLatch latch = new CountDownLatch(5)；
• 主线程开始循环启用一组子线程；
• 主线程中，使用latch.await()阻塞，等待整组子线程全部执行完成；
• 子线程接受主线程中的latch作为构造函数；
• 子线程工作完成后调用latch.countDown()将计数器减一，子线程不阻塞，继续后续操作；
• 计数器值为0后，主线程结束阻塞状态，并开始后续操作；

// 只有一个构造器
// 参数count为计数值
public CountDownLatch(int count) {  };  

// 最重要的方法
// 调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public void await() throws InterruptedException { };   
// 和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  
// 将count值减1
public void countDown() { };  

CyclicBarrier

• 一组线程互相等待，都达到指定状态时，再同步执行，整组线程有阻塞；
• 主线程只完成初始化，没有其他操作，CyclicBarrier barrier = new CyclicBarrier(5)
• 子线程接收主线程的barrier作为构造函数参数；
• 子线程中执行 barrier.await()，子线程阻塞等待；
• 所有子线程到达await()之后，再继续后续操作；

// 两个构造函数
// parties指让多少个线程或者任务等待至barrier状态
public CyclicBarrier(int parties) {}
// 参数barrierAction为当这些线程都达到barrier状态时会执行的内容
public CyclicBarrier(int parties, Runnable barrierAction) {}

// await()的两个重载版本
// 比较常用，用来挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务
public int await() throws InterruptedException, BrokenBarrierException { };
// 让这些线程等待至一定的时间，如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };

Semaphore

• 信号量，可以控同时访问的线程个数；

//参数permits表示许可数目，即同时可以允许多少线程进行访问
public Semaphore(int permits) {         
    sync = new NonfairSync(permits);
}
//这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
public Semaphore(int permits, boolean fair) {    
    sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}

• 通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可；
• acquire()、release()会阻塞进程；
• 有tryAcquire()，可以避免获取时阻塞；

/**
* 以下四个接口会阻塞进程
*/
//获取一个许可
public void acquire() throws InterruptedException {  }     
//获取permits个许可
public void acquire(int permits) throws InterruptedException { }    
//释放一个许可
public void release() { }          
//释放permits个许可
public void release(int permits) { }    

/**
* 以下四个接口不会阻塞进程
*/
//尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire() { };    
//尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };  
//尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(int permits) { }; 
//尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; 

Runnable

• 是一个接口，只声明了一个run()方法；
• run()方法返回值为void类型，所以在执行完任务之后无法返回任何结果；
• runnable不会返回结果，并且无法抛出返回结果的异常；

public interface Runnable {
    public abstract void run();
}

Callable

• 是一个泛型接口，只声明了一个call()方法；
• call()函数返回的类型就是传递进来的V类型；
• 该方法有一个泛型返回值类型，可以任意指定，这个返回值可以被Future拿到；

public interface Callable<V> {
    V call() throws Exception;
}

• Callable的使用一般情况下是配合ExecutorService来使用,ExecutorService接口中声明了若干个submit方法的重载版本；

// 第一、第三个方法常用，第二个不常用
<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

Future

• 是一个接口；
• 对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果；
• Future提供了三种功能：
  – 判断任务是否完成；
  – 能够中断任务；
  – 能够获取任务执行结果。

    public interface Future<V> {

        /**
         * 1、用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。
         * 2、参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。
         * 3、如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；
         * 4、如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；
         * 5、如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
         */
        boolean cancel(boolean mayInterruptIfRunning);

        /**
         * 任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true
         */
        boolean isCancelled();

        /**
         * 表示任务是否已经完成，若任务完成，则返回true
         */
        boolean isDone();

        /**
         * 1、获取执行结果;
         * 2、这个方法会产生阻塞，会一直等到任务执行完毕才返回;
         */
        V get() throws InterruptedException, ExecutionException;

        /**
         * 1、获取执行结果;
         * 2、如果在指定时间内，还没获取到结果，就直接返回null；
         */
        V get(long timeout, TimeUnit unit)
                throws InterruptedException, ExecutionException, TimeoutException;
    }

FureTask

• FutureTask类实现了RunnableFuture接口

public class FutureTask<V> implements RunnableFuture<V>

• RunnableFuture接口的实现：

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

• RunnableFuture继承了Runnable接口和Future接口；
• FutureTask实现了RunnableFuture接口；
• FutureTask既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值；

// 构造器
public FutureTask(Callable<V> callable) {}
public FutureTask(Runnable runnable, V result) {}

最后

以上就是纯真小霸王为你收集整理的Java并发-CountDownLatch、CyclicBarrier、Semaphore、Runnable、Callable、Future、FutureTask总结记录的全部内容，希望文章能够帮你解决Java并发-CountDownLatch、CyclicBarrier、Semaphore、Runnable、Callable、Future、FutureTask总结记录所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。