juc线程高级特性——CountDownLatch / Callable / Lock

Posted 雪山上的蒲公英

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了juc线程高级特性——CountDownLatch / Callable / Lock相关的知识,希望对你有一定的参考价值。

5. CountDownLatch 闭锁

Java 5.0 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。

CountDownLatch 一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。

闭锁可以延迟线程的进度直到其到达终止状态,闭锁可以用来确保某些活动直到其他活动都完成才继续执行:

  •  确保某个计算在其需要的所有资源都被初始化之后才继续执行;
  •  确保某个服务在其依赖的所有其他服务都已经启动之后才启动;
  •  等待直到某个操作所有参与者都准备就绪再继续执行。

如下:要求在创建的5个线程都执行完毕之后,再调用线程main方法输出耗费时间,使用wait,notify和notifyAll方法也可实现,但JDK不推荐。这里使用CountDownLatch。

/*
 * CountDownLatch :闭锁,在完成某些运算时,只有其他所有线程的运算全部完成,当前运算才继续执行
 */
public class TestCountDownLatch {

    public static void main(String[] args) {
        //CountDownLatch的构造函数接收一个int类型的参数作为计数器,如果你想等待N个点完成,这里就传入N。
        final CountDownLatch latch = new CountDownLatch(5);
        LatchDemo ld = new LatchDemo(latch);

        long start = System.currentTimeMillis();

        for (int i = 0; i < 5; i++) {
            new Thread(ld).start();
        }

        try {
            //阻塞当前线程,直到N变成零。
            latch.await();
        } catch (InterruptedException e) {
        }

        long end = System.currentTimeMillis();

        System.out.println("耗费时间为:" + (end - start));
    }

}

class LatchDemo implements Runnable {

    private CountDownLatch latch;
    public LatchDemo(CountDownLatch latch) {
        this.latch = latch;
    }
    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                if (i % 2 == 0) {
                    System.out.println(i);
                }
            }
        } finally {  //计数器减一
            latch.countDown();
        }
    }
}

结果:

6. 创建执行线程的方式三:实现 Callable 接口

Thread类和Runnable接口都不允许声明检查型异常,也不能定义返回值。Thread类和Runnable接口都不允许声明检查型异常,也不能定义返回值。

不能声明抛出检查型异常这个问题比较麻烦。public void run()方法契约意味着你必须捕获并处理检查型异常。即使你小心地保存了异常信息(在捕获异常时)以便稍后检查,但也不能保证这个类(Runnable对象)的所有使用者都读取异常信息。你也可以修改Runnable实现的getter,让它们都能抛出任务执行中的异常。但这种方法除了繁琐也不是十分安全可靠,你不能强迫使用者调用这些方法,程序员很可能会调用join()方法等待线程结束然后就不管了。

Java 5.0 在 java.util.concurrent 提供了一个新的创建执行线程的方式:Callable 接口。Callable接口定义了方法public T call() throws Exception。我们可以在Callable实现中声明强类型的返回值,甚至是抛出异常。

Future是Java 1.5中引入的接口,当你提交一个Callable对象给线程池时,将得到一个Future对象,并且它和你传入的Callable有相同的结果类型声明。这个对象取代了Java 1.5之前直接操作具体Thread实例的做法。过去你不得不用Thread.join()或者Thread.join(long millis)等待任务完成。

Callable 需要依赖FutureTask(Future子类RunnableFuture的实现类) ,FutureTask 也可以用作闭锁。

/*
 * 一、创建执行线程的方式三:实现 Callable 接口。 相较于实现 Runnable 接口的方式,方法可以有返回值,并且可以抛出异常。
 * 
 * 二、执行 Callable 方式,需要 FutureTask 实现类的支持,用于接收运算结果。  FutureTask 是  Future 接口的实现类
 */
public class TestCallable {
    
    public static void main(String[] args) {
        ThreadDemo1 td = new ThreadDemo1();
        
        //1.执行 Callable 方式,需要 FutureTask 实现类的支持,用于接收运算结果。
        FutureTask<Integer> result = new FutureTask<>(td);
        
        new Thread(result).start();
        
        //2.接收线程运算后的结果
        try {
            Integer sum = result.get();  //FutureTask 可用于 闭锁
            System.out.println(sum);
            System.out.println("------------------------------------");
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class ThreadDemo1 implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum = 0;        
        for (int i = 0; i <= 100000; i++) {
            sum += i;
        }    
        return sum;
    }  
}

/*class ThreadDemo implements Runnable{
    @Override
    public void run() {
    }    
}*/

7. 同步锁 Lock

在 Java 5.0 之前,协调共享对象的访问时可以使用的机制只有 synchronized 和 volatile 。Java 5.0 后增加了一些新的机制,但并不是一种替代内置锁的方法,而是当内置锁不适用时,作为一种可选择的高级功能。

ReentrantLock 实现了 Lock 接口,并提供了与synchronized 相同的互斥性和内存可见性。但相较于synchronized 提供了更高的处理锁的灵活性。

/*
 * 用于解决多线程安全问题的方式:
 * 
 * synchronized:隐式锁
 * 1. 同步代码块
 * 
 * 2. 同步方法
 * 
 * jdk 1.5 后:
 * 3. 同步锁 Lock
 * 注意:是一个显示锁,需要通过 lock() 方法上锁,必须通过 unlock() 方法进行释放锁
 */
public class TestLock {    
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        
        new Thread(ticket, "1号窗口").start();
        new Thread(ticket, "2号窗口").start();
        new Thread(ticket, "3号窗口").start();
    }
}

class Ticket implements Runnable{  
    private int tick = 100; 
 
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){         
            lock.lock(); //上锁     
            try{
                if(tick > 0){
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                    }                    
                    System.out.println(Thread.currentThread().getName() + " 完成售票,余票为:" + --tick);
                }
            }finally{
                lock.unlock(); //释放锁
            }
        }
    }    
}

 

以上是关于juc线程高级特性——CountDownLatch / Callable / Lock的主要内容,如果未能解决你的问题,请参考以下文章

juc线程高级特性

juc线程高级特性——线程池 / 线程调度 / ForkJoinPool

JUC并发编程 共享模式之工具 JUC CountdownLatch(倒计时锁) -- CountdownLatch(使用CountdownLatch原理改进: 配合线程池使用)

JUC5.CountDownLatch

JUC包中的CountDownLatch源码实现分析

juc高级特性——虚假唤醒 / Condition / 按序交替 / ReadWriteLock / 线程八锁