多线程应用 任务执行 等待所有任务完成一起处理
2013-01-12 19:49
543 查看
首先是执行算法的CALL
Java代码
/**
* <dl>
* <dt><b>类功能概要</b></dt>
* <dd></dd>
* </dl>
* Version Date Company Developer Revise
* ------- ---------- --------- --------- ------
* pisv2.3.2 2012-02-24 yihaodian xiangqi create
*/
package com.yihaodian.pis.thread;
import java.util.concurrent.Callable;
/**
* @author yhd
*
*/
class Content implements Callable<Integer> {
publicint data;
public Integer call() throws Exception {
data ++;
//此段可以表示用来执行其他耗时任务
Thread.sleep(5000l);
return data;
}
publicint getData() {
return data;
}
publicvoid setData(int data) {
this.data = data;
}
}
其次是执行这个计算的任务线程
Java代码
/**
* <dl>
* <dt><b>类功能概要</b></dt>
* <dd></dd>
* </dl>
* Version Date Company Developer Revise
* ------- ---------- --------- --------- ------
* pisv2.3.2 2012-02-24 yihaodian xiangqi create
*/
package com.yihaodian.pis.thread;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @author yhd
*
*/
publicclass TestCall {
/**
* <dl>
* <dt><b>方法功能概要</b></dt>
* <dd></dd>
* </dl>
*/
public Future<Integer> excute(Content content) {
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();
ThreadPoolExecutor executor = new ThreadPoolExecutor(50, 100, 1,
TimeUnit.MINUTES, workQueue,
new ThreadPoolExecutor.AbortPolicy());
return executor.submit(content);
}
}
最后是主类，内部类设定参数，得到计算后的数据
Java代码
/**
* <dl>
* <dt><b>类功能概要</b></dt>
* <dd></dd>
* </dl>
* Version Date Company Developer Revise
* ------- ---------- --------- --------- ------
* pisv2.3.2 2012-02-24 yihaodian xiangqi create
*/
package com.yihaodian.pis.thread;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @author yhd
*
*/
publicclass Test {
/**
* <dl>
* <dt><b>方法功能概要</b></dt>
* <dd></dd>
* </dl>
*/
publicstaticvoid main(String[] args) {
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();
ThreadPoolExecutor executor = new ThreadPoolExecutor(50, 100, 1,
TimeUnit.MINUTES, workQueue,
new ThreadPoolExecutor.AbortPolicy());
class MainThread implements Runnable {
TestCall testCall = new TestCall();
@Override
publicvoid run() {
try {
List<Future<Integer>> tasks = new ArrayList<Future<Integer>>();
for (int i = 0; i < 1000; i++) {
Content content = new Content();
content.setData(i);
tasks.add(testCall.excute(content));
}
//结束循环,开始得到结果
//状态用来标记任务完成的状态
int status = 0;
while (status != 2) {
status = 1;
for(Future<Integer> task : tasks) {
if (!task.isDone()) {
status = 0;
//等待任务都完成
Thread.sleep(1000l);
break;
}
if (status == 1 || status == 2) {
System.out.println(task.get());
status = 2;
}
}
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
MainThread mainThread = new MainThread();
executor.submit(mainThread);
}
}
最后得到的结果就是 你想要的 2
Java代码
/**
* <dl>
* <dt><b>类功能概要</b></dt>
* <dd></dd>
* </dl>
* Version Date Company Developer Revise
* ------- ---------- --------- --------- ------
* pisv2.3.2 2012-02-24 yihaodian xiangqi create
*/
package com.yihaodian.pis.thread;
import java.util.concurrent.Callable;
/**
* @author yhd
*
*/
class Content implements Callable<Integer> {
publicint data;
public Integer call() throws Exception {
data ++;
//此段可以表示用来执行其他耗时任务
Thread.sleep(5000l);
return data;
}
publicint getData() {
return data;
}
publicvoid setData(int data) {
this.data = data;
}
}
/**
* <dl>
* <dt><b>类功能概要</b></dt>
* <dd></dd>
* </dl>
* Version Date Company Developer Revise
* ------- ---------- --------- --------- ------
* pisv2.3.2 2012-02-24 yihaodian xiangqi create
*/
package com.yihaodian.pis.thread;
import java.util.concurrent.Callable;
/**
* @author yhd
*
*/
class Content implements Callable<Integer> {
public int data;
public Integer call() throws Exception {
data ++;
//此段可以表示用来执行其他耗时任务
Thread.sleep(5000l);
return data;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
}其次是执行这个计算的任务线程
Java代码
/**
* <dl>
* <dt><b>类功能概要</b></dt>
* <dd></dd>
* </dl>
* Version Date Company Developer Revise
* ------- ---------- --------- --------- ------
* pisv2.3.2 2012-02-24 yihaodian xiangqi create
*/
package com.yihaodian.pis.thread;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @author yhd
*
*/
publicclass TestCall {
/**
* <dl>
* <dt><b>方法功能概要</b></dt>
* <dd></dd>
* </dl>
*/
public Future<Integer> excute(Content content) {
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();
ThreadPoolExecutor executor = new ThreadPoolExecutor(50, 100, 1,
TimeUnit.MINUTES, workQueue,
new ThreadPoolExecutor.AbortPolicy());
return executor.submit(content);
}
}
/**
* <dl>
* <dt><b>类功能概要</b></dt>
* <dd></dd>
* </dl>
* Version Date Company Developer Revise
* ------- ---------- --------- --------- ------
* pisv2.3.2 2012-02-24 yihaodian xiangqi create
*/
package com.yihaodian.pis.thread;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @author yhd
*
*/
public class TestCall {
/**
* <dl>
* <dt><b>方法功能概要</b></dt>
* <dd></dd>
* </dl>
*/
public Future<Integer> excute(Content content) {
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();
ThreadPoolExecutor executor = new ThreadPoolExecutor(50, 100, 1,
TimeUnit.MINUTES, workQueue,
new ThreadPoolExecutor.AbortPolicy());
return executor.submit(content);
}
}最后是主类，内部类设定参数，得到计算后的数据
Java代码
/**
* <dl>
* <dt><b>类功能概要</b></dt>
* <dd></dd>
* </dl>
* Version Date Company Developer Revise
* ------- ---------- --------- --------- ------
* pisv2.3.2 2012-02-24 yihaodian xiangqi create
*/
package com.yihaodian.pis.thread;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @author yhd
*
*/
publicclass Test {
/**
* <dl>
* <dt><b>方法功能概要</b></dt>
* <dd></dd>
* </dl>
*/
publicstaticvoid main(String[] args) {
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();
ThreadPoolExecutor executor = new ThreadPoolExecutor(50, 100, 1,
TimeUnit.MINUTES, workQueue,
new ThreadPoolExecutor.AbortPolicy());
class MainThread implements Runnable {
TestCall testCall = new TestCall();
@Override
publicvoid run() {
try {
List<Future<Integer>> tasks = new ArrayList<Future<Integer>>();
for (int i = 0; i < 1000; i++) {
Content content = new Content();
content.setData(i);
tasks.add(testCall.excute(content));
}
//结束循环,开始得到结果
//状态用来标记任务完成的状态
int status = 0;
while (status != 2) {
status = 1;
for(Future<Integer> task : tasks) {
if (!task.isDone()) {
status = 0;
//等待任务都完成
Thread.sleep(1000l);
break;
}
if (status == 1 || status == 2) {
System.out.println(task.get());
status = 2;
}
}
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
MainThread mainThread = new MainThread();
executor.submit(mainThread);
}
}
/**
* <dl>
* <dt><b>类功能概要</b></dt>
* <dd></dd>
* </dl>
* Version Date Company Developer Revise
* ------- ---------- --------- --------- ------
* pisv2.3.2 2012-02-24 yihaodian xiangqi create
*/
package com.yihaodian.pis.thread;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @author yhd
*
*/
public class Test {
/**
* <dl>
* <dt><b>方法功能概要</b></dt>
* <dd></dd>
* </dl>
*/
public static void main(String[] args) {
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();
ThreadPoolExecutor executor = new ThreadPoolExecutor(50, 100, 1,
TimeUnit.MINUTES, workQueue,
new ThreadPoolExecutor.AbortPolicy());
class MainThread implements Runnable {
TestCall testCall = new TestCall();
@Override
public void run() {
try {
List<Future<Integer>> tasks = new ArrayList<Future<Integer>>();
for (int i = 0; i < 1000; i++) {
Content content = new Content();
content.setData(i);
tasks.add(testCall.excute(content));
}
//结束循环,开始得到结果
//状态用来标记任务完成的状态
int status = 0;
while (status != 2) {
status = 1;
for(Future<Integer> task : tasks) {
if (!task.isDone()) {
status = 0;
//等待任务都完成
Thread.sleep(1000l);
break;
}
if (status == 1 || status == 2) {
System.out.println(task.get());
status = 2;
}
}
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
MainThread mainThread = new MainThread();
executor.submit(mainThread);
}
}最后得到的结果就是 你想要的 2
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 等待所有或任意异步任务完成,以及异步任务完成时的处理方案
- OC用Dispatch处理并发完成所有任务之后执行最终的结果
- 等待几个异步任务都完成后在执行其他的操作
- 如何等待java线程池中所有任务完成
- 主线程等待线程池所有任务完成
- java并发编程学习：如何等待多个线程执行完成后再继续后续处理(synchronized、join、FutureTask、CyclicBarrier)
- 主线程等待所有子线程完成后再执行
- 主线程等待所有子线程完成后再执行
- 主线程等待线程池所有任务完成
- 主线程等待所有子线程执行完成之后再继续往下执行的解决方案
- java线程池主线程等待子线程执行完成后再继续处理后面工作
- 多个线程的同步(所有任务都完成之后再向下执行)--转
- 主线程等待所有子线程完成后再执行
- JAVA主线程等待所有子线程执行完成后主线程再执行
- 主线程等待所有子线程完成后再执行
- java线程池主线程等待子线程执行完成后再继续处理后面工作
- 主线程等待所有子线程完成后再执行
- 如何等待java线程池中所有任务完成
- 多线程执行任务等待所有任务执行完毕
- java并发编程学习：如何等待多个线程执行完成后再继续后续处理(synchronized、join、FutureTask、CyclicBarrier)