每天一例多线程[day17]-----Executors框架

 

1. /**

2. * 以下四种底层实现核心都是实例化了一个ThreadPoolExecutor对象返回，其实就是根据以下四种传递的具体参数

3. * 不同而实现的四种不同的功能。

4. *

5. * ThreadPoolExecutor来实现以下四种的原因是，当以下四种不满足我们需求时，我们可以

6. * 自定义线程池。

7. * 构造参数：

8. * public ThreadPoolExecutor(

9. * int corePoolSize,--当前线程池核心线程数

10. * int maximumPoolSize,--当前线程池最大线程数

11. * long keepAliveTime,--保持活着的空间时间

12. * TimeUnit unit,--时间单位

13. * BlockingQueue<Runnable> workQueue,--排队等待的自定义队列

14. * ThreadFactoty threadFactory,

15. * RejectedExecutionHandler handler--队列满以后，其他任务被拒绝执行的方法

16. * ){.........}

17. *

18. */

 

 

newFiexedThreadPool

该方法返回一个固定数量的线程池，该方法的线程数量始终不变，当有一个任务提交时，若线程池中空闲，则立即执行，若没有则会被暂缓在一个任务队列中等待有空闲的线程去执行。

1. /*

2. * public static ExecutorService newFixedThreadPool(int nThreads) {

3. return new ThreadPoolExecutor(nThreads, nThreads,

4. 0L, TimeUnit.MILLISECONDS,

5. new LinkedBlockingQueue<Runnable>());

6. }

7. * 核心线程数=最大线程数，空闲时间0s，线程执行完直接回收，但是维持线程池个数固定，

8. * 没有空闲线程的话，线程会被缓存在LinkedBlockingQueue无界阻塞队列中

9. */

10. // ExecutorService pool = Executors.newFixedThreadPool(10);

newSingleThreadExecutor

创建有一个线程的线程池，若空闲则执行，若没有空闲则暂缓在任务队列中。

1. /*

2. * 和固定差不多，仅有1个线程

3. * public static ExecutorService newSingleThreadExecutor() {

4. return new FinalizableDelegatedExecutorService

5. (new ThreadPoolExecutor(1, 1,

6. 0L, TimeUnit.MILLISECONDS,

7. new LinkedBlockingQueue<Runnable>()));

8. }

9. */

10. // ExecutorService pool = Executors.newSingleThreadExecutor();

newCachedThreadPool

返回一个可以根据实际情况调整线程个数的线程池，不限制最大线程数量，若有空闲的线程则执行任务，若无任务则不创建线程，并且空闲线程会在60s后自动回收。

1. /**

2. * 初始化时核心线程0，不限制线程最大数，

3. * 只要任务来了就创建一个线程并且执行任务，使用SynchronousQueue，没有任何容量。

4. * 线程最大空闲时间60s，如果线程在60s内没有任务到来就回收线程。如果59s的时候来了，就去执行

5. * 任务不会回收线程。

6. *

7. * public static ExecutorService newCachedThreadPool() {

8. return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

9. 60L, TimeUnit.SECONDS,

10. new SynchronousQueue<Runnable>());

11. }

12. */

13. // ExecutorService pool = Executors.newCachedThreadPool();

 

newScheduledThreadPool

该方法返回一个ScheduledExecutorService对象，但该线程池可以指定线程的数量。

1. /**

2. * 初始化指定的核心线程数，且没有最大线程数限制，空闲时间0s，执行完任务就回收线程，

3. * 线程没有空闲时任务到来，放到DelayedWorkQueue中。只有等延迟时间到了，任务才能被取出执行。

4. *

5. *

6. * public ScheduledThreadPoolExecutor(int corePoolSize) {

7. super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,

8. new DelayedWorkQueue());

9. }

10. */

11. // ExecutorService pool = Executors.newScheduledThreadPool(10);

举例：

1. import java.util.concurrent.Executors;

2. import java.util.concurrent.ScheduledExecutorService;

3. import java.util.concurrent.ScheduledFuture;

4. import java.util.concurrent.TimeUnit;

5.  

6. class Temp extends Thread {

7. public void run() {

8. System.out.println("run");

9. }

10. }

11.  

12. public class ScheduledJob {

13.  

14. public static void main(String args[]) throws Exception {

15.  

16. Temp command = new Temp();

17. ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

18.  

19. /**

20. * scheduleWithFixedDelay(

21. * Runnable command, 具体线程任务

22. * long initialDelay, 初始化延迟执行时间

23. * long delay, 轮询执行时间，每隔delay时间执行一次

24. * TimeUnit unit 单位

25. * )

26. *

27. */

28. //5s后，每隔1s执行一次command

29. ScheduledFuture<?> scheduleTask =

30. scheduler.scheduleWithFixedDelay(command, 5, 1, TimeUnit.SECONDS);

31.  

32. }

33. }

打印：

1. run

2. run

3. run

4. run