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 call() throws Exception;
}
  • Callable的使用一般情况下是配合ExecutorService来使用,ExecutorService接口中声明了若干个submit方法的重载版本;
// 第一、第三个方法常用,第二个不常用
 Future submit(Callable task);
 Future submit(Runnable task, T result);
Future submit(Runnable task);

Future

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

        /**
         * 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 implements RunnableFuture
  • RunnableFuture接口的实现:
public interface RunnableFuture extends Runnable, Future {
    void run();
}
  • RunnableFuture继承了Runnable接口和Future接口;
  • FutureTask实现了RunnableFuture接口;
  • FutureTask既可以作为Runnable被线程执行,又可以作为Future得到Callable的返回值;
// 构造器
public FutureTask(Callable callable) {}
public FutureTask(Runnable runnable, V result) {}

你可能感兴趣的:(Java并发-CountDownLatch、CyclicBarrier、Semaphore、Runnable、Callable、Future、FutureTask总结记录)