线程笔记之并发同步
在应用编程中，我们会遇到下面这样的调用模型。。。
当一个业务方法（begin）中顺序调用多个子业务方法（opertion1-N），且有些子业务方法比较耗时，那么自然而然完成这次调用所需要的时间就比较长了。对于这样的问题，通常情况下会从两个方面对其进行重构和调优：
- 单个方法调优，即针对operation1-N中比较耗时的方法进行重构已达到期望的效果
- 业务重组和方法重构，即对整个大的业务方法进行重组，找出合乎当前需求（功能和性能）的实现方式
1比较好理解，最常见的就是sql语句，IO和string buffer方面的调优；2则需要看具体的应用场景了。由于本文主要是侧重线程的并发与同步，所以我将例举一个比较特殊的场景（webservices 远程调用）。如下：
对照上述序列图，若每一个operation方法都将进行一次远程webservice调用，那么一次调用的代价就要包含网络通信方面的开销。如果网络延时很高，多次远程调用的代价就相当大了。那么该如果结合上面的第2点进行重构和调优呢？
- 减少网络调用次数。 例如 operation1->API1，operation2->API2， 那么是否可以提供一个包含API1和API2的新API12供其调用呢？这样一次调用就可以达到目的。
- 多线程调用。如，让operation1与operation2并发，这样调用所需要的时间则为max(cost(operation1), cost(operation2))。这样做会大大提高系统的复杂性，谨慎而为之。
接下来进入主题
，谈谈并发的具体实现方式。
基本测试类ConcurrentSimpleTest
public class ConcurrentSimpleTest {
public void method1() {
System.out.println("before exec method1");
try {
Thread.sleep(400);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
System.out.println("method1 has been interrupted.");
e.printStackTrace();
}
System.out.println("after exec method1");
}
public void method2() {
System.out.println("before exec method2");
try {
Thread.sleep(800);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
System.out.println("method2 has been interrupted.");
e.printStackTrace();
}
System.out.println("after exec method2");
}
}
方式1：使用线程的join方法
public static void main(String[] args) throws InterruptedException {
final ConcurrentSimpleTest cst = new ConcurrentSimpleTest();
long s1 = System.currentTimeMillis();
cst.method1();
cst.method2();
long s2 = System.currentTimeMillis();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
cst.method1();
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
cst.method2();
}
});
t1.start();
t2.start();
t1.join(); //t2.join(500); 实际400ms后，方法就返回了
t2.join(); //t1.join(x); if x< max((800 - 400), (800-500)), 那该方法会在t2执行完前返回
//线程1/2都已返回，需要验证结果
long s3 = System.currentTimeMillis();
System.out.println("time cost for normal execution:" + (s2-s1));
System.out.println("time cost for concurrent execution:" + (s3-s2));
}
方式2：使用信号量对象
- 自定义信号量
public class SimpleMonitor {
public volatile int single = 0;
public void require(int single) {
this.single = single;
}
public synchronized void release(int single) {
this.single -= single;
this.notify();
}
}
public static void main(String[] args) throws InterruptedException {
final ConcurrentSimpleTest cst = new ConcurrentSimpleTest();
final SimpleMonitor monitor = new SimpleMonitor();
long s1 = System.currentTimeMillis();
cst.method1();
cst.method2();
long s2 = System.currentTimeMillis();
monitor.require(2); //初始化信号量
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
cst.method1();
} finally {
monitor.release(1); //信号量-1
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {
cst.method2();
} finally {
monitor.release(1); //信号量-1
}
}
});
t1.start();
t2.start();
synchronized (monitor) {
while (monitor.single > 0) {
monitor.wait(); // monitor.wait(10 * 1000), 进行超时异常处理，中断t1,t2
}
}
//线程1/2都已返回，需要验证结果
long s3 = System.currentTimeMillis();
System.out.println("time cost for normal execution:" + (s2 - s1));
System.out.println("time cost for concurrent execution:" + (s3 - s2));
}
- 使用JDK concurrent包中的信号量对象Semaphores
public static void main(String[] args) throws InterruptedException {
final ConcurrentSimpleTest cst = new ConcurrentSimpleTest();
final Semaphore monitor = new Semaphore(0);
long s1 = System.currentTimeMillis();
cst.method1();
cst.method2();
long s2 = System.currentTimeMillis();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
cst.method1();
} finally {
monitor.release(); //增加信号量
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {
cst.method2();
} finally {
monitor.release(); //增加信号量
}
}
});
t1.start();
t2.start();
monitor.acquireUninterruptibly(2); //tryAcquire(int permits, long timeout, TimeUnit unit) 可设置超时处理
//线程1/2都已返回，需要验证结果
long s3 = System.currentTimeMillis();
System.out.println("time cost for normal execution:" + (s2 - s1));
System.out.println("time cost for concurrent execution:" + (s3 - s2));
}
- 使用JDK concurrent包中的信号量对象CountDownLatch（似乎比Semaphores更适合这种场景）
public static void main(String[] args) throws InterruptedException {
final ConcurrentSimpleTest22 cst = new ConcurrentSimpleTest22();
final CountDownLatch monitor = new CountDownLatch(2); //设置计数器
long s1 = System.currentTimeMillis();
cst.method1();
cst.method2();
long s2 = System.currentTimeMillis();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
cst.method1();
} finally {
monitor.countDown(); //计数器-1
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {
cst.method2();
} finally {
monitor.countDown(); //计数器-1
}
}
});
t1.start();
t2.start();
monitor.await(1, TimeUnit.SECONDS); //monitor.await(1000, TimeUnit.MILLISECONDS); 设定超时阀值
//线程1/2都已返回，需要验证结果
long s3 = System.currentTimeMillis();
System.out.println("time cost for normal execution:" + (s2 - s1));
System.out.println("time cost for concurrent execution:" + (s3 - s2));
}
方式3：使用JDK5中新的线程实现方式和线程池
public static void main(String[] args) throws InterruptedException, ExecutionException {
final ExecutorService execPool = Executors.newFixedThreadPool(5);
final ConcurrentSimpleTest3 cst = new ConcurrentSimpleTest3();
long s1 = System.currentTimeMillis();
cst.method1();
cst.method2();
long s2 = System.currentTimeMillis();
Callable<Void> call1 = new Callable<Void>(){
@Override
public Void call() throws Exception {
cst.method1();
return null;
}
};
Callable<Void> call2 = new Callable<Void>(){
@Override
public Void call() throws Exception {
cst.method2();
return null;
}
};
Future<Void> task1 = execPool.submit(call1);
Future<Void> task2 = execPool.submit(call2);
task1.get();//task1.get(1, TimeUnit.SECONDS); get方法会阻塞，直到线程执行结束返回结果或者超时
task2.get();//task2.get(1, TimeUnit.SECONDS);
//线程1/2都已返回，需要验证结果
long s3 = System.currentTimeMillis();
System.out.println("time cost for normal execution:" + (s2 - s1));
System.out.println("time cost for concurrent execution:" + (s3 - s2));
execPool.shutdown();
}
要达到目的，我们的实现的方式有多种，上面给出的例子也只是抛砖引入，那么该如何抉择呢？个人认为应该考虑以下几个方面：
- 并发线程（任务）的可控性。如线程执行是否超时，可中断执行中的线程，异常处理以及获取线程执行的状态等。方法1/2/3都针对具体的子线程（任务）可控，而方法2在超时设定方面则是针对并发的线程。
- 合理性，即合乎人的思维和设计，个人认为用信号量同步的方式（方法2）比较合理。
- 高效性，即性能。线程池应该是个不错的选择。
- 简化性，即实现和使用比较简单化。
简化，其实就是更多的复用/重用。对于上面给出的应用场景，可以提出下面这样的模型：
其中主线程为main thread，在它的执行过程中会启动2个子线程T1和T2，等待T1和T2执行结束后，main thread才能执行结束。
进一步抽象下，便可以得到下面这个复杂点的模型：
模型中每个背景为白色的节点代表一个Thread，边代表执行的步骤和方向。
Begin 会启动T1和T2 线程，T2 执行完毕后会执行T4，而从 T1 和 T2 指向 T3 的两条边表示的是 T3 必须等 T1 和 T2 都执行完毕以后才能开始执行。若T1和T2同时执行完毕，那么T3和T4也会并发执行。当T3和T4执行完成，就会执行End，整个过程结束。
对于这个模型，我们可以提供一个简单的框架示意图：
其具体实现主要分为3部分：
- Constructor: 线程（任务）构建器，主要构建子线程（任务）以及其关联关系（主要是前置依赖关系）
- Executor: 线程（任务）执行器，主要负责高效地执行所提交的线程(任务)
- Monitor: 负责监控一组线程（任务）的执行状态并进行简单地调度。如前置任务出现异常，那么后续任务该任何执行等等
当然还得提供一些额外的访问接口：如，线程（任务）的执行结果等。这样一个框架/组件的雏形就有了，而作为调用者，也只要关心输入和输出即可。
总结：本文主要从一个顺序调用的例子出发，因性能问题引申到了并发，列出了并发同步的几种简单实现示例，并最后提出了一个并发框架的雏形。
有兴趣的朋友可以一起讨论其具体实现和应用。
--《全文完》--