多线程——定长线程池
思路：先新建线程池——定长线程池（ExecutorService）；CompletionService异步获取并行任务执行结果；循环创建新线程，实现callable接口来创建新线程，future来获得线程状态，future.get()有阻塞效果，只有执行完当前线程才会进行下一个；最后一个循环CompletionService则调用take方法取到的都是完成的任务的Future对象，自然调用get方法时就不会阻塞了，来检查各个线程是否完成
1 package test; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 import java.util.concurrent.Callable; 6 import java.util.concurrent.CompletionService; 7 import java.util.concurrent.ExecutionException; 8 import java.util.concurrent.Executor; 9 import java.util.concurrent.ExecutorCompletionService; 10 import java.util.concurrent.ExecutorService; 11 import java.util.concurrent.Executors; 12 import java.util.concurrent.Future; 13 14 public class TestThreadPool { 15 private static
package test;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TestThreadPool {
private static ExecutorService executorService=null;
//新建线程池
static{
//初始化线程池 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
//Runtime.getRuntime().availableProcessors()获得可用处理器个数
executorService=Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()*5);
}
public static void main(String[] args) {
complet();
}
public static void complet(){
// CompletionService异步获取并行任务执行结果
CompletionService completionService=new ExecutorCompletionService(executorService);
List<String> list=new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
for (int i = 1; i <=list.size(); i++) {
Callable call=new TestThread(i, list);
Future fu=completionService.submit(call);
try {
System.out.println(fu.get());// return 返回值，阻塞直到该线程运行结束
Thread.sleep(2000);
} catch (InterruptedException | ExecutionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
executorService.shutdown();
for (int i = 0; i <list.size(); i++) {
try {
System.out.println("线程："+completionService.take().get()+"执行结束");
} catch (InterruptedException | ExecutionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
executorService=null; 16 //新建线程池 17 static{ 18 //初始化线程池 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 19 //Runtime.getRuntime().availableProcessors()获得可用处理器个数 20 executorService=Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()*5); 21 } 22 23 public static void main(String[] args) { 24 complet(); 25 } 26 27 public static void complet(){ 28 // CompletionService异步获取并行任务执行结果 29 CompletionService completionService=new ExecutorCompletionService(executorService); 30 List<String> list=new ArrayList<>(); 31 list.add("a"); 32 list.add("b"); 33 list.add("c"); 34 list.add("d"); 35 list.add("e"); 36 for (int i = 1; i <=list.size(); i++) { 37 Callable call=new TestThread(i, list); 38 Future fu=completionService.submit(call); 39 try { 40 System.out.println(fu.get());// return 返回值，阻塞直到该线程运行结束 41 Thread.sleep(2000); 42 } catch (InterruptedException | ExecutionException e) { 43 // TODO Auto-generated catch block 44 e.printStackTrace(); 45 } 46 47 } 48 49 executorService.shutdown(); 50 for (int i = 0; i <list.size(); i++) { 51 try { 52 System.out.println("线程："+completionService.take().get()+"执行结束"); 53 } catch (InterruptedException | ExecutionException e) { 54 // TODO Auto-generated catch block 55 e.printStackTrace(); 56 } 57 } 58 } 59 }
1 package test; 2 3 import java.util.List; 4 import java.util.concurrent.Callable; 5 6 public class TestThread implements Callable{ 7 static int num; 8 static List list; 9 public TestThread(int num,List list){ 10 this.num=num; 11 this.list=list; 12 } 13 @Override 14 public Object call() throws Exception { 15 for (int i = 1; i <=20; i++) { 16 System.out.println(list.get(num-1)+"---"+i); 17 } 18 return "第"+num+"线程执行结束"; 19 } 20 21 }
