(计数器)CountDownLatch(Q当辣起)
CountDownLatch (Q当辣起)类位于java.util.concurrent包下,利用它可以实现类似计数器的功能。比如有一个任务A,它要等待其他4个任务执行完毕之后才能执行,此时就可以利用CountDownLatch来实现这种功能了。CountDownLatch是通过一个计数器来实现的,计数器的初始值为线程的数量。每当一个线程完成了自己的任务后,计数器的值就会减1。当计数器值到达0时,它表示所有的线程已经完成了任务,然后在闭锁上等待的线程就可以恢复执行任务。
package com.lb;
import java.util.concurrent.CountDownLatch;
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(2);
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ",子线程开始执行...");
try {
Thread.sleep(1000*5);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ",子线程结束执行...");
countDownLatch.countDown();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ",子线程开始执行...");
try {
Thread.sleep(1000*5);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ",子线程结束执行...");
countDownLatch.countDown();//计数器值每次减去1
}
}).start();
countDownLatch.await();// 減去为0,恢复任务继续执行
System.out.println("两个子线程执行完毕....");
System.out.println("主线程继续执行.....");
for (int i = 0; i <10; i++) {
System.out.println("main,i:"+i);
}
}
}
子线程执行完毕后主线程才开始执行:
(屏障)CyclicBarrier(塞葛里杯v尔)
CyclicBarrier(塞葛里杯v尔)初始化时规定一个数目,然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时,所有进入等待状态的线程被唤醒并继续。
CyclicBarrier就象它名字的意思一样,可看成是个障碍, 所有的线程必须到齐后才能一起通过这个障碍。
CyclicBarrier初始时还可带一个Runnable的参数, 此Runnable任务在CyclicBarrier的数目达到后,所有其它线程被唤醒前被执行。
package com.lb;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo {
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 cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@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 {
//进入等待
cyclicBarrier.await();
} catch (Exception e) {
}
System.out.println("所有线程执行完毕..........");
}
}
(计数信号量)Semaphore(塞闷佛儿)
Semaphore(塞闷佛儿)是一种基于计数的信号量。它可以设定一个阈值,基于此,多个线程竞争获取许可信号,做自己的申请后归还,超过阈值后,线程申请许可信号将会被阻塞。Semaphore可以用来构建一些对象池,资源池之类的,比如数据库连接池,我们也可以创建计数为1的Semaphore,将其作为一种类似互斥锁的机制,这也叫二元信号量,表示两种互斥状态。它的用法如下:
availablePermits函数用来获取当前可用的资源数量
wc.acquire(); //申请资源
wc.release();// 释放资源
package com.lb.semaphore;
import java.util.Random;
import java.util.concurrent.Semaphore;
public class ThradDemo001 extends Thread {
private String name;
private Semaphore wc;
public ThradDemo001(String name, Semaphore wc) {
this.name = name;
this.wc = wc;
}
@Override
public void run() {
// 剩下的资源
int availablePermits = wc.availablePermits();
if (availablePermits > 0) {
System.out.println(name + "终于有茅坑了.....");
} else {
System.out.println(name + "怎么没有茅坑了...");
}
try {
// 申请资源
wc.acquire();
} catch (InterruptedException e) {
}
System.out.println(name + "终于上厕所啦" + ",剩下厕所:" + wc.availablePermits());
try {
Thread.sleep(new Random().nextInt(1000));
} catch (Exception e) {
// TODO: handle exception
}
System.out.println(name + "厕所上完啦!");
// 释放资源
wc.release();
}
}
package com.lb.semaphore;
import java.util.concurrent.Semaphore;
public class TestSemaphore {
public static void main(String[] args) {
Semaphore semaphore = new Semaphore(3);
for (int i = 1; i <= 10; i++) {
ThradDemo001 thradDemo001 = new ThradDemo001("第" + i + "个人", semaphore);
thradDemo001.start();
}
}
}
并发队列
在并发队列上JDK提供了两套实现,一个是以ConcurrentLinkedQueue为代表的高性能队
列非阻塞,一个是以BlockingQueue接口为代表的阻塞队列,无论哪种都继承自Queue。