zoukankan      html  css  js  c++  java

  • 多线程应用 任务执行 等待所有任务完成一起处理

    首先是执行算法的CALL

    Java代码 复制代码 收藏代码
    1. /**
    2. * <dl>
    3. * <dt><b>类功能概要</b></dt>
    4. * <dd></dd>
    5. * </dl>
    6. * Version        Date       Company   Developer    Revise
    7. * -------     ----------   ---------  ---------    ------
    8. * pisv2.3.2   2012-02-24   yihaodian   xiangqi     create
    9. */ 
    10. package com.yihaodian.pis.thread; 
    11.  
    12. import java.util.concurrent.Callable; 
    13.  
    14. /**
    15. * @author yhd
    16. *
    17. */ 
    18. class Content implements Callable<Integer> { 
    19.  
    20.     publicint data; 
    21.     public Integer call() throws Exception { 
    22.         data ++; 
    23.         //此段可以表示用来执行其他耗时任务 
    24.         Thread.sleep(5000l); 
    25.         return data; 
    26.     } 
    27.     publicint getData() { 
    28.         return data; 
    29.     } 
    30.     publicvoid setData(int data) { 
    31.         this.data = data; 
    32.     } 
    33.      
    34. }  
    /**
 * <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代码 复制代码 收藏代码
    1. /**
    2. * <dl>
    3. * <dt><b>类功能概要</b></dt>
    4. * <dd></dd>
    5. * </dl>
    6. * Version        Date       Company   Developer    Revise
    7. * -------     ----------   ---------  ---------    ------
    8. * pisv2.3.2   2012-02-24   yihaodian   xiangqi     create
    9. */ 
    10. package com.yihaodian.pis.thread; 
    11.  
    12. import java.util.List; 
    13. import java.util.concurrent.BlockingQueue; 
    14. import java.util.concurrent.Callable; 
    15. import java.util.concurrent.Future; 
    16. import java.util.concurrent.LinkedBlockingQueue; 
    17. import java.util.concurrent.ThreadPoolExecutor; 
    18. import java.util.concurrent.TimeUnit; 
    19.  
    20. /**
    21. * @author yhd
    22. *
    23. */ 
    24. publicclass TestCall { 
    25.  
    26.     /**
    27.      * <dl>
    28.      * <dt><b>方法功能概要</b></dt>
    29.      * <dd></dd>
    30.      * </dl>
    31.      */ 
    32.     public Future<Integer> excute(Content content) { 
    33.         BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>(); 
    34.         ThreadPoolExecutor executor = new ThreadPoolExecutor(50, 100, 1, 
    35.                 TimeUnit.MINUTES, workQueue, 
    36.                 new ThreadPoolExecutor.AbortPolicy()); 
    37.         return executor.submit(content); 
    38.     } 
    39.  
    40. }  
    /**
 * <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代码 复制代码 收藏代码
    1. /**
    2. * <dl>
    3. * <dt><b>类功能概要</b></dt>
    4. * <dd></dd>
    5. * </dl>
    6. * Version        Date       Company   Developer    Revise
    7. * -------     ----------   ---------  ---------    ------
    8. * pisv2.3.2   2012-02-24   yihaodian   xiangqi     create
    9. */ 
    10. package com.yihaodian.pis.thread; 
    11.  
    12. import java.util.ArrayList; 
    13. import java.util.List; 
    14. import java.util.concurrent.BlockingQueue; 
    15. import java.util.concurrent.ExecutionException; 
    16. import java.util.concurrent.Future; 
    17. import java.util.concurrent.LinkedBlockingQueue; 
    18. import java.util.concurrent.ThreadPoolExecutor; 
    19. import java.util.concurrent.TimeUnit; 
    20.  
    21. /**
    22. * @author yhd
    23. *
    24. */ 
    25. publicclass Test { 
    26.  
    27.     /**
    28.      * <dl>
    29.      * <dt><b>方法功能概要</b></dt>
    30.      * <dd></dd>
    31.      * </dl>
    32.      */ 
    33.     publicstaticvoid main(String[] args) { 
    34.         BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>(); 
    35.         ThreadPoolExecutor executor = new ThreadPoolExecutor(50, 100, 1, 
    36.                 TimeUnit.MINUTES, workQueue, 
    37.                 new ThreadPoolExecutor.AbortPolicy()); 
    38.         class MainThread implements Runnable { 
    39.             TestCall testCall = new TestCall(); 
    40.             @Override 
    41.             publicvoid run() { 
    42.                 try { 
    43.                 List<Future<Integer>> tasks = new ArrayList<Future<Integer>>(); 
    44.                 for (int i = 0; i < 1000; i++) { 
    45.                     Content content = new Content(); 
    46.                     content.setData(i); 
    47.                     tasks.add(testCall.excute(content)); 
    48.                      
    49.                 } 
    50.                 //结束循环,开始得到结果 
    51.                 //状态用来标记任务完成的状态 
    52.                 int status = 0; 
    53.                 while (status != 2) { 
    54.                     status = 1; 
    55.                     for(Future<Integer> task : tasks) { 
    56.                         if (!task.isDone()) { 
    57.                             status = 0; 
    58.                             //等待任务都完成 
    59.                             Thread.sleep(1000l); 
    60.                             break; 
    61.                         } 
    62.                         if (status == 1 || status == 2) { 
    63.                             System.out.println(task.get()); 
    64.                             status = 2; 
    65.                         } 
    66.                     } 
    67.                 } 
    68.                 } catch (Exception e) { 
    69.                     // TODO Auto-generated catch block 
    70.                     e.printStackTrace(); 
    71.                 } 
    72.             } 
    73.         } 
    74.         MainThread mainThread = new MainThread(); 
    75.         executor.submit(mainThread); 
    76.     } 
    77.  
    78. }  
    /**
 * <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
  • 相关阅读:
    linux 命令——48 watch (转）
    linux 命令——47 iostat (转）
    linux 命令——46 vmstat(转）
    linux 命令——45 free(转）
    linux 命令——44 top (转）
    linux 命令——43 killall(转）
    linux 命令——42 kill (转）
    linux 命令——41 ps(转）
    linux 命令——40 wc (转）
    Java for LeetCode 068 Text Justification
  • 原文地址：https://www.cnblogs.com/chenzhao/p/2857880.html
Copyright © 2011-2022 走看看