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();

以上这篇java线程池的几种实现方法和区别介绍就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持。