Java 线程池模型的思考和选择（已更新）

多谢 风水 同学提出的问题。我重新研究了下源代码，纠正下我之前存在的错误的理论。于是对之前的文章做了修正，之前对大家引起的误导表示非常道歉。

这里对之前的文章重新进行了下梳理和研究，希望大家斧正。

---- 正文 -----
这几天总是讨论线程创建方式的问题，说性能比那个最优，哪个更方便等等。对于熟悉java的人来说，最先接触的应该是ExecutorService，这种线程池管理的方式操作比较简单，也广受大家好评。但是在很多系统上还有其他的实现方式，把Thread对象new出来，放进容器里面。这些Thread不停的取Queue（有生产者会往里面放待处理数据）里的数据进行处理，不停进行循环。可以到queue没数据的时候进行阻塞，直到有数据重新开始。

但是这里要说明一点的是，这两者的原理是一样的，只不过ExecutorService会借助Runnable来实现初始化线程，直到初始化满为止，后续的Runnable执行使用。具体的源码分析在后续的文章中一起分析。

不过对于自己的实现，和ExecutorService的实现，虽然一样，但是还是想看两者的速度如何。于是我做了一个小实验，来简单判断这两者的区别

ExecutorService的方式：

public static void ExecutorServiceTest() {
    ExecutorService es = Executors.newFixedThreadPool(100);
    for(int i = 0;i<100;i++) {    // 进行初始化各个线程，所以现用Runnable进行补充
        es.execute(new Runnable() {         
            int i = 9;
            @Override
            public void run() {
                int b =  i*9;
                Math.acos(b);
                Math.sin(b);
                Math.acos(b);
                Math.sin(b);
                Math.acos(b);
                Math.sin(b);
                Math.acos(b);
                Math.sin(b);
            }
        });
    }
    long time  = System.currentTimeMillis();
    int count = 10000000;
    while(count>0) {
        es.execute(new Runnable() {
                
            int i = 9;
            @Override
            public void run() {
                int b =  i*9;
                Math.acos(b);
                Math.sin(b);
                Math.acos(b);
                Math.sin(b);
                Math.acos(b);
                Math.sin(b);
                Math.acos(b);
                Math.sin(b);
            }
        });
        count--;
    }
    es.shutdown();
    System.out.println(System.currentTimeMillis() - time);
        
}

自定义线程池的方式：

public static void SelfThreadTest() {
    final ConcurrentLinkedQueue<Integer> queue1 = new ConcurrentLinkedQueue<>();
        
    final List<Thread> threadlist = new ArrayList<>(100);
    for(int i = 0;i<100;i++) {
        Thread t = new Thread(new Runnable() {
                
            Integer b ;
            boolean next = true;
            @Override
            public void run() {
                while(true) {
                    b = queue1.poll();
                    if(b == null) {
                        if(!next) {return;}
                        continue;
                    }
                    int c = b*9;
                    Math.acos(b);
                    Math.sin(b);
                    Math.acos(b);
                    Math.sin(b);
                    Math.acos(b);
                    Math.sin(b);
                    Math.acos(b);
                    Math.sin(b);
                    next = false;
                }
                    
            }
        });
            
        threadlist.add(t);
    }
        
        
    for(int i = 0;i<100;i++) {
        threadlist.get(i).start();
    }
        
    int count = 10000000;
    long time  = System.currentTimeMillis();
    while(count>0) {
        queue1.offer(count);
        count --;
            
    }

    while(true) {
        if(threadlist.get(99).getState() == Thread.State.TERMINATED) {  // 这里没有做太详细的判断略
            break;
        }
    }
        
    System.out.println(System.currentTimeMillis() - time);
}

这两个某次运行结果为：

begin
5302
4347
end

第一行为ExecutorService的运行结果，第二行为自定义线程池的运行结果。每次的运行时间都会有所差别，但是结果都是类似的。
是的，时间还是有挺大差别的，但是这个差别并不是上次说的" 后续会重复创建线程消耗的时间” 。因为后续是不继续生成线程的，ExecutorService中的一个线程其实在内部也是不停的循环，等待Runnable过来。而这个Runnable也仅是个接口实现了run方法，Thread循环取这个run方法进行运行。而这里的时间差别应该是ExecutorService中的各种线程检查和判断损失的时间（仅猜测-我们后续文章一起分析源码）。至于选择，大家还是先择系统的比较好，毕竟可以保证结果的稳定。自定义的方式，大家可以研究研究，如果要用在生产环境上，务必需要进行足够量的测试。

如果对Java线程创建流程感兴趣，可以参考这篇文章：https://yq.aliyun.com/articles/72803 。文章中讲到Java的线程创建最终会通过JNI调用到系统的pthread_create(C语言线程创建)，可见Java的线程就是真实的线程。