4 Concurrent.util工具类详解
(1)CyclicBarrier使用:
假设有一个场景:每一个线程代表一个跑步运动员,当运动员都准备好后,才一起出发,只要有一个人没有准备好,大家都等待。
CyclicBarrier barrier = new CyclicBarrier(int count); count为计数器,每有一个线程调用barrier.await();则计数器减1,当计数器减为0的时候,所有await的线程会同时被唤醒开始执行。
import java.util.Random;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class UseCyclicBarrier {
static class Runner implements Runnable{
private CyclicBarrier barrier;
private String name;
public Runner(CyclicBarrier barrier, String name) {
// TODO Auto-generated constructor stub
this.barrier = barrier;
this.name = name;
}
@Override
public void run() {
// TODO Auto-generated method stub
try {
Thread.sleep(1000 * new Random().nextInt(5));
System.out.println(this.name + "准备ok!");
barrier.await();
} catch (Exception e) {
// TODO: handle exception
}
System.out.println(System.currentTimeMillis() + " - " + this.name + " Go!");
}
}
public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(3);
ExecutorService pool = Executors.newFixedThreadPool(3);
pool.submit(new Thread(new Runner(barrier, "zhangsan")));
pool.submit(new Thread(new Runner(barrier, "lisi")));
pool.submit(new Thread(new Runner(barrier, "wangwu")));
pool.shutdown();
}
}
(2)CountDownLacth使用:
他常用于监听某些初始化操作,等初始化执行完毕后,通知主线程继续工作。
CountDownLatch count = new CountDownLatch(int count); count为计数器,没调用一次count.countDown();计数器就会减1,当计数器减为0的时候会唤醒await的线程继续执行。
import java.util.concurrent.CountDownLatch;
public class UseCountDownLacth {
public static void main(String[] args) {
final CountDownLatch count = new CountDownLatch(2);
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
System.out.println("进入线程t1," + "等待其他线程处理完成...");
count.await();
System.out.println("t1线程继续执行...");
} catch (Exception e) {
// TODO: handle exception
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
System.out.println("进入线程t2," + "执行t2线程的初始化操作...");
Thread.sleep(3 * 1000);
System.out.println("t2线程初始化完毕,通知t1线程...");
count.countDown();
} catch (Exception e) {
// TODO: handle exception
}
}
});
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
System.out.println("进入线程t3," + "执行t3线程的初始化操作...");
Thread.sleep(4 * 1000);
System.out.println("t3线程初始化完毕,通知t1线程...");
count.countDown();
} catch (Exception e) {
// TODO: handle exception
}
}
});
t1.start();
t2.start();
t3.start();
}
}
- 两者的区别:CountDownLacth是一个线程等待,多个线程去发通知,然后一个线程执行。CyclicBarrier是多个线程等待,然后多个线程一起开始执行。
(3)Callable使用:
(4)Future使用:
Future模式非常适用于在处理耗时很长的业务逻辑时进行适用,可以有效的减小系统的响应时间,提高系统的吞吐量
FutureTask<V> futureTask = new FutureTask<V>( ? extends Callable );
ExecutorService pool = Executors.newFixedThreadPool(2);
Future f = pool.submit(futureTask);
V result = futureTask.get();//执行后的返回结果
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;
import java.util.concurrent.FutureTask;
public class UseFuture implements Callable<String>{
private String para;
public UseFuture(String para) {
// TODO Auto-generated constructor stub
this.para = para;
}
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
Thread.sleep(3000);
String result = this.para + "处理完成";
return result;
}
public static void main(String[] args) throws Exception{
String queryStr = "query";
FutureTask<String> futureTask = new FutureTask<String>(new UseFuture(queryStr));
FutureTask<String> futureTask1 = new FutureTask<String>(new UseFuture(queryStr));
ExecutorService pool = Executors.newFixedThreadPool(2);
long start = System.currentTimeMillis();
Future f = pool.submit(futureTask);
Future f1 = pool.submit(futureTask1);
System.out.println("请求完毕.");
// System.out.println(f.isDone());
// System.out.println(f.get()); //如果任务执行完成,那么f.get会返回null
// System.out.println(f.isDone());
System.out.println(futureTask.get());
System.out.println("111111111");
System.out.println(futureTask1.get());
long end = System.currentTimeMillis() - start;
System.out.println(end);
pool.shutdown();
}
}
(5)Semaphore信号量
- PV(page view)网站的总访问量,页面浏览量或点击量,用户每刷新一次就会被记录一次。
- UV(unique Visitor)访问网站的一台电脑客户端为一个访客。一般来讲,时间上以00:00-24:00之类相同ip的客户端只记录一次
- QPS(query per second)即每秒查询数,qps很大程度上代表了系统业务上的繁忙程度。每次请求的背后,可能对应着多次磁盘I/O,多次网络请求,多个cpu时间片等。我们通过qps可以非常直观的了解当前系统业务情况,一旦当前qps超过所设定的预警阀值,可以考虑增加机器对集群扩容,以免压力过大导致宕机,可以根据前期的压力测试得到估值,在结合后期综合运维情况,估算出阀值。
- RT(response time)即请求的响应时间,这个指标非常关键,直接说明前端用户的体验,因此任何系统设计师都想降低rt时间。
当然还涉及cpu、内存、网络、磁盘等情况,细节的问题很多。
public static void main(String[] args) {
final Semaphore semp = new Semaphore(5); //实例化许可门限,相当于阀值
ExecutorService exec = Executors.newCachedThreadPool();
for(int i = 0; i < 20; i++){
final int NO = i;
Runnable run = new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
semp.acquire();//获取许可,如果能够获取则继续执行,否则阻塞等待
System.out.println("Accessing: " + NO);
Thread.sleep(5 * 1000);
semp.release();//释放许可
} catch (Exception e) {
// TODO: handle exception
}
}
};
exec.execute(run);
}
exec.shutdown();
}
- 容量评估:一般来说通过开发、运维、测试以及业务等相关人员综合处系统的一系列阀值,然后我们根据关键阀值如qps、rt等,对系统进行有效的变更。
一般来讲,我们进行多轮压力测试以后,可以对系统进行峰值评估,采用所谓的80/20原则,即80%的访问请求将在20%的时间内达到。这样我们可以根据系统对应的PV计算出峰值qps。
峰值qps=(总PV * 80%) / (60 * 60 * 24 * 20%)
然后在将总得峰值qps除以单台机器所能承受的最高的qps值,就是所需机器的数量:机器总数 = 总得峰值qps / 压力测试得出的单机极限qps
当然这只是在一般情况下,如果系统可能存在像天猫双十一那样的促销活动,需要另外去考量。