一个主线程下有多个子线程任务，主线程必须在100秒内将子线程执行的集合结果进行处理返回。

最新推荐文章于 2024-05-10 15:48:27 发布

张家强全栈

最新推荐文章于 2024-05-10 15:48:27 发布

阅读量555

点赞数

写了3个例子，用Future、FutureTask、ThreadPoolExecutor、CompletionService。

例子1：

package cn.fansunion.executorservice;

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

//获得Future的值，如果还没返回，就等待

public class FutureTaskTest {

public static void main(String[] args) {

// 【强制】线程池不允许使用 Executors ExecutorsExecutors

// 去创建，而是通过去创建，而是通过去创建，而是通过 ThreadPoolExecutor

// ThreadPoolExecutor的方式，这样的方式，这样的处理方式让写同学更加明确线程池运行规则，避资源耗尽风险。

int nThreads = 5;

ThreadPoolExecutor executor = new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue<Runnable>(1000));

List<FutureTask<Integer>> taskList = new ArrayList<FutureTask<Integer>>(10);

for (int index = 1; index <= 10; index++) {

Integer num = new Random().nextInt(10);

System.out.println(String.format("index:%s,num=%s", index,num));

FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {

public Integer call() throws Exception {

int maxSleepNum = 10;

Integer sleepNum = new Random().nextInt(maxSleepNum);

System.out.println(String.format("SleepNum:%s", sleepNum));

Thread.sleep(sleepNum*1000);

return num;

}

例子2：

package cn.fansunion.executorservice;

import java.util.Random;

import java.util.concurrent.Callable;

import java.util.concurrent.CompletionService;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorCompletionService;

import java.util.concurrent.Future;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

/**

* CompletionService,先获得，最快得到结果的那个线程的值

* @author leiwen1

public class FutureTaskTest2 {

public static void main(String[] args) {

// 【强制】线程池不允许使用 Executors ExecutorsExecutors

// 去创建，而是通过去创建，而是通过去创建，而是通过 ThreadPoolExecutor

// ThreadPoolExecutor的方式，这样的方式，这样的处理方式让写同学更加明确线程池运行规则，避资源耗尽风险。

int nThreads = 5;

ThreadPoolExecutor executor = new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue<Runnable>(1000));

CompletionService<Integer> completionService= new ExecutorCompletionService<Integer>(executor);

int maxIndex = 10;

//List<FutureTask<Integer>> taskList = new ArrayList<FutureTask<Integer>>(maxIndex);

for (int index = 1; index <= maxIndex; index++) {

Integer num = new Random().nextInt(maxIndex);

System.out.println(String.format("index:%s,num=%s", index,num));

Callable<Integer> callable = new Callable<Integer>() {

public Integer call() throws Exception {

int maxSleepNum = 10;

Integer sleepNum = new Random().nextInt(maxSleepNum);

System.out.println(String.format("SleepNum:%s", sleepNum));

Thread.sleep(sleepNum*1000);

return num;

}

};

//Future<Integer> task = new FutureTask<>(callable);

if(!executor.isShutdown()){

completionService.submit(callable);

}

Integer sum = 0;

for (int index = 1; index <= maxIndex; index++) {

try {

//查询最新1个完成的任务，然后删除

//Retrieves and removes the Future representing the next completed task, waiting if none are yet present.

Future<Integer> future = completionService.take();

Integer num = future.get();

System.out.println(String.format("num=%s",num));

sum += num;

} catch (InterruptedException | ExecutionException e) {

e.printStackTrace();

}

executor.shutdownNow();

System.out.println(sum);

}

package cn.fansunion.executorservice;


import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
 * CompletionService,先获得，最快得到结果的那个线程的值
 * @author leiwen1
 *
 */
public class FutureTaskTest2 {


	public static void main(String[] args) {
		// 【强制】线程池不允许使用 Executors ExecutorsExecutors
		// 去创建，而是通过 去创建，而是通过 去创建，而是通过 ThreadPoolExecutor
		// ThreadPoolExecutor的方式，这样 的方式，这样 的处理方式让写同学更加明确线程池运行规则，避资源耗尽风险。
		int nThreads = 5;
		ThreadPoolExecutor executor = new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
				new LinkedBlockingQueue<Runnable>(1000));
		CompletionService<Integer> completionService= new ExecutorCompletionService<Integer>(executor);
		int maxIndex = 10;
		//List<FutureTask<Integer>> taskList = new ArrayList<FutureTask<Integer>>(maxIndex);
		for (int index = 1; index <= maxIndex; index++) {
			Integer num = new Random().nextInt(maxIndex);
			System.out.println(String.format("index:%s,num=%s", index,num));
			Callable<Integer> callable = new Callable<Integer>() {


				public Integer call() throws Exception {
					int maxSleepNum = 10;
					Integer sleepNum = new Random().nextInt(maxSleepNum);
					System.out.println(String.format("SleepNum:%s", sleepNum));
					Thread.sleep(sleepNum*1000);
					return num;
				}


			};
			//Future<Integer> task = new FutureTask<>(callable);
			if(!executor.isShutdown()){
				completionService.submit(callable);
			}
		}
		Integer sum = 0;
		for (int index = 1; index <= maxIndex; index++) {
			try {
				//查询最新1个完成的任务，然后删除
				//Retrieves and removes the Future representing the next completed task, waiting if none are yet present.
				Future<Integer> future = completionService.take();
				Integer num = future.get();
				System.out.println(String.format("num=%s",num));
				sum += num;
			} catch (InterruptedException | ExecutionException e) {
				e.printStackTrace();
			}


		}
		executor.shutdownNow();
		System.out.println(sum);
	}


}

在例子2的基础上，改了点，就是题目所要的效果。
例子3：

package cn.fansunion.executorservice;

import java.util.Arrays;

import java.util.Collections;

import java.util.Random;

import java.util.concurrent.Callable;

import java.util.concurrent.CompletionService;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorCompletionService;

import java.util.concurrent.Future;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

/**

* CompletionService,先获得，最快得到结果的那个线程的值

* pool方法，可以设置超时时间

public class FutureTaskTest3 {

public static void main(String[] args) {

// 【强制】线程池不允许使用 Executors ExecutorsExecutors

// 去创建，而是通过去创建，而是通过去创建，而是通过 ThreadPoolExecutor

// ThreadPoolExecutor的方式，这样的方式，这样的处理方式让写同学更加明确线程池运行规则，避资源耗尽风险。

int nThreads = 5;

ThreadPoolExecutor executor = new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue<Runnable>(1000));

CompletionService<Integer> completionService= new ExecutorCompletionService<Integer>(executor);

int maxIndex = 100;

//1到100求和

for (int index = 1; index <= maxIndex; index++) {

Integer num = index;

System.out.println(String.format("index:%s,num=%s", index,num));

Callable<Integer> callable = new Callable<Integer>() {

public Integer call() throws Exception {

//让一部分超时

int maxSleepNum = 350;

Integer sleepNum = new Random().nextInt(maxSleepNum);

System.out.println(String.format("SleepNum:%s", sleepNum));

//模拟计算时间，比如从远程查询数据

Thread.sleep(sleepNum);

return num;

}

};

//Future<Integer> task = new FutureTask<>(callable);

if(!executor.isShutdown()){

completionService.submit(callable);

}

//所有成功返回的num

Integer[] taskNumArray = new Integer[maxIndex];

for (int index = 1; index <= maxIndex; index++) {

try {

//等待下1个完成的任务，然后删除，但是最多等待一定的时间

Future<Integer> future = completionService.poll(100, TimeUnit.MILLISECONDS);

//模拟100毫秒，方便模拟超时，程序快点执行

if(future==null){

break;

}

Integer num = future.get();

taskNumArray[index-1]=num;

System.out.println(String.format("num=%s,成功返回1个数据",num));

} catch (InterruptedException | ExecutionException e) {

e.printStackTrace();

}

executor.shutdownNow();

Integer sum = 0;

//Collections.sort(Arrays.asList(taskNumArray));

//System.out.println(taskNumArray);

for(Integer num:taskNumArray){

//超时的那几个，么有值，位置是空的

if(num != null){

System.out.print(num+",");

sum+= num;

}

System.out.println();

System.out.println(String.format("sum=%s", sum));

}

package cn.fansunion.executorservice;


import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
 * CompletionService,先获得，最快得到结果的那个线程的值
 * pool方法，可以设置超时时间
 *
 */
public class FutureTaskTest3 {


	public static void main(String[] args) {
		// 【强制】线程池不允许使用 Executors ExecutorsExecutors
		// 去创建，而是通过 去创建，而是通过 去创建，而是通过 ThreadPoolExecutor
		// ThreadPoolExecutor的方式，这样 的方式，这样 的处理方式让写同学更加明确线程池运行规则，避资源耗尽风险。
		int nThreads = 5;
		ThreadPoolExecutor executor = new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
				new LinkedBlockingQueue<Runnable>(1000));
		CompletionService<Integer> completionService= new ExecutorCompletionService<Integer>(executor);
		int maxIndex = 100;
		//1到100求和
		for (int index = 1; index <= maxIndex; index++) {
			Integer num = index;
			System.out.println(String.format("index:%s,num=%s", index,num));
			Callable<Integer> callable = new Callable<Integer>() {


				public Integer call() throws Exception {
					//让一部分超时
					int maxSleepNum = 350;
					Integer sleepNum = new Random().nextInt(maxSleepNum);
					System.out.println(String.format("SleepNum:%s", sleepNum));
					//模拟计算时间，比如从远程查询数据
					Thread.sleep(sleepNum);
					return num;
				}


			};
			//Future<Integer> task = new FutureTask<>(callable);
			if(!executor.isShutdown()){
				completionService.submit(callable);
			}
		}
		//所有成功返回的num
		Integer[] taskNumArray = new Integer[maxIndex];
		for (int index = 1; index <= maxIndex; index++) {
			try {
				//等待下1个完成的任务，然后删除，但是最多等待一定的时间
				Future<Integer> future = completionService.poll(100, TimeUnit.MILLISECONDS);
				//模拟100毫秒，方便模拟超时，程序快点执行
				if(future==null){
					break;
				}
				Integer num = future.get();
				taskNumArray[index-1]=num;
				System.out.println(String.format("num=%s,成功返回1个数据",num));
			} catch (InterruptedException | ExecutionException e) {
				e.printStackTrace();
			}


		}	
		executor.shutdownNow();
		Integer sum = 0;
		//Collections.sort(Arrays.asList(taskNumArray));
		//System.out.println(taskNumArray);
		for(Integer num:taskNumArray){
			//超时的那几个，么有值，位置是空的
			if(num != null){
				System.out.print(num+",");
				sum+= num;
			}
		}
		System.out.println();
		System.out.println(String.format("sum=%s", sum));
	}


}

输出结果(每次都是随机的)：
num=53,成功返回1个数据
SleepNum:1
num=56,成功返回1个数据
SleepNum:296
num=61,成功返回1个数据
1,5,3,6,2,4,8,11,7,14,10,13,17,15,9,19,16,22,12,20,23,24,25,18,21,26,30,27,29,28,33,35,31,37,34,38,40,32,42,39,36,45,46,48,41,43,50,49,47,52,44,55,51,54,53,56,61,
sum=1657

}

});

if(!executor.isShutdown()){

executor.submit(task);

}

taskList.add(task);

}

Integer sum = 0;

for (FutureTask<Integer> task : taskList) {

try {

//阻塞,Waits if necessary for the computation to complete, and then retrieves its result.

Integer num = task.get();

System.out.println(String.format("num=%s",num));

sum += num;

} catch (InterruptedException | ExecutionException e) {

e.printStackTrace();

}

executor.shutdownNow();

System.out.println(sum);

}

张家强全栈

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
一个主线程下有多个子线程任务，主线程必须在100秒内将子线程执行的集合结果进行处理返回。

写了3个例子，用Future、FutureTask、ThreadPoolExecutor、CompletionService。例子1： package cn.fansunion.executorservice; import java.util.ArrayList; import java.util.List; import java.util.Random; import jav...
复制链接

扫一扫