线程池的一些测试

newFixedThreadPool

    问题提出：

1.  jdk中关于newFixedThreadPool的叙述是：创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。
   
2. 什么叫可重用固定线程的线程池？
   

    代码：

1.  这个是我写的一个线程类，在打印完信息后睡眠个3秒钟

2. public class MyThread extends Thread{
3. private boolean flag;
4. public MyThread(boolean flag) {
5. this.flag = flag;
6. }
8. @Override
9. public void run() {
10. toString();
11. try {
12. Thread.sleep(3000);
13. } catch (InterruptedException e) {
14. e.printStackTrace();
15. }
16. System.out.println("The thread has recall !");
17. }
19. @Override
20. public String toString(){
21. System.out.println("NAME : " + this.getName() + " ID :" + this.getId());
22. return null;
23. }
26. }

    2.      第二个程序，启动一个newFixedThreadPool运行一下。

    

1. import java.util.ArrayList;
2. import java.util.concurrent.ExecutorService;
3. import java.util.concurrent.Executors;
6. public class TestPoolExecutor {
8. public static void main(String[] args) {
9. ExecutorService pool = Executors.newFixedThreadPool(3);
10. ArrayList<MyThread>threads = new ArrayList<MyThread>();
11. boolean flag = true;
14. for(int i=0; i<10; i++){
15. MyThread thread = new MyThread(flag);
16. threads.add(thread);
17. pool.execute(thread);
18. }
20. }
21. }

    3.     输出的情况

1. NAME : Thread-0 ID :9
2. NAME : Thread-1 ID :11
3. NAME : Thread-2 ID :13
4. The thread has recall !
5. NAME : Thread-3 ID :15
6. The thread has recall !
7. NAME : Thread-4 ID :16
8. The thread has recall !
9. NAME : Thread-5 ID :17
10. The thread has recall !
11. NAME : Thread-6 ID :18
12. The thread has recall !
13. NAME : Thread-7 ID :19
14. The thread has recall !
15. NAME : Thread-8 ID :20
16. The thread has recall !
17. NAME : Thread-9 ID :21
18. The thread has recall !
19. The thread has recall !
20. The thread has recall !

    结论：

1.     可以看出，我启动​了三个线程，在每个线程完成之后，又有一个新的线程进入线程池中，完成一些操作，之后在结束了该线程，重复添加线程，一直到所有的任务都完成为止！
   

newCachedThreadPool

1. newCachedThreadPool
2. public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们，并在需要时使用提供的 ThreadFactory 创建新线程。
4. 参数：
5. threadFactory - 创建新线程时使用的工厂
6. 返回：
7. 新创建的线程池
8. 抛出：
9. NullPointerException - 如果 threadFactory 为 null

   

1.  ​这个是CachedThreadPool的说明和解释，可以看到，该线程池的空间是由jvm来自己定义的，也就是说，你可以启动n个线程，但是运行与否得看，jvm的内存和每一个线程的情况。
   
2. 额，电脑测试光荣事迹，死机码

1. import java.util.ArrayList;
2. import java.util.concurrent.ExecutorService;
3. import java.util.concurrent.Executors;
6. public class TestPoolExecutor {
8. public static void main(String[] args) {
9. ExecutorService pool = Executors.newCachedThreadPool();
10. ArrayList<MyThread>threads = new ArrayList<MyThread>();
13. for(int i=0; i<2000000; i++){
14. MyThread thread = new MyThread(i);
15. threads.add(thread);
16. pool.execute(thread);
17. }
18. }
19. }

    3.     从这个可以得出一个深刻的结论：那就是让系统自行根据需求自行线程池不靠谱啊！

 

来自为知笔记(Wiz)

转载于:https://www.cnblogs.com/sober-reflection/p/4060658.html