JUC---线程池

1.JUC包各大线程池的对比：

1.1SingleThreadExecutor

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SingleThreadPoolTest {
    public static volatile  int sum=0;
    public static void main(String[] args) throws Exception {
        //串行化执行任务
        ExecutorService executorService5 = Executors.newSingleThreadExecutor();

        for(  int i=0;i<100;i++){
            executorService5.execute(()->{
                System.out.println(Thread.currentThread().getName()+":"+sum++);
            });
        }

    }
}

1.2 CachedThreadPool

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CachePoolTest {
    public static volatile  int sum=0;
    public static void main(String[] args) throws Exception {
        ExecutorService executorService5 = Executors.newCachedThreadPool();

        for(  int i=0;i<100;i++){
            executorService5.execute(()->{
                System.out.println(Thread.currentThread().getName()+":"+sum++);
            });
        }
    }
}

1.3 FixedThreadPool

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolTest {
    public static volatile  int sum=0;
    public static void main(String[] args) {
        ExecutorService executorService5 = Executors.newFixedThreadPool(3);

        for(  int i=0;i<100;i++){
            executorService5.execute(()->{
                System.out.println(Thread.currentThread().getName()+":"+sum++);
            });
        }
    }
}

1.4 SingleThreadScheduledExecutor

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledPoolTest {
    public static volatile int sum = 0;

    public static void main(String[] args) {
        ScheduledExecutorService executorService5 = Executors.newSingleThreadScheduledExecutor();
        executorService5.scheduleWithFixedDelay(
                () -> {
                    System.out.println(Thread.currentThread().getName() + ":" + sum++);
                }, 0, 1, TimeUnit.SECONDS);

    }
}

1.5 WorkStealingPool

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class WorkStealingPoolTest {
    public static volatile  int sum=0;
    public static void main(String[] args) throws Exception {
        ExecutorService executorService5 = Executors.newWorkStealingPool(8);
        for( int i=0;i<100;i++){
            executorService5.execute(()->{
                System.out.println(Thread.currentThread().getName()+":"+sum++);
            });
        }


    }
}

2.手动创建线程池

建议手动创建线程池，更灵活

import java.util.concurrent.*;

public class ThreadPoolTest {
    public static volatile int version = 0;

    public static void main(String[] args) throws Exception {
        ExecutorService executorService = new ThreadPoolExecutor(2, 10, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(100));
        for (int i = 0; i < 1000; i++) {
            executorService.execute(() -> {//阻塞队列设置小一点，可以达到被拒绝的效果；默认是阻塞队列满且线程达到最大数时，有新的请求进来，直接拒绝
                System.out.println(Thread.currentThread().getName() + "：" + version++);
            });
        }
    }
}

2.1 corePoolSize 

表示线程池核心线程数，当初始化线程池时，会创建核心线程进入等待状态，即使它是空闲的，核心线程也不会被摧毁，从而降低了任务一来时要创建新线程的时间和性能开销。

2.2 maximumPoolSize 

表示最大线程数,大于最大线程数的任务只能进入阻塞队列进行排队等候，直到有线程空闲了，才能继续执行任务。

2.3 keepAliveTime 

除了核心线程外，那些被新创建出来的线程空闲状态可以存活多久.0表示不销毁。

2.4 unit 

存活时间单位。

2.5 workQueue 

表示任务的阻塞队列。

3 注意

    1.引用的是默认的拒绝策略，当线程数达到最大数量，任务队列已满，直接拒绝新的请求。

    2.  corePoolSize < 线程数 <maximumPoolSize ,新的请求优先放入队列。

   3.  shutDown()停止接收新的submit的任务，已提交的任务（正在运行和队列中的），会继续执行。

   4.  shutDownNow()停止接收新的submit的任务，忽略队列里正在等待的任务，尝试将正在执行的任务打断；返回未执行的队列列表。