Executors创建四种线程池

谁践踏了优雅 2021-12-20 14:37 305阅读 0赞

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。  
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。  
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。  
newSingleThreadExecutor 创建一个单线程化的线程池执行任务。

package com.xhx.java;  
  
import static org.junit.Assert.assertTrue;  
  
import org.junit.Test;  
  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.ScheduledExecutorService;  
import java.util.concurrent.TimeUnit;  
  
// Executors四种线程池  
public class AppTest  
\{  
private Runnable myRunnable = new Runnable() \{  
@Override  
public void run() \{  
try \{  
//Thread.sleep(2000);  
System.out.println(Thread.currentThread().getName() + " run");  
\} catch (Exception e) \{  
e.printStackTrace();  
\}  
\}  
\};  
  
private Runnable myRunnableSleep = new Runnable() \{  
@Override  
public void run() \{  
try \{  
Thread.sleep(5000);  
System.out.println(Thread.currentThread().getName() + " run");  
\} catch (Exception e) \{  
e.printStackTrace();  
\}  
\}  
\};  
  
  
/\*\*  
\* newCachedThreadPool:创建可缓存的线程池，如果线程池中的线程在60秒未被使用就将被移除，在执行新的任务时，  
\* 当线程池中有之前创建的可用线程就重用可用线程，否则就新建一条线程  
\* public static ExecutorService newCachedThreadPool() \{  
\* return new ThreadPoolExecutor(0, Integer.MAX\_VALUE,  
\* 60L, TimeUnit.SECONDS,  
\* new SynchronousQueue<Runnable>());  
\* \}  
\*/  
@Test  
public void testCachedThreadPool() throws InterruptedException \{  
ExecutorService executorService = Executors.newCachedThreadPool();//线程池里面的线程数会动态的变化，并可在线程被重用前重用  
for(int i = 0; i<=20;i++)\{  
executorService.execute(myRunnable);  
\}  
  
Thread.sleep(100000);  
\}  
/\*  
运行结果：出现可重用线程  
pool-1-thread-2 run  
pool-1-thread-1 run  
pool-1-thread-3 run  
pool-1-thread-3 run  
pool-1-thread-2 run  
pool-1-thread-4 run  
pool-1-thread-3 run  
pool-1-thread-1 run  
pool-1-thread-2 run  
pool-1-thread-4 run  
pool-1-thread-3 run  
pool-1-thread-2 run  
pool-1-thread-1 run  
pool-1-thread-5 run  
pool-1-thread-4 run  
pool-1-thread-6 run  
pool-1-thread-7 run  
pool-1-thread-8 run  
pool-1-thread-9 run  
pool-1-thread-10 run  
pool-1-thread-11 run  
\*/  
  
  
/\*\*  
\* newScheduledThreadPool:创建一个可延迟执行或定期执行的线程池  
\*/  
@Test  
public void testScheduledThreadPool() throws InterruptedException \{  
ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);  
//5s第一次执行，之后3秒执行一次  
executorService.scheduleAtFixedRate(myRunnable,5,3,TimeUnit.SECONDS);  
  
Thread.sleep(20000);  
\}  
  
/\*\*  
\* newSingleThreadExecutor:创建一个单线程的Executor，如果该线程因为异常而结束就新建一条线程来继续执行后续的任务  
\*/  
@Test  
public void testSingleThreadExecutor() throws InterruptedException \{  
ExecutorService executorService = Executors.newSingleThreadExecutor();  
for(int i = 0; i<=20;i++)\{  
executorService.execute(myRunnable);  
\}  
Thread.sleep(20000);  
\}  
  
/\*\*  
\* 创建可重用且固定线程数的线程池，如果线程池中的所有线程都处于活动状态，  
\* 此时再提交任务就在队列中等待，直到有可用线程；如果线程池中的某个线程由于异常而结束时，线程池就会再补充一条新线程。  
\*/  
@Test  
public void testFixedThreadPool() throws InterruptedException \{  
ExecutorService executorService = Executors.newFixedThreadPool(10);  
for(int i = 0; i<=20;i++)\{  
executorService.execute(myRunnableSleep);  
\}  
Thread.sleep(200000);  
\}  
\}

转载于:https://www.cnblogs.com/chinaifae/p/10522235.html