Loading...
墨滴

楼仔

2021/05/20  阅读:16  主题:橙心

【Java并发编程系列6】同步工具类

主要讲解Java常用的同步工具类,包括闭锁/FutureTask/信号量/栅栏,最后还对“创建线程的三种方式”进行简单的扫盲。

前言

《Java并发编程实战》这本书看到第五章了,里面的同步工具类感觉比较常用,就简单总结一下。不过在讲“同步工具类”前,大家需要对创建线程的三种方法非常清楚,如果这个不清楚的话,直接看示例可能不太懂,文章最后面有“创建线程的三种方式”内容,已经给Java小白扫盲,谁让楼哥是暖男呢。

同步工具类

闭锁

用途:可用于命令一组线程在同一个时刻开始执行某个任务,或者等待一组相关的操作结束,尤其适合计算并发执行某个任务的耗时。

public class CountDownLatchTest {
    public void timeTasks(int nThreads, final Runnable task) throws InterruptedException {
        final CountDownLatch startGate = new CountDownLatch(1);
        final CountDownLatch endGate = new CountDownLatch(nThreads);

        for (int i = 0; i < nThreads; i++) {
            Thread t = new Thread() {
                @Override
                public void run()  {
                    try {
                        // 阻塞,等待startGate.countDown()的执行
                        startGate.await();
                        try {
                            task.run();
                        } finally {
                            // 每次执行完毕后,计数器减1,表示有一个事件已经完成
                            endGate.countDown();
                        }
                    } catch(InterruptedException e) {
                        System.out.println("Throw Exception, e:" + e.toString());
                    }
                }
            };
            // 启动线程
            t.start();
        }

        long start = System.nanoTime();
        System.out.println("打开闭锁");
        startGate.countDown(); // 打开开关,进入startGate.await()后面的逻辑
        endGate.await(); // 等待所有线程endGate.countDown()全部执行完毕
        long end = System.nanoTime();
        System.out.println("闭锁退出,共耗时" + (end-start));
    }

    class RunnableTask implements Runnable {
        @Override
        public void run() {
            System.out.println("当前线程为:" + Thread.currentThread().getName());
        }
    }

    public static void main(String args[]) throws InterruptedException {
        CountDownLatchTest test = new CountDownLatchTest();
        test.timeTasks(5, test.new RunnableTask());
    }
}
// 输出:
// 打开闭锁
// 当前线程为:Thread-0
// 当前线程为:Thread-2
// 当前线程为:Thread-1
// 当前线程为:Thread-3
// 当前线程为:Thread-4
// 闭锁退出,共耗时1985771

里面的注释其实已经很清晰了,简单总结一下流程:

  1. 初始化startGate和endGate的计数器,分别为1和5;
  2. 开启5个线程,去执行RunnableTask任务;
  3. 5个线程启动后,会全部阻塞在startGate.await();
  4. 当调用startGate.countDown(),startGate计数器为0,线程阀门放开,开始一起去执行每个线程任务task.run();
  5. 每个线程执行完毕后,会调用endGate.countDown(),每调用一次,endGate的计数器减去1,线程执行过程中,主线程通过endGate.await()阻塞;
  6. 当所有线程执行完毕,endGate计数器为0,主线程endGate.await()阻塞放开,执行后面收尾流程,流程结束。

这个和Go的sync.WaitGroup,简直一毛一样啊!看来语言的设计,很多都差不多。

FutureTask

FutureTask也可以用作闭锁,它是通过Callabale来实现,相当于一种可以生成结果的Runnable,并且可以处于以下3种状态:等待状态,正在运行和运行完成。Future.get的行为取决于任务的状态,如果任务已经完成,那么get会立即返回结果,否则get将阻塞到任务进入完成状态,然后返回结果或者抛出异常。

@Data
@Service
public class Cat {
    private String catName;
}

public class Preloader {
    private final FutureTask<Cat> future = new FutureTask<Cat>(new Callable<Cat>() {
        @Override
        public Cat call() throws InterruptedException {
            Cat cat = new Cat();
            cat.setCatName("罗小黑");
            for (int i = 1; i <= 5; i ++) {
                // 睡眠1秒,方便大家看执行效果
                Thread.sleep(1000L);
                System.out.println("Sleep " + i + " 秒");
            }
            return cat;
        }
    });

    private final Thread thread = new Thread(future);

    public void start() {
        System.out.println("启动Start");
        thread.start();
    }

    public Cat get() throws ExecutionException, InterruptedException {
        Cat cat = null;
        try {
            System.out.println("开始获取数据!");
            // 阻塞,等待线程执行完毕
            cat = future.get();
            System.out.println("获取数据成功!");
        } catch (ExecutionException e) {
            // 异常处理,省略...
        }
        return cat;
    }
    
    public static void main(String args[]) throws ExecutionException, InterruptedException {
        Preloader preloader = new Preloader();
        preloader.start();
        Cat cat = preloader.get();
        System.out.println(cat.toString());
    }
}
// 输出:
// 启动Start
// 开始获取数据!
// Sleep 1 秒
// Sleep 2 秒
// Sleep 3 秒
// Sleep 4 秒
// Sleep 5 秒
// 获取数据成功!
// Cat(catName=罗小黑)

我们可以看到,获取Cat数据时,主线程一直阻塞住,直到Cat成功构造好数据后,才正常返回,简单总结一下流程:

  1. 初始化线程对象Thread和FutureTask静态对象,其中FutureTask的Callable是构造Cat数据;
  2. 启动线程thread.start(),开始执行future中Callable.call()方法,开始构造Cat数据;
  3. 在Cat数据构造成功前,future.get()会一直阻塞,直到future中Callable.call()成功返回,阻塞结束。

信号量

用途:用来控制同时访问某个特定资源的操作数量,或者同时执行某个指定操作的数量。计数信号量可以用来实现某种资源池,或者对容器施加边界。

public class SemaphoreTest<T{
    public final Set<T> set;

    private final Semaphore sema;

    public SemaphoreTest(int bound){
        this.set = Collections.synchronizedSet(new HashSet<T>());
        this.sema = new Semaphore(bound);
    }

    public boolean add(T o) throws InterruptedException{
        sema.acquire();
        boolean wasAdded = false;
        try{
            wasAdded = set.add(o);
            return wasAdded;
        }finally{
            if(!wasAdded){
                sema.release();
            }
        }
    }

    public boolean remove(T o){
        boolean wasRemoved = set.remove(o);
        if(wasRemoved){
            sema.release();
        }
        return wasRemoved;
    }

    public static void main(String[] args) throws InterruptedException{
        int permits = 5;
        SemaphoreTest<Integer> test = new SemaphoreTest<Integer>(permits);
        for(int i = 0; i < 10; i++){
            test.add(i);
            System.out.println("set:" + test.set);
        }
    }
}
// 输出:
// set:[0]
// set:[0, 1]
// set:[0, 1, 2]
// set:[0, 1, 2, 3]
// set:[0, 1, 2, 3, 4]

这个示例就很简单,描述一下流程:

  1. 先初始化信号量sema的许可个数为5;
  2. 通过add()添加数据,每添加一个数据,就消耗sema的一个许可;
  3. 当5个许可全部消耗完毕后,如果需要再添加数据,因为sema的许可为0,阻塞请求。 备注:如果这个时候调用了sema.release(),会释放一个许可,那么add()会继续添加一个元素,之后的请求继续阻塞,直到有新的许可释放。

栅栏

上面介绍的都是闭锁的几种实现方式,栅栏类似于闭锁,它能阻塞一组线程直到某个时间发生。栅栏和闭锁的关键区别在于,所有线程必须同时到达栅栏位置,才能继续执行。书中有一句哈总结的很好:

闭锁用于等待事件,而栅栏用于等待其它线程。

用途:用于阻塞一组线程直到某个事件发生。所有线程必须同时到达栅栏位置才能继续执行下一步操作,且能够被重置以达到重复利用。而闭锁式一次性对象,一旦进入终止状态,就不能被重置。

public class CyclicBarrierWorker implements Runnable {
    private int id;
    private CyclicBarrier barrier;

    public CyclicBarrierWorker(int id, final CyclicBarrier barrier) {
        this.id = id;
        this.barrier = barrier;
    }

    @Override
    public void run() {
        try {
            if (id == 5) {
                // 让第5个线程sleep 10秒
                Thread.sleep(10000);
            }
            System.out.println(id + " people wait");
            barrier.await(); // 大家等待最后一个线程到达
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

class TestCyclicBarrier {
    public static void main(String[] args) {
        int num = 10;
        // 新建一个栅栏
        CyclicBarrier barrier = new CyclicBarrier(num, new Runnable() {
            @Override
            public void run() {
                // num个线程全部执行完毕,且都调用barrier.await(),才会去执行该方法
                // 可以理解为计数器初始值为num,每调用一次barrier.await(),计数器-1,直到计数器等于0
                System.out.println("go on together!");
            }
        });
        for (int i = 1; i <= num; i++) {
            new Thread(new CyclicBarrierWorker(i, barrier)).start();
        }
    }
}
// 输出:
// 1 people wait
// 3 people wait
// 4 people wait
// 2 people wait
// 6 people wait
// 7 people wait
// 8 people wait
// 9 people wait
// 10 people wait
// 5 people wait
// go on together!

我故意让第5个线程sleep了10秒,所以大家都等第五个线程,全部执行完毕后,再一起去执行栅栏中的任务,简单总结一下流程:

  1. 新建一个栅栏,第一个参数num是线程个数,第二个参数是栅栏需要执行的任务;
  2. 启动10个线程,每个线程传入栅栏变量,这10个线程开始执行,然后都阻塞在barrier.await(),大家都在等待最后一个线程的到达;
  3. 当最后一个线程到达barrier.await()后,阻塞放开,开始执行栅栏中的方法。

创建线程的三种方式

如果大家对线程创建非常清楚,可以直接跳过“创建线程的三种方式”这部分内容,该部分内容主要给Java小白扫盲。

继承Thread类

继承Thread类并复写run()方法,是一种很简单的方式,代码如下:

public class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name + "已经运行");

    }
    public static void main(String[] args) {
        new MyThread("线程一").start();
    }
}
// 输出:
// 线程一已经运行

实现Runnable接口

这个是我们经常使用的方式之一,代码如下:

public class MyTask implements Runnable {
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name + "已经运行");
    }
    public static void main(String[] args) {
        new Thread(new MyTask(),"线程二").start();
    }
}
// 输出:
// 线程二已经运行

Thread类与Runnable接口的比较:

  • 由于Java“单继承,多实现”的特性,Runnable接口使用起来比Thread更灵活;

  • Runnable接口出现更符合面向对象,将线程单独进行对象的封装;

  • Runnable接口出现,降低了线程对象和线程任务的耦合性;

  • 如果使用线程时不需要使用Thread类的诸多方法,显然使用Runnable接口更为轻量;

所以,我们通常优先使用“实现Runnable接口”这种方式来自定义线程类。

Callable与Future创建线程

我们看到不管是Thread还是Runable接口,其run()都是无返回值的,并且无法抛出异常的,如果我们有需要返回值或者抛出异常怎么办?这个时候就需要用到Callable与Feature了。先来看类的继承关系:

Callable接口:

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

那一般是怎么使用Callable的呢?Callable一般是配合线程池工具ExecutorService来使用的,后面会给一个简单的示例。

Future接口只有几个比较简单的方法:

public interface Future<V{
    // 取消任务,如果任务正在运行的,mayInterruptIfRunning为true时,表明这个任务会被打断的,并返回true;
    // 为false时,会等待这个任务执行完,返回true;若任务还没执行,取消任务后返回true,如任务执行完,返回false
    boolean cancel(boolean mayInterruptIfRunning);
    // 判断任务是否被取消了,正常执行完不算被取消
    boolean isCancelled();
    // 判断任务是否已经执行完成,任务取消或发生异常也算是完成,返回true
    boolean isDone();
    // 获取任务返回结果,如果任务没有执行完成则等待完成将结果返回,如果获取的过程中发生异常就抛出异常,
    // 比如中断就会抛出InterruptedException异常等异常
    get() throws InterruptedException, ExecutionException;
    // 在规定的时间如果没有返回结果就会抛出TimeoutException异常
    get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

RunnableFuture是对Runnable和Future进行组装:

public interface RunnableFuture<Vextends RunnableFuture<V{
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */

    void run();
}

最后就是FutureTask和Callable,Callable是一个接口,里面有个V call()方法,这个V就是我们返回值类型。FutureTask类的构造函数,我们发现其中一个构造函数的参数是Callable类型,所以是通过FutureTask对Callable进行调用,并对线程进行管理。 Callable与Future的用法如下:

public class CallableTest {
    private void callTest() {
        //这里指定返回String类型
        Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("Callable 已经运行啦");
                return "this is Callable is running";
            }
        };
        FutureTask<String> futureTask = new FutureTask<String>(callable);
        futureTask.run();
        try {
            if (futureTask.isDone()){   //任务完成
                System.out.println(futureTask.get());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        CallableTest test = new CallableTest();
        test.callTest();
    }
}

简单说一下调用流程:

  1. 先初始化一个Callable匿名对象,然后重写call()方法;
  2. 初始化一个futureTask对象,用Callable作为入参;
  3. 直接执行futureTask.run()方法,调度任务;
  4. 通过futureTask.isDone()判断任务是否完成,完成后,阻塞放开。

原理:其实FutureTask内部实现比较简单,Callable就是他的任务,而FutureTask内部维护了一个任务状态,所有的状态都是围绕这个任务来进行的,随着任务的进行,状态也在不断的更新。任务发起者调用get()方法时,如果任务没有执行完成,会将当前线程放入阻塞队列等待,当任务执行完后,会唤醒阻塞队列中的线程。

扩展一下:Callable可以交给FutureTask处理,也可以交给线程池处理。

下面看一个Callable和线程池的调用示例:

public class CallableTest2 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executors = Executors.newCachedThreadPool();
        Future<String> future;
        for(int i = 0; i < 5 ; i++){
            // 直接把Callable对象扔给线程池,由线程池执行
            future = executors.submit(new CallableImpl(Integer.toString(i)));
            System.out.println(future.get());
        }
        executors.shutdown();
    }
}

class CallableImpl implements Callable<String{
    private String callableName;
    public CallableImpl(String callableName) {
        this.callableName = callableName;
    }
    @Override
    public String call() throws Exception {
        return "当前Callable名为: " + callableName;
    }
}

这个就很简单,直接整个Callable,然后扔给线程池去调度。

总结

这篇文章讲解了Java常用的同步工具类,这是很多是《Java并发编程实战》书里面的内容,但是当我看书时,感觉书中讲的知识并不容易懂,对于不懂的地方,我就到网上找一些相关示例,或者对一些基础知识做一些扫盲。所以大家看书时,不懂的地方可以跳过去,然后再单独对于不懂的知识点,到网上查阅资料,因为网上有很多博客,写的真的是非常好,比很多书籍作者表述的要好很多,这个也算是我看书的一点点心得。

楼仔

2021/05/20  阅读:16  主题:橙心

作者介绍

楼仔