【Java并发】几个常用API

• 并发包
  • (计数器)CountDownLatch
  • (屏障)CyclicBarrier
  • (计数信号量)Semaphore
  • 案例:
    • 需求:
    • 代码:

并发包

(计数器)CountDownLatch

　　​CountDownLatch类位于java.util.concurrent包下，利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。
​

import java.util.concurrent.CountDownLatch;
public class CountDownlatchTest {
    public static void main(String[] args) {
        CountDownLatch count = new CountDownLatch(2);
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始执行-->" + System.currentTimeMillis());
                count.countDown();
                System.out.println(Thread.currentThread().getName() + "结束执行-->" + System.currentTimeMillis());
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始执行-->" + System.currentTimeMillis());
                count.countDown();
                System.out.println(Thread.currentThread().getName() + "结束执行-->" + System.currentTimeMillis());
            }
        }).start();

        try {
            count.await(); // 当Count减为0 时，执行后面的代码
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("两个子线程执行完毕....");
        System.out.println("主线程继续执行.....");
        for (int i = 0; i < 10; i++) {
            System.out.println("main,i:" + i);
        }
    }
}

执行结果

Thread-0开始执行-->1564281731639
Thread-0结束执行-->1564281731639
Thread-1开始执行-->1564281731639
Thread-1结束执行-->1564281731639
两个子线程执行完毕....
主线程继续执行.....
main,i:0
main,i:1
main,i:2
main,i:3
main,i:4
main,i:5
main,i:6
main,i:7
main,i:8
main,i:9

(屏障)CyclicBarrier

　　CyclicBarrier初始化时规定一个数目，然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时，所有进入等待状态的线程被唤醒并继续。
　　CyclicBarrier就象它名字的意思一样，可看成是个障碍， 所有的线程必须到齐后才能一起通过这个障碍。
　　CyclicBarrier初始时还可带一个Runnable的参数， 此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5);
        for (int i = 0; i < 5; i++) {
            Writer writer = new Writer(cyclicBarrier);
            writer.start();
        }
    }
}

class Writer extends Thread {
    private CyclicBarrier cyc;

    public Writer(CyclicBarrier cyc) {
        this.cyc = cyc;
    }

    @Override
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + ",正在写入数据");
        try {
            Thread.sleep(3000);
        } catch (Exception e) {
            // TODO: handle exception
        }
        System.out.println("线程" + Thread.currentThread().getName() + ",写入数据成功.....");
        try {
            cyc.await();
        } catch (Exception e) {
        }
        System.out.println("所有线程执行完毕..........");
    }
}

执行结果

线程Thread-0,正在写入数据
线程Thread-2,正在写入数据
线程Thread-1,正在写入数据
线程Thread-3,正在写入数据
线程Thread-4,正在写入数据
线程Thread-3,写入数据成功.....
线程Thread-1,写入数据成功.....
线程Thread-0,写入数据成功.....
线程Thread-2,写入数据成功.....
线程Thread-4,写入数据成功.....
所有线程执行完毕..........
所有线程执行完毕..........
所有线程执行完毕..........
所有线程执行完毕..........
所有线程执行完毕..........

(计数信号量)Semaphore

　　Semaphore是一种基于计数的信号量。它可以设定一个阈值，基于此，多个线程竞争获取许可信号，做自己的申请后归还，超过阈值后，线程申请许可信号将会被阻塞。　
　　 Semaphore可以用来构建一些对象池，资源池之类的，比如数据库连接池，我们也可以创建计数为1的Semaphore，将其作为一种类似互斥锁的机制，这也叫二元信号量，表示两种互斥状态。它的用法如下：

semp.availablePermits()//函数用来获取当前可用的资源数量
semp.acquire(); //申请资源
semp.release();// 释放资源

// 创建一个计数阈值为5的信号量对象  
// 只能5个线程同时访问  
Semaphore semp = new Semaphore(5);  
try {  
  // 申请许可  
  semp.acquire();  
  try {  
    // 业务逻辑  
  }catch (Exception e){  
  } finally {  
    // 释放许可  
    semp.release();  
  }  
}catch(InterruptedException e){ }  

案例:

需求:

　　一个商店只有3个抓娃娃机，但是有10个人要来抓娃娃，那怎么办？假设10的人的编号分别为1-10，并且1号先到，10号最后到。那么1-3号来的时候必然有可用抓娃娃机，可以开始抓娃娃，4号来的时候需要看看前面3人是否有人抓完了，如果有人抓完，4号就开始抓娃娃，否则等待。同样的道理，4-10号也需要等待正在抓娃娃的人抓完才能抓，并且谁先开始抓娃娃要看等待的人是否有素质，是否能遵守先来先用抓玩玩机的规则。

代码:

import java.util.Random;
import java.util.concurrent.Semaphore;

public class SemaphoreTest {
    public static void main(String[] args) {
        Semaphore semp = new Semaphore(3);
        for (int i = 0; i <= 10; i++) {
            CatchDollThread thread = new CatchDollThread("thread-" + i, semp);
            thread.start();
        }
    }
}

class CatchDollThread extends Thread {
    private String name;
    private Semaphore cad;
    public CatchDollThread(String name, Semaphore cad) {
        this.name = name;
        this.cad = cad;
    }

    @Override
    public void run() {
        int availablePermits = cad.availablePermits();
        if (availablePermits > 0) {
            System.out.println(this.name + "说: 有空闲的抓娃娃机");
        } else {
            System.out.println(this.name + "说: 没有空闲的娃娃机了");
        }
        try {
            // 申请资源
            cad.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.name + "开始抓娃娃" + ",此时空闲的机器:" + cad.availablePermits());
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (Exception e) {
        }
        System.out.println(this.name + "抓完娃娃");
        // 释放资源
        cad.release();

    }
}

执行结果

thread-1说: 有空闲的抓娃娃机
thread-3说: 有空闲的抓娃娃机
thread-2说: 有空闲的抓娃娃机
thread-0说: 有空闲的抓娃娃机
thread-4说: 没有空闲的娃娃机了
thread-2开始抓娃娃,此时空闲的机器:0
thread-3开始抓娃娃,此时空闲的机器:1
thread-1开始抓娃娃,此时空闲的机器:2
thread-5说: 没有空闲的娃娃机了
thread-6说: 没有空闲的娃娃机了
thread-7说: 没有空闲的娃娃机了
thread-8说: 没有空闲的娃娃机了
thread-9说: 没有空闲的娃娃机了
thread-10说: 没有空闲的娃娃机了
thread-1抓完娃娃
thread-0开始抓娃娃,此时空闲的机器:0
thread-3抓完娃娃
thread-4开始抓娃娃,此时空闲的机器:0
thread-4抓完娃娃
thread-5开始抓娃娃,此时空闲的机器:0
thread-0抓完娃娃
thread-6开始抓娃娃,此时空闲的机器:0
thread-2抓完娃娃
thread-7开始抓娃娃,此时空闲的机器:0
thread-6抓完娃娃
thread-8开始抓娃娃,此时空闲的机器:0
thread-5抓完娃娃
thread-9开始抓娃娃,此时空闲的机器:0
thread-8抓完娃娃
thread-10开始抓娃娃,此时空闲的机器:0
thread-10抓完娃娃
thread-7抓完娃娃
thread-9抓完娃娃