每日六道java新手入门面试题,通往自由的道路--线程池

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

public class ThreadPoolDemo {
    public static void main(String[] args) {
        threadPoolTest();
    }
    private static void threadPoolTest() {
        // 1. 使用工厂类获取线程池对象
        ExecutorService executorService = Executors.newCachedThreadPool();
        // 2. 提交任务
        for (int i = 1; i < 8; i++) {
            executorService.submit(new MyRunnable(i));
        }
    }
}
// 我们的任务类
class MyRunnable implements Runnable {
    private int id;
    public MyRunnable(int id) {
        this.id = id;
    }
    @Override
    public void run() {
        // 打印是哪个线程的名称。
        System.out.println(Thread.currentThread().getName() + "执行了任务" + id);
    }
}

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

public static void main(String[] args) {
    // threadPoolTest();
    threadPoolTest2();
}
private static void threadPoolTest2() {
    // 1. 使用工厂类获取线程池对象
    ExecutorService executorService = Executors.newFixedThreadPool(3);
    // 2. 提交任务
    for (int i = 1; i < 8; i++) {
        executorService.submit(new MyRunnable(i));
    }
}

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

public static void main(String[] args) {
    // threadPoolTest();
    // threadPoolTest2();
    threadPoolTest3();
}
private static void threadPoolTest3() {
    // 1. 使用工厂类获取线程池对象
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    // 2. 提交任务
    for (int i = 1; i < 8; i++) {
        executorService.submit(new MyRunnable(i));
    }
}

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

public static void main(String[] args) {
    //        threadPoolTest();
    //        threadPoolTest2();
    //        threadPoolTest3();
    threadPoolTest4();
}
private static void threadPoolTest4() {
    // 1. 使用工厂类获取线程池对象
    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
    // 2. 每个任务延迟两秒执行
    for (int i = 1; i < 8; i++) {
        scheduledExecutorService.schedule(new MyRunnable(i), 2, TimeUnit.SECONDS);
    }
    System.out.println("看是不是我先执行了！");
}

public ScheduledFuture<?> schedule(Runnable command,
                                       long delay, TimeUnit unit);
延迟时间单位是unit，时间数是delay，任务是Runnable类型的command。
public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                        long delay, TimeUnit unit);
而这个方法是上面方法的重载，不一样的是任务是Callable类型的

// 五个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {...}
// 六个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {...}
// 六个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler) {...}
// 七个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {...}

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();  
    // 1. 获取ctl，ctl是记录着线程池状态和线程数。
    int c = ctl.get();
    // 2. 判断当前线程数小于corePoolSize核心线程,则调用addWorker创建核心线程执行任务
    if (workerCountOf(c) < corePoolSize) {
       if (addWorker(command, true))
           return;
       // 创建线程失败，需要重新获取clt的状态和线程数。
       c = ctl.get();
    }
    // 3. 如果不小于corePoolSize，进入下面的方法。
    // 判断线程池是否运行状态并且运行线程数大于corePoolSize，将任务添加到workQueue队列。
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 3.1 再次检查线程池是否运行状态。
        // 如果isRunning返回false(状态检查)，则remove这个任务，然后执行拒绝策略。
        if (! isRunning(recheck) && remove(command))
            reject(command);
            // 3.2 线程池处于running状态，但是没有线程，则创建线程加入到线程池中
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 4. 如果放入workQueue失败，则创建非核心线程执行任务，
    // 如果这时创建非核心线程失败(当前线程总数不小于maximumPoolSize时)，就会执行拒绝策略。
    else if (!addWorker(command, false))
         reject(command);
}

/**
 * 自定义任务类
 */
public class Task implements Runnable{
    private int id;
    public Task(int id) {
        this.id = id;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "即将执行的任务是" + id + "任务");
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "执行完成的任务是" + id + "任务");
    }
}

public class ThreadPoolExecutorDemo {
    private static final int CORE_POOL_SIZE = 3;
    private static final int MAX_POOL_SIZE = 5;
    private static final int QUEUE_CAPACITY = 10;
    private static final Long KEEP_ALIVE_TIME = 1l;

    public static void main(String[] args) {
        //通过ThreadPoolExecutor构造函数自定义参数创建
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 10; i++) {
            Task task = new Task( i);
            //执行Runnable
            executor.execute(task);
        }
        //终止线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("线程已经全部执行完");
    }
}