Java 线程池，

Java 线程池，

下面是多线程的一种写法 ：

class PrintRunnable implements Runnable {
    // i如果是全局变量，会被多个线程同时共享
    int i = 1;
    @Override
    public void run() {
        while (i <= 10) {
            System.out.println(Thread.currentThread().getName() + "正在运行" + (i++));
        }
    }
}

public class RunnableTest {

    public static void main(String[] args) {
        // 多态
        Runnable pr = new PrintRunnable();
        Thread t1 = new Thread(pr);
        t1.start();
        
        // 如果想要多个线程同时执行就要new多个Runnable
        Runnable pr1 = new PrintRunnable();
        Thread t2 = new Thread(pr);
        t2.start();
      
}

下面这种写法是上面的简写：

int j = 1;
new Thread(new Runnable() {
    @Override
    public void run() {
        while (j <= 10) {
            System.out.println(Thread.currentThread().getName() + "正在运行" + (j++));
        }
    }
}).start();

//todo 或者改为lambda表达式
new Thread(()-> {
    int k = 1;
    while (k <= 10) {
        System.out.println(Thread.currentThread().getName() + "正在运行" + (k++));
    }
}).start();

new Thread的弊端如下：

a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执行、定期执行、线程中断。

相比new Thread，Java提供的四种线程池的好处在于：

a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。

Java通过Executors提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

可以直接通过for循环代替上面的 new Thread

ExecutorService executorService = Executors.newCachedThreadPool();

    // for循环相当于上面 new了 10个 Thread
    for (int i = 0; i < 10; i++) {
        // 标志第几个线程
        final int index = i;
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                log.info("task:{}", index);
            }
        });
    }

    executorService.shutdown();

根据阿里巴巴开发手册，应该更进一步改为： 

public class Test{

private static class PrintRunnable implements Runnable {
    // i如果是全局变量，会被多个线程同时共享
    int i = 1;
    @Override
    public void run() {
        while (i <= 10) {
            System.out.println(Thread.currentThread().getName() + "正在运行" + (i++));
        }
    }
}




public static ThreadFactory namedThreadFactory = new ThreadFactory() {

        private final AtomicInteger mThreadNum = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
            System.out.println(t.getName() + " has been created");
            return t;
        }
    };

public static ExecutorService singleThreadPool = new ThreadPoolExecutor(1, 1,0L,
    TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(1024), 
    namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

    public static int num = 0;


for (int i = 0; i < 300; i++) {

    System.out.println(Thread.currentThread().getName());
    PrintRunnable printRunnable = new PrintRunnable();

    singleThreadPool.execute(printRunnable);
}

singleThreadPool.shutdown();

}