java中线程池的使用

public static ExecutorSevice newSingleThreadExecutor()

public static ExecutorSevice newFixedThreadPool()

public static ExecutorSevice newCachedThreadPool()

public static ScheduledExecutorService newScheduledThreadPool()

public static ExecutorService newWorkStealingPool()

new ForkJoinPool()

newCachedThreadPool() ：创建一个 ExecutorService，该 ExecutorService 根据需要来创建线程，可以重复利用已存在的线程来执行任务。

newFixedThreadPool(int numberOfThreads) ：创建一个可重复使用的、固定线程数量的 ExecutorService。

newScheduledThreadPool(int corePoolSize)：根据时间计划，延迟给定时间后创建 ExecutorService（或者周期性地创建 ExecutorService）。

newSingleThreadExecutor()：创建单个工作线程 ExecutorService。

newSingleThreadScheduledExecutor()：根据时间计划延迟创建单个工作线程 ExecutorService（或者周期性的创建）。

newWorkStealingPool()：创建一个拥有多个任务队列（以便减少连接数）的 ExecutorService

new ForkJoinPool() 并行地实现分治算法

newSingleThreadExecutor()和newFixedThreadPool(1)有什么区别呢？

上面说了那么多，答案应该也很显而易见了，实际上差别仅仅在于newSingleThreadExecutor()返回的线程池少暴露了一些方法并且多了个finalize方法保证线程池调用shutdown()，仅此而已。

网上有一些错误的回答，比如说前者线程执行期间抛出异常仍然能保证又其他线程顶替他，而后者不行，这样的回答都是错的。想要论证这是错的实际上很简单，对newFixedThreadPool(1)进行测试：

1. package newFixedThreadPool;

2.  

3. import java.util.concurrent.ExecutorService;

4. import java.util.concurrent.Executors;

5.  

6. public class Test {

7. public static void main(String[] args) {

8. ExecutorService fixedThreadPool = Executors.newFixedThreadPool(1);

9. int i = 0;

10. while (i++<10) {

11. final int index = i;

12. fixedThreadPool.execute(new Runnable() {

13. @Override

14. public void run() {

15. if(index == 1){

16. throw new IllegalStateException("handler exception");//线程运行时抛出异常

17. }

18. System.out.println(Thread.currentThread().getName() + "执行");

19. try {

20. Thread.sleep(3000);//模拟当前线程执行其他操作 花费3s

21. } catch (InterruptedException e) {

22. e.printStackTrace();

23. }

24. }

25. });

26. }

27. fixedThreadPool.shutdown();

28. }

29. }

运行结果如下：

可以看到对于newFixedThreadPool(1)，当一个线程在运行时抛出异常也会有其他线程顶替他去完成接下来的任务。

接下来对newSingleThreadExecutor()方法进行测试：

1. package newSingleThreadExecutor;

2.  

3. import java.util.concurrent.ExecutorService;

4. import java.util.concurrent.Executors;

5.  

6. public class Test {

7. public static void main(String[] args) {

8. ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

9. int i = 0;

10. while (i++ < 10) {

11. final int index = i;

12. singleThreadExecutor.execute(new Runnable() {

13. @Override

14. public void run() {

15. if(index == 1){

16. throw new IllegalStateException("handler exception");

17. }

18. System.out.println(Thread.currentThread().getName() + "执行" + "No." + index);

19. }

20. });

21. }

22. singleThreadExecutor.shutdown();

23. }

24. }

 

执行结果如下：

对于newSingleThreadExecutor()来说，也是当线程运行时抛出异常的时候会有新的线程加入线程池替他完成接下来的任务。

1. LinkedBlockingQueue

        无界队列。可以一直添加任务，直到内存溢出。

2. SynchronousQueue

         没有容量的队列。一个任务都不能放进去。

3. DelayedWorkQueue

         延迟工作的队列。

4. WorkQueue

         支持工作窃取的队列。

 

1. void execute(Runnable command);   

         直接提交，没有返回值。

   

2. <T> Future<T> submit(Callable<T> task);

          任务有返回值，通过 Future 获得返回值。

 

3. Future<?> submit(Runnable task)

          任务没有返回值，任务完成后，通过 Future 得到的是 null。