ThreadPool：线程池

1、定义

创新互联建站是专业的万宁网站建设公司，万宁接单;提供成都做网站、网站建设,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行万宁网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

缓存一定线程数量的区域。

2、作用

复用、管理线程，避免新建线程/销毁线程消耗CPU资源。

3、核心参数

参数　　作用

corePoolSize(核心线程数)　　核心线程会一直存活

maximumPoolSize(最大线程数)　　活动线程达到最大线程数，后续新任务会阻塞

keepAliveTime(闲置线程超时时长)　　非核心线程闲置超过该时长将被回收(设置作用于核心线程threadPoolExecutor.allowCoreThreadTimeOut(true))

unit(keepAliveTime 单位)　　如：TimeUnit.MILLISECONDS, TimeUnit.SECONDS

workQueue(任务队列)　　存放 execute() 提交的 Runnable 对象

threadFactory(线程工厂)　　为线程池创建线程，Thread newThread(Runnable r)

4、工作流程

5、常用线程池

类型　　线程类型　　线程数量　　特点　　场景

定长线程池(FixedThreadPool)　　核心线程　　固定　　1、核心线程空闲不会回收。2、所有线程处于活动状态，新的任务将处于等待状态，直到有线程空闲。3、任务队列无大小限制。4、堆积的任务可能占用大内存　　控制线程最大并发数

定时线程池(ScheduledThreadPool)　　核心、非核心线程　　核心:固定，非核心:无限制　　1、非核心线程闲置时会被回收。2、非核心线程无限制可能创建非常多线程。　　执行定时/ 周期性任务

可缓存线程池(CachedThreadPool)　　非核心　　无限制　　1、优先使用闲置线程处理任务。2、线程大小无限制。3、60 秒 回收闲置线程。4、非核心线程无限制可能创建非常多线程。　　执行数量多、耗时少的任务

单线程线程池(SingleThreadExecutor)　　核心线程　　1个　　1、任务顺序执行。2、不需要处理线程同步。3、堆积的任务可能占用大内存　　单线程

6、具体使用

public class ExecutorDemo {

public static void main(String[] args) {

createThreadPoolExecutor();

createFixedThreadPool();

createScheduledThreadPool();

createCachedThreadPool();

createSingleThreadExecutor();

}

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();

private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));

private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;

private static final int KEEP_ALIVE_SECONDS = 30;

private static final BlockingQueue sPoolWorkQueue =

new LinkedBlockingQueue(128);

private static final ThreadFactory sThreadFactory = new ThreadFactory() {

private final AtomicInteger mCount = new AtomicInteger(1);

@Override

public Thread newThread(Runnable r) {

return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());

}

};

public static void createThreadPoolExecutor() {

// 1.创建自定义线程池

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(

CORE_POOL_SIZE,

MAXIMUM_POOL_SIZE,

KEEP_ALIVE_SECONDS,

TimeUnit.SECONDS,

sPoolWorkQueue,

sThreadFactory);

threadPoolExecutor.allowCoreThreadTimeOut(true);

// 2.创建任务

Runnable task = new Runnable() {

@Override

public void run() {

System.out.println("自定义线程池-任务执行");

}

};

// 3.通过线程池执行任务

threadPoolExecutor.execute(task);

// 4.关闭线程池

threadPoolExecutor.shutdown();

}

public static void createFixedThreadPool() {

// 1.创建定长线程池

// public static ExecutorService newFixedThreadPool(int var0) {

// return new ThreadPoolExecutor(var0, var0, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());

// }

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

// 2.创建任务

Runnable task = new Runnable() {

@Override

public void run() {

System.out.println("定长线程池-任务执行");

}

};

// 3.通过线程池执行任务

fixedThreadPool.execute(task);

// 4.关闭线程池

fixedThreadPool.shutdown();

}

public static void createScheduledThreadPool() {

// 1.创建定时线程池

// public ScheduledThreadPoolExecutor(int var1) {

// super(var1, 2147483647, 0L, TimeUnit.NANOSECONDS, new ScheduledThreadPoolExecutor.DelayedWorkQueue());

// }无锡妇科医院排行 http://www.0510bhyy.com/

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);

// 2.创建任务

Runnable task = new Runnable() {

@Override

public void run() {

System.out.println("定时线程池-任务执行");

}

};

// 3.通过线程池执行任务,execute 立即执行，schedule 延迟1s执行,scheduleAtFixedRate 延迟1s执行之后每隔2秒执行

// scheduledThreadPool.execute(task);

scheduledThreadPool.schedule(task, 1000L, TimeUnit.MILLISECONDS);

// scheduledThreadPool.scheduleAtFixedRate(task,1000L,2000L, TimeUnit.MILLISECONDS);

// 4.关闭线程池

scheduledThreadPool.shutdown();

}

public static void createCachedThreadPool() {

// 1.创建可缓存线程池

// public static ExecutorService newCachedThreadPool() {

// return new ThreadPoolExecutor(0, 2147483647, 60L, TimeUnit.SECONDS, new SynchronousQueue());

// }

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

// 2.创建任务

Runnable task = new Runnable() {

@Override

public void run() {

System.out.println("可缓存线程池-任务执行");

}

};

// 3.通过线程池执行任务

cachedThreadPool.execute(task);

// 4.关闭线程池

cachedThreadPool.shutdown();

}

public static void createSingleThreadExecutor() {

// 1.创建单线程线程池

// public static ExecutorService newSingleThreadExecutor() {

// return new Executors.FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue()));

// }

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

// 2.创建任务

Runnable task = new Runnable() {

@Override

public void run() {

System.out.println("单线程线程池-任务执行");

}

};

// 3.通过线程池执行任务

singleThreadExecutor.execute(task);

// 4.关闭线程池

singleThreadExecutor.shutdown();

}

}