java自定义线程池ThreadPoolExecutor

java自定义线程池ThreadPoolExecutor

java线程获取结果Callable、Future、FutureTask

理解 Thread.Sleep 函数

 

自定义创建线程池    

          在我的文章  Java线程池的使用与分析  里也讲到到线程池的各个概念，今天我们就来实践一下，自定义一个线程池。

一、我们回顾一下在 Java线程池的使用与分析 里讲到的关于线程池 ThreadPoolExecutor 的知识点

ThreadPoolExecutor。它提供了好几个构造方法，但是最底层的构造方法却只有一个。那么，我们就从这个构造方法着手分析。 

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler);

这个构造方法有7个参数，我们逐一来进行分析。

  1、corePoolSize，线程池中的核心线程数

  2、maximumPoolSize，线程池中的最大线程数

  3、keepAliveTime，空闲时间，当线程池数量超过核心线程数时，多余的空闲线程存活的时间，即：这些线程多久被销毁。

  4、unit，空闲时间的单位，可以是毫秒、秒、分钟、小时和天，等等

  5、workQueue，等待队列，线程池中的线程数超过核心线程数时，任务将放在等待队列，它是一个BlockingQueue类型的对象

  6、threadFactory，线程工厂，我们可以使用它来创建一个线程

  7、handler，拒绝策略，当线程池和等待队列都满了之后，需要通过该对象的回调函数进行回调处理

这些参数里面，基本类型的参数都比较简单，我们不做进一步的分析。我们更关心的是workQueue、threadFactory和handler，接下来我们将进一步分析。

    1. 等待队列-workQueue

       等待队列是BlockingQueue类型的，理论上只要是它的子类，我们都可以用来作为等待队列。同时，jdk内部自带一些阻塞队列，我们来看看大概有哪些。

  1)ArrayBlockingQueue，队列是有界的，基于数组实现的阻塞队列

  2)LinkedBlockingQueue，队列可以有界，也可以无界。基于链表实现的阻塞队列

  3)SynchronousQueue，不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作将一直处于阻塞状态。该队列也是Executors.newCachedThreadPool()的默认队列

  4)PriorityBlockingQueue，带优先级的无界阻塞队列

     通常情况下，我们需要指定阻塞队列的上界（比如1024）。另外，如果执行的任务很多，我们可能需要将任务进行分类，然后将不同分类的任务放到不同的线程池中执行。

   2. 线程工厂-threadFactory

   ThreadFactory是一个接口，只有一个方法。既然是线程工厂，那么我们就可以用它生产一个线程对象。来看看这个接口的定义。

public interface ThreadFactory {

    /**
     * Constructs a new {@code Thread}.  Implementations may also initialize
     * priority, name, daemon status, {@code ThreadGroup}, etc.
     *
     * @param r a runnable to be executed by new thread instance
     * @return constructed thread, or {@code null} if the request to
     *         create a thread is rejected
     */
    Thread newThread(Runnable r);
}

   Executors的实现使用了默认的线程工厂-DefaultThreadFactory。它的实现主要用于创建一个线程，线程的名字为pool-{poolNum}-thread-{threadNum} 

static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }

    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

很多时候，我们需要自定义线程名字。我们只需要自己实现ThreadFactory，用于创建特定场景的线程即可

3、拒绝策略-handler

    所谓拒绝策略，就是当线程池满了、队列也满了的时候，我们对任务采取的措施。或者丢弃、或者执行、或者其他...

jdk自带4种拒绝策略：

 1)CallerRunsPolicy // 在调用者线程执行

 2)AbortPolicy // 直接抛出RejectedExecutionException异常

 3)DiscardPolicy // 任务直接丢弃，不做任何处理

 4)DiscardOldestPolicy // 丢弃队列里最旧的那个任务，再尝试执行当前任务

       这四种策略各有优劣，比较常用的是DiscardPolicy，但是这种策略有一个弊端就是任务执行的轨迹不会被记录下来。所以，我们往往需要实现自定义的拒绝策略， 通过实现RejectedExecutionHandler接口的方式

4、提交任务的几种方式

     往线程池中提交任务，主要有两种方法，execute()和submit()。

  execute()用于提交不需要返回结果的任务，我们看一个例子。

public static void main(String[] args) {
    ExecutorService executor = Executors.newFixedThreadPool(2);
    executor.execute(() -> System.out.println("hello"));
}

  submit()用于提交一个需要返回果的任务。该方法返回一个Future对象，通过调用这个对象的get()方法，我们就能获得返回结果。get()方法会一直阻塞，直到返回结果返回。另外，我们也可以使用它的重载方法get(long timeout, TimeUnit unit)，这个方法也会阻塞，但是在超时时间内仍然没有返回结果时，将抛出异常TimeoutException。

public static void main(String[] args) throws Exception {
    ExecutorService executor = Executors.newFixedThreadPool(2);
    Future<Long> future = executor.submit(() -> {
        System.out.println("task is executed");
        return System.currentTimeMillis();
    });
    System.out.println("task execute time is: " + future.get());
}

5、关闭线程池

      在线程池使用完成之后，我们需要对线程池中的资源进行释放操作，这就涉及到关闭功能。我们可以调用线程池对象的shutdown()和shutdownNow()方法来关闭线程池。

这两个方法都是关闭操作，又有什么不同呢？

  1、shutdown()会将线程池状态置为SHUTDOWN，不再接受新的任务，同时会等待线程池中已有的任务执行完成再结束。

  2、shutdownNow()会将线程池状态置为SHUTDOWN，对所有线程执行interrupt()操作，清空队列，并将队列中的任务返回回来。

另外，关闭线程池涉及到两个返回boolean的方法，isShutdown()和isTerminated()，分别表示是否关闭和是否终止。

 

二、开始自定义线程池

     1、自定义线程池的原因：

          1）无长度限制的队列，可能因为任务堆积导致OOM

          2）自定义拒绝策略

          3）根据服务器配置，去设置更合理、更高效的 线程池参数，使程序更健壮

    2、写个demo，自定义线程池并且自定义拒绝策略

          从上面可以看到默认提供的四种策略似乎都不太友好，要么放弃要么抛异常，而直接在调用者线程中执行或许也不是你想要的，因为它破坏了线程的执行顺序。

          有时候我们需要保证任务添加不会失败，并且只要被添加的任务能依次顺序执行就好了，而不需要这个添加动作立即响应，即让线程池等待池中的任务完成后再继续添加新任务，此时JDK提供的四种策略无法满足需求，需要自定义拒绝策略

         废话了这么多，现在直接上菜：

package com.montnets.task;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 自定义阻塞型线程池 当池满时会阻塞任务提交
 * 
 */
public class BlockThreadPool {

    private ThreadPoolExecutor pool = null;
    
    public BlockThreadPool(int poolSize) {
        //初始化线程池
        pool = new ThreadPoolExecutor(poolSize, poolSize, 0, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(5), new CustomThreadFactory(),
                new CustomRejectedExecutionHandler());
    }
    
    //销毁线程池
    public void destory() {
        if (pool != null) {
            pool.shutdownNow();
        }
    }

   //自定义创建线程的工厂  自定义线程名称
    private class CustomThreadFactory implements ThreadFactory {
        private AtomicInteger count = new AtomicInteger(0);
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            String threadName = BlockThreadPool.class.getSimpleName() + count.addAndGet(1);
            t.setName(threadName);
            return t;
        }
    }

    //自定义拒绝策略  如果队列已满 就堵塞继续等待 直到队列有空闲
    private class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            try {
                // 核心改造点，由blockingqueue的offer改成put阻塞方法
                executor.getQueue().put(r);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //开始执行
    public void execute(Runnable runnable) {
        this.pool.execute(runnable);
    }

    // 测试构造的线程池
    public static void main(String[] args) {
        BlockThreadPool pool = new BlockThreadPool(3);
        for (int i = 1; i < 100; i++) {
            System.out.println("提交第" + i + "个任务!");
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getId() + "=====开始");
                        TimeUnit.SECONDS.sleep(10);
                        System.out.println(Thread.currentThread().getId() + "=====【结束】");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            System.out.println("【提交第" + i + "个任务成功！】");
        }

        // 2.销毁----此处不能销毁,因为任务没有提交执行完,如果销毁线程池,任务也就无法执行了
        // exec.destory();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

注意：

        这里的例子是   当核心池和缓存队列满了之后外部再调用execute时就会阻塞住，一直等到池里某个任务完成后释放出空闲线程以后，再将该任务添加到缓存队列，而不会抛异常或丢弃该任务。

适用于一些定时扫描触发任务类场景