Java多线程知识点整理（CyclicBarrier、CountDownLatch、Callable、Future和FutureTask）

最新推荐文章于 2024-08-20 15:01:06 发布

转载最新推荐文章于 2024-08-20 15:01:06 发布 · 428 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/u/2380961/blog/1595836

文章标签：

#java #python

本文深入探讨了Java并发编程中的三大核心工具：CyclicBarrier、CountDownLatch及Callable与Future的使用方法和区别。通过实例代码展示了如何利用这些工具进行线程间的协调与数据交换，提高程序执行效率。

2019独角兽企业重金招聘Python工程师标准>>>

一、CyclicBarrier

CyclicBarrier从字面理解是指循环屏障，它可以协同多个线程，让多个线程在这个屏障前等待，直到所有线程都达到了这个屏障时，再一起继续执行后面的动作。

代码：

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierThread extends Thread{
	
	private CyclicBarrier cb;
	
	private int second;
	
	
	public CyclicBarrierThread(CyclicBarrier cb, int second) {
		
		this.cb = cb;
		this.second = second;
	}


	@Override
	public void run() {
		try {
			System.out.println("开始了!");
			Thread.sleep(second*1000);
			System.out.println("准备等待!"+System.currentTimeMillis());
			cb.await();
			System.out.println("结束了");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		Runnable runnable = new Runnable() {
			@Override
			public void run() {
				System.out.println("CyclicBarrier的所有线程await()结束了，我运行了, 时间为"+System.currentTimeMillis());
				
			}
		};
		 	CyclicBarrier cb = new CyclicBarrier(3, runnable);
		    CyclicBarrierThread cbt0 = new CyclicBarrierThread(cb, 3);
		    CyclicBarrierThread cbt1 = new CyclicBarrierThread(cb, 6);
		    CyclicBarrierThread cbt2 = new CyclicBarrierThread(cb, 9);
		    cbt0.start();
		    cbt1.start();
		    cbt2.start();
		
	}
	
}

运行的结果：

从代码的结果来看，先运行run方法，遇到await()之后，睡眠，然后在运行runnable的方法，然后再运行run方法进行结束。

从使用来看，可能有人觉得CyclicBarrier和CountDownLatch有点像，都是多个线程等待相互完成之后，再执行后面的代码。实际上，CountDownLatch和CyclicBarrier都是用于多个线程间的协调的，它们二者的几个差别是：

1、CountDownLatch是在多个线程都进行了latch.countDown()后才会触发事件，唤醒await()在latch上的线程，而执行countDown()的线程，执行完countDown()后会继续自己线程的工作；CyclicBarrier是一个栅栏，用于同步所有调用await()方法的线程，并且等所有线程都到了await()方法时，这些线程才一起返回继续各自的工作。

2、另外CountDownLatch和CyclicBarrier的一个差别是，CountDownLatch不能循环使用，计数器减为0就减为0了，不能被重置，CyclicBarrier可以循环使用。

3、CountDownLatch可以唤起多条线程的任务，CyclicBarrier只能唤起一条线程的任务。

注意，因为使用CyclicBarrier的线程都会阻塞在await方法上，所以在线程池中使用CyclicBarrier时要特别小心，如果线程池的线程过少，那么就会发生死锁了。

二、CountDownLatch

CountDownLatch主要提供的机制是当多个（具体数量等于初始化CountDownLatch时count参数的值）线程都达到了预期状态或完成预期工作时触发事件，其他线程可以等待这个事件来触发自己的后续工作。值得注意的是，CountDownLatch是可以唤醒多个等待的线程的。到达自己预期状态的线程会调用CountDownLatch的countDown方法，等待的线程会调用CountDownLatch的await方法。如果CountDownLatch初始化的count值为1，那么这就退化为一个单一事件了，即是由一个线程来通知其他线程，效果等同于对象的wait和notifyAll，count值大于1是常用的方式，目的是为了让多个线程到达各自的预期状态，变为一个事件进行通知，线程则继续自己的行为。

import java.util.concurrent.CountDownLatch;

public class WorkThread extends Thread{
	
	private CountDownLatch cdl;
    private int sleepSecond;
        
    public WorkThread(String name, CountDownLatch cdl, int sleepSecond)
    {
        super(name);
        this.cdl = cdl;
        this.sleepSecond = sleepSecond;
    }
     
    @Override
    public void run()
    {
        try
        {
            System.out.println(this.getName() + "启动了，时间为" + System.currentTimeMillis());
            Thread.sleep(sleepSecond * 1000);
            cdl.countDown();
            System.out.println(this.getName() + "执行完了，时间为" + System.currentTimeMillis());
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
    private static class DoneThread extends Thread
    {
        private CountDownLatch cdl;
            
        public DoneThread(String name, CountDownLatch cdl)
        {
            super(name);
            this.cdl = cdl;
        }
            
        public void run()
        {
            try
            {
                System.out.println(this.getName() + "要等待了, 时间为" + System.currentTimeMillis());
                cdl.await();
                System.out.println(this.getName() + "等待完了, 时间为" + System.currentTimeMillis());
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    }
        
    public static void main(String[] args) throws Exception
    {
        CountDownLatch cdl = new CountDownLatch(3);
        DoneThread dt0 = new DoneThread("DoneThread1", cdl);
        //DoneThread dt1 = new DoneThread("DoneThread2", cdl);
        dt0.start();
        //dt1.start();
        WorkThread wt0 = new WorkThread("WorkThread1", cdl, 2);
        WorkThread wt1 = new WorkThread("WorkThread2", cdl, 3);
        WorkThread wt2 = new WorkThread("WorkThread3", cdl, 4);
        wt0.start();
        wt1.start();
        wt2.start();
    }
	
	
	
	
}

运行结果：

这相当于是一种进化版本的等待/通知机制，它可以的实现的是多个工作线程完成任务后通知多个等待线程开始工作，之前的都是一个工作线程完成任务通知一个等待线程或者一个工作线程完成任务通知所有等待线程。

CountDownLatch其实是很有用的，特别适合这种将一个问题分割成N个部分的场景，所有子部分完成后，通知别的一个/几个线程开始工作。比如我要统计C、D、E、F盘的文件，可以开4个线程，分别统计C、D、E、F盘的文件，统计完成把文件信息汇总到另一个/几个线程中进行处理。

三、Callable、Future和FutureTask

3.1、Callable

Callable和rRunnable差不多，两者都是为那些其实例可能被另一个线程执行的类而设计的，最主要的差别在于Runnable不会返回线程运算结果，Callable可以（假如线程需要返回运行结果）。

3.2、Future

Future是一个接口表示异步计算的结果，它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。Future提供了get()、cancel()、isCancel()、isDone()四种方法，表示Future有三种功能：

1、判断任务是否完成

2、中断任务

3、获取任务执行结果

3.3、FutureTask

FutureTask是Future的实现类，它提供了对Future的基本实现。可使用FutureTask包装Callable或Runnable对象，因为FutureTask实现了Runnable，所以也可以将FutureTask提交给Executor。

使用方法

Callable、Future、FutureTask一般都是和线程池配合使用的，因为线程池ThreadPoolExecutor的父类AbstractExecutorService提供了三种submit方法：

1、public Future<?> subit(Runnable task){...}

2、public <T> Future<T> submit<Runnable task, T result>{...}

3、public <T> Future<T> submit<Callable<T> task>{...}

第2个用得不多，第1个和第3个比较有用。

代码：Callable和Future

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableThread implements Callable<String>{

	@Override
	public String call() throws Exception {
		System.out.println("开始了call方法"+System.currentTimeMillis());
		Thread.sleep(1000);
		return "sucess";
	}
	
	
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		 ExecutorService es = Executors.newFixedThreadPool(1);
		 
		 CallableThread callableThread = new CallableThread();
		 
		 Future<String> submit = es.submit(callableThread);
		 es.shutdown();
		 try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		 System.out.println("mian线程等待!");
		 String string = submit.get();
		 System.out.println(string);
	}
}

运行结果：

Callable+FutureTask使用示例：

public static class CallableThread implements Callable<String>
{
    public String call() throws Exception
    {
        System.out.println("进入CallableThread的call()方法, 开始睡觉, 睡觉时间为" + System.currentTimeMillis());
        Thread.sleep(10000);
        return "123";
    }
}
    
public static void main(String[] args) throws Exception
{
    ExecutorService es = Executors.newCachedThreadPool();
    CallableThread ct = new CallableThread();
    FutureTask<String> f = new FutureTask<String>(ct);
    es.submit(f);
    es.shutdown();
        
    Thread.sleep(5000);
    System.out.println("主线程等待5秒, 当前时间为" + System.currentTimeMillis());
        
    String str = f.get();
    System.out.println("Future已拿到数据, str = " + str + ", 当前时间为" + System.currentTimeMillis());
}

总结：使用Callable、Future和FutureTask的好处

上面演示了两个例子，其实反映的是现实中一种情况，把上面的例子稍微扩展一下就是：

有一个method()方法，方法中执行方法A返回一个数据要10秒钟，A方法后面的代码一共要执行20秒钟，但是这20秒的代码中有10秒的方法并不依赖方法A的执行结果，有10秒钟的代码依赖方法A的执行结果。此时若采用同步的方式，那么势必要先等待10秒钟，等待方法A执行完毕，返回数据，再执行后面20秒的代码。

不得不说这是一种低效率的做法。有了Callable、Future和FutureTask，那么：

1、先把A方法的内容放到Callable实现类的call()方法中

2、method()方法中，Callable实现类传入Executor的submit方法中

3、执行后面方法中10秒不依赖方法A运行结果的代码

4、获取方法A的运行结果，执行后面方法中10秒依赖方法A运行结果的代码

这样代码执行效率一下子就提高了，程序不必卡在A方法处。异步执行代码。

当然，也可以不用Callable，采用实现Runnable的方式，run()方法执行完了想个办法给method()方法中的某个变量V赋个值就好了。但是我上一篇文章开头就说了，之所以要用多线程组件，就是因为JDK帮我们很好地实现好了代码细节，让开发者更多可以关注业务层的逻辑。如果使用Runnable的方式，那么我们自己就要考虑很多细节，比如Runnable实现类的run()方法执行完毕给V赋值是否线程安全、10秒后如果A方法没有执行完导致V还没有值怎么办，何况JDK还给用户提供了取消任务、判断任务是否存在等方法。既然JDK已经帮我们考虑并实现这些细节了，在没有有说服力的理由的情况下，我们为什么还要自己写run()方法的实现呢？

转载于:https://my.oschina.net/u/2380961/blog/1595836