Java线程池的几种实现方法和区别介绍实例详解

下面通过实例代码为大家介绍java线程池的几种实现方法和区别：

import java.text.dateformat;
import java.text.simpledateformat;
import java.util.arraylist;
import java.util.date;
import java.util.list;
import java.util.random;
import java.util.concurrent.callable;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
import java.util.concurrent.future;
public class testthreadpool {
 // -newfixedthreadpool与cachethreadpool差不多，也是能reuse就用，但不能随时建新的线程
 // -其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子
 // -和cachethreadpool不同，fixedthreadpool没有idle机制（可能也有，但既然文档没提，肯定非常长，类似依赖上层的tcp或udp
 // idle机制之类的），所以fixedthreadpool多数针对一些很稳定很固定的正规并发线程，多用于服务器
 // -从方法的源代码看，cache池和fixed 池调用的是同一个底层池，只不过参数不同:
 // fixed池线程数固定，并且是0秒idle（无idle）
 // cache池线程数支持0-integer.max_value(显然完全没考虑主机的资源承受能力），60秒idle
 private static executorservice fixedservice = executors.newfixedthreadpool(6);
 // -缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse.如果没有，就建一个新的线程加入池中
 // -缓存型池子通常用于执行一些生存期很短的异步型任务
 // 因此在一些面向连接的daemon型server中用得不多。
 // -能reuse的线程，必须是timeout idle内的池中线程，缺省timeout是60s,超过这个idle时长，线程实例将被终止及移出池。
 // 注意，放入cachedthreadpool的线程不必担心其结束，超过timeout不活动，其会自动被终止。
 private static executorservice cacheservice = executors.newcachedthreadpool();
 // -单例线程，任意时间池中只能有一个线程
 // -用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒idle（无idle）
 private static executorservice singleservice = executors.newsinglethreadexecutor();
 // -调度型线程池
 // -这个池子里的线程可以按schedule依次delay执行，或周期执行
 private static executorservice scheduledservice = executors.newscheduledthreadpool(10);
 public static void main(string[] args) {
 dateformat format = new simpledateformat("yyyy-mm-dd hh:mm:ss");
 list<integer> customerlist = new arraylist<integer>();
 system.out.println(format.format(new date()));
 testfixedthreadpool(fixedservice, customerlist);
 system.out.println("--------------------------");
 testfixedthreadpool(fixedservice, customerlist);
 fixedservice.shutdown();
 system.out.println(fixedservice.isshutdown());
 system.out.println("----------------------------------------------------");
 testcachethreadpool(cacheservice, customerlist);
 system.out.println("----------------------------------------------------");
 testcachethreadpool(cacheservice, customerlist);
 cacheservice.shutdownnow();
 system.out.println("----------------------------------------------------");
 testsingleservicethreadpool(singleservice, customerlist);
 testsingleservicethreadpool(singleservice, customerlist);
 singleservice.shutdown();
 system.out.println("----------------------------------------------------");
 testscheduledservicethreadpool(scheduledservice, customerlist);
 testscheduledservicethreadpool(scheduledservice, customerlist);
 scheduledservice.shutdown();
 } 
 public static void testscheduledservicethreadpool(executorservice service, list<integer> customerlist) {
 list<callable<integer>> listcallable = new arraylist<callable<integer>>();
 for (int i = 0; i < 10; i++) {
  callable<integer> callable = new callable<integer>() {
  @override
  public integer call() throws exception {
   return new random().nextint(10);
  }
  };
  listcallable.add(callable);
 }
 try {
  list<future<integer>> listfuture = service.invokeall(listcallable);
  for (future<integer> future : listfuture) {
  integer id = future.get();
  customerlist.add(id);
  }
 } catch (exception e) {
  e.printstacktrace();
 }
 system.out.println(customerlist.tostring());
 }
 public static void testsingleservicethreadpool(executorservice service, list<integer> customerlist) {
 list<callable<list<integer>>> listcallable = new arraylist<callable<list<integer>>>();
 for (int i = 0; i < 10; i++) {
  callable<list<integer>> callable = new callable<list<integer>>() {
  @override
  public list<integer> call() throws exception {
   list<integer> list = getlist(new random().nextint(10));
   boolean isstop = false;
   while (list.size() > 0 && !isstop) {
   system.out.println(thread.currentthread().getid() + " -- sleep:1000");
   isstop = true;
   }
   return list;
  }
  };
  listcallable.add(callable);
 }
 try {
  list<future<list<integer>>> listfuture = service.invokeall(listcallable);
  for (future<list<integer>> future : listfuture) {
  list<integer> list = future.get();
  customerlist.addall(list);
  }
 } catch (exception e) {
  e.printstacktrace();
 }
 system.out.println(customerlist.tostring());
 }
 public static void testcachethreadpool(executorservice service, list<integer> customerlist) {
 list<callable<list<integer>>> listcallable = new arraylist<callable<list<integer>>>();
 for (int i = 0; i < 10; i++) {
  callable<list<integer>> callable = new callable<list<integer>>() {
  @override
  public list<integer> call() throws exception {
   list<integer> list = getlist(new random().nextint(10));
   boolean isstop = false;
   while (list.size() > 0 && !isstop) {
   system.out.println(thread.currentthread().getid() + " -- sleep:1000");
   isstop = true;
   }
   return list;
  }
  };
  listcallable.add(callable);
 }
 try {
  list<future<list<integer>>> listfuture = service.invokeall(listcallable);
  for (future<list<integer>> future : listfuture) {
  list<integer> list = future.get();
  customerlist.addall(list);
  }
 } catch (exception e) {
  e.printstacktrace();
 }
 system.out.println(customerlist.tostring());
 }
 public static void testfixedthreadpool(executorservice service, list<integer> customerlist) {
 list<callable<list<integer>>> listcallable = new arraylist<callable<list<integer>>>();
 for (int i = 0; i < 10; i++) {
  callable<list<integer>> callable = new callable<list<integer>>() {
  @override
  public list<integer> call() throws exception {
   list<integer> list = getlist(new random().nextint(10));
   boolean isstop = false;
   while (list.size() > 0 && !isstop) {
   system.out.println(thread.currentthread().getid() + " -- sleep:1000");
   isstop = true;
   }
   return list;
  }
  };
  listcallable.add(callable);
 }
 try {
  list<future<list<integer>>> listfuture = service.invokeall(listcallable);
  for (future<list<integer>> future : listfuture) {
  list<integer> list = future.get();
  customerlist.addall(list);
  }
 } catch (exception e) {
  e.printstacktrace();
 }
 system.out.println(customerlist.tostring());
 }
 public static list<integer> getlist(int x) {
 list<integer> list = new arraylist<integer>();
 list.add(x);
 list.add(x * x);
 return list;
 }
}

使用：linkedblockingqueue实现线程池讲解

//例如：corepoolsize=3,maximumpoolsize=6,linkedblockingqueue(10)
 
//rejectedexecutionhandler默认处理方式是：threadpoolexecutor.abortpolicy
 
//threadpoolexecutor executorservice = new threadpoolexecutor(corepoolsize, maximumpoolsize, 1l, timeunit.seconds, new linkedblockingqueue<runnable>(10));
 
//1.如果线程池中（也就是调用executorservice.execute）运行的线程未达到linkedblockingqueue.init(10)的话，当前执行的线程数是:corepoolsize(3) 
 
//2.如果超过了linkedblockingqueue.init(10)并且超过的数>=init(10)+corepoolsize(3)的话，并且小于init(10)+maximumpoolsize. 当前启动的线程数是：(当前线程数-init(10))
 
//3.如果调用的线程数超过了init(10)+maximumpoolsize 则根据rejectedexecutionhandler的规则处理。

关于：rejectedexecutionhandler几种默认实现讲解

//默认使用：threadpoolexecutor.abortpolicy，处理程序遭到拒绝将抛出运行时rejectedexecutionexception。
      rejectedexecutionhandler policy=new threadpoolexecutor.abortpolicy();
//     //在 threadpoolexecutor.callerrunspolicy 中，线程调用运行该任务的execute本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。
//     policy=new threadpoolexecutor.callerrunspolicy();
//     //在 threadpoolexecutor.discardpolicy 中，不能执行的任务将被删除。
//     policy=new threadpoolexecutor.discardpolicy();
//     //在 threadpoolexecutor.discardoldestpolicy 中，如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。
//     policy=new threadpoolexecutor.discardoldestpolicy();

希望本篇文章对您有所帮助