Java-ThreadPool线程池总结

ExecutorService threadPool = Executors.newFixedThreadPool(N);

• 单个任务执行，它只会使用单个工作线程，一池一线程

ExecutorService threadPool = Executors.newSingleThreadExecutor();

• 执行短期异步任务，可缓存线程池，线程池根据需要创建新线程，但在先前构造的线程可以复用，也可灵活回收空闲的线程，可扩容的池

ExecutorService threadPool = Executors.newCachedThreadPool();

• 周期性线程池；支持定时及周期性任务执行

ExecutorService threadPool = Executors.newScheduledThreadPool();

(1) newFixedThreadPool

---

可以控制线程最大并发数的线程池：

public class FixedThreadPool {

private static AtomicInteger num = new AtomicInteger(0);

private static ExecutorService executorService = Executors.newFixedThreadPool(2);

public static void main(String[] args) {

countSum c= new countSum();

//将coutSum作为Task，submit至线程池

for (int i = 0; i < 2; i++) {

executorService.submit©;

}

//Task执行完成后关闭

executorService.shutdown();

}

static class countSum implements Runnable{

@Override

public void run() {

for (int i = 0; i < 500; i++) {

try{

System.out.println("Thread - “+Thread.currentThread().getName()+” count= "+ num.getAndIncrement());

Thread.sleep(100);

}catch (Exception e){

e.printStackTrace();

}

}

}

}

}

结果：

(2) newSingleThreadExecutor

---

只会使用唯一的工作线程执行任务的线程池：

public class SingleThreadExecutor {

private static AtomicInteger num = new AtomicInteger(0);

private static ExecutorService executorService = Executors.newSingleThreadExecutor();

public static void main(String[] args) {

//将coutSum作为Task，submit至线程池

for (int i = 0; i < 2; i++) {

executorService.submit(new countSum());

}

//Task执行完成后关闭

executorService.shutdown();

}

static class countSum implements Runnable{

@Override

public void run() {

for (int i = 0; i < 500; i++) {

try{

System.out.println("Thread - “+Thread.currentThread().getName()+” count= "+ num.getAndIncrement());

Thread.sleep(100);

}catch (Exception e){

e.printStackTrace();

}

}

}

}

}

结果：

(3) newScheduledThreadPool

---

传参值为corePoolSize大小，支持定时及周期性任务执行

延期执行示例：调用schedule方法，三个参数：Task，Delay，TimeUnit

public class ScheduledThreadPool {

// corePoolSize = 2

private static ScheduledExecutorService service = Executors.newScheduledThreadPool(2);

public static void main(String[] args) {

System.out.println("Thread - “+Thread.currentThread().getName()+” BEGIN "+ new Date());

service.schedule(new print(),5, TimeUnit.SECONDS);

service.shutdown();

}

static class print implements Runnable{

@Override

public void run() {

for (int i = 0; i < 10; i++) {

try{

System.out.println("Thread - “+Thread.currentThread().getName()+” Delay 5 second and sleep 2 second "+ new Date());

Thread.sleep(2000);

}catch (Exception e){

e.printStackTrace();

}

}

}

}

}

结果：

定时执行示例：调用scheduleAtFixedRate方法，四个参数：Task，initialDelay，Period，TimeUnit

public class ScheduledThreadPool {

// corePoolSize = 1

private static ScheduledExecutorService service = Executors.newScheduledThreadPool(1);

public static void main(String[] args) {

System.out.println("Thread - “+Thread.currentThread().getName()+” BEGIN "+ new Date());

service.scheduleAtFixedRate(new print(),5,3,TimeUnit.SECONDS);

}

static class print implements Runnable{

@Override

public void run() {

System.out.println("Thread - “+Thread.currentThread().getName()+” Delay 5 second and period 3 second "+ new Date());

}

}

}

结果：

(4) newCachedThreadPool

=======================

可缓存线程池，如果线程池长度超过处理需要，回收空闲线程，若无可回收，则新建线程。即若前一个任务已完成，则会接着复用该线程：

public class CachedThreadPool {

private static AtomicInteger num = new AtomicInteger(0);

private static ExecutorService service = Executors.newCachedThreadPool();

public static void main(String[] args) {

countSum c = new countSum();

for (int i = 0; i < 3; i++) {

try {

service.submit©;

Thread.sleep(1000);

}catch (Exception e){

e.printStackTrace();

}

}

service.shutdown();

}

static class countSum implements Runnable{

@Override

public void run() {

for (int i = 0; i < 1000; i++) {

System.out.println("Thread - “+Thread.currentThread().getName()+” countSum= "+num.getAndIncrement());