周五在java群里看到了一个有意思的问题，周末就顺便实现了一下，需求如下：

考察一个多线程的场景，一个Http?Request的controller有10个线程同时并行处理，要求：

1)?主线程必须等待10个线程全部执行成功后主线程返回“Success”

2)?只要其中任意一个线程出错，不仅当前出错的线程要回滚，其他所有线程不管成功失败也要回滚，主线程等待所有线程回滚完毕后输出相应的错误字符“Fail”。?

代码如下：

package com.mfunny.queue;

import java.util.concurrent.BlockingDeque;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.LinkedBlockingDeque;

/**

*

*

*

*

*

*

* 修改历史: <br>

* 修改日期 修改人员 版本 修改内容

* --------------------------------------------------------------------

* 2016年03月26日 上午9:31 1.0 初始化创建

*

*

* @author

* @version 1.0

* @since JDK1.7

*/

public class Test {

private static class Rollback {

public Rollback(Boolean needRoolBack) {

this.needRoolBack = needRoolBack;

}

private Boolean needRoolBack = false;

public Boolean getNeedRoolBack() {

return needRoolBack;

}

public void setNeedRoolBack(Boolean needRoolBack) {

this.needRoolBack = needRoolBack;

}

}

private static class Task implements Runnable {

/**

* 监控10个子任务的执行

*/

private CountDownLatch childMonitor;

/**

* 监控主线程

*/

private CountDownLatch mainMonitor;

/**

* 存储线程的返回结果

*/

private BlockingDeque resultList;

/**

* 回滚类

*/

private Rollback rollback;

public Task(CountDownLatch childCountDown, CountDownLatch mainCountDown, BlockingDeque result, Rollback rollback) {

this.childMonitor = childCountDown;

this.mainMonitor = mainCountDown;

this.resultList = result;

this.rollback = rollback;

}

private void shouldRollBack() {

System.out.println(Thread.currentThread().getName()+"开始回滚");

}

/**

* 事务提交

*/

private void submit() {

}

/**

* 执行任务,返回false表示任务执行错误，需要回滚

* 本案例中根据线程名字包含Thread-8判断是否回滚

* @return

*/

private Boolean processTask() {

if(Thread.currentThread().getName().contains("Thread-8"))

return false;

return true;

}

@Override public void run() {

System.out.println(Thread.currentThread().getName()+"子线程开始执行任务");

Boolean result = processTask();

//向队列中添加处理结果

resultList.add(result);

//等待其他的子线程执行完成，一起执行主线程的判断逻辑

childMonitor.countDown();

try {

//等待主线程的判断逻辑执行完，执行下面的是否回滚逻辑

mainMonitor.await();

} catch (Exception e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+"子线程执行剩下的任务");

//需要回滚

if (rollback.getNeedRoolBack())

shouldRollBack();

else

//不需要回滚->事务提交

submit();

}

}

public static void main(String[] args) {

//监控10个子线程的任务执行

CountDownLatch childMonitor = new CountDownLatch(10);

//监控主线程，是否需要回滚

CountDownLatch mainMonitor = new CountDownLatch(1);

//存储任务的返回结果，返回true表示不需要回滚，反之，则回滚

BlockingDeque results = new LinkedBlockingDeque(10);

Rollback rollback = new Rollback(false);

for (int i = 0; i < 10; i++) {

//10个任务启动

Thread thread = new Thread(new Task(childMonitor, mainMonitor, results, rollback));

thread.start();

}

try {

//监测10个子线程的执行

childMonitor.await();

System.out.println("主线程开始执行任务");

//根据返回结果来确定是否回滚

for (int i = 0; i < 10; i++) {

Boolean result = results.take();

if (!result) {

rollback.setNeedRoolBack(true);

}

}

//10个子线程开始执行

mainMonitor.countDown();

if(rollback.getNeedRoolBack())

System.out.println("Fail");

else System.out.println("Success");

} catch (Exception e) {

}

}

}

?思想就是使用两个CountDownWatch实现子线程的二段提交

?

顺便给群打一下广告：

java高级群(329019348)

java水群(51317874)

原文：http://lsk569937453.iteye.com/blog/2286415