java线程池、定时任务

一、自定义线程池

参考

查看三大方法的调用源码，发现本质都是调用了 new ThreadPoolExecutor ( 7 大参数 )

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

}

1、corePollSize
核心线程数。在创建了线程池后，线程中没有任何线程，等到有任务到来时才创建线程去执行任务。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到 corePoolSize 后，就会把到达的任务放到缓存队列当中。

2、maximumPoolSize
最大线程数。表明线程中最多能够创建的线程数量，此值必须大于等于1。

3、keepAliveTime
空闲的线程保留的时间，达到这个时间后，自动释放

4、TimeUnit
空闲线程的保留时间单位。

TimeUnit.DAYS; //天
TimeUnit.HOURS; //小时
TimeUnit.MINUTES; //分钟
TimeUnit.SECONDS; //秒
TimeUnit.MILLISECONDS; //毫秒
TimeUnit.MICROSECONDS; //微妙
TimeUnit.NANOSECONDS; //纳秒

5、BlockingQueue workQueue
阻塞队列，存储等待执行的任务。参数有ArrayBlockingQueue、 LinkedBlockingQueue、SynchronousQueue可选。

6、ThreadFactory
线程工厂，用来创建线程，一般默认即可

7、RejectedExecutionHandler
队列已满，而且任务量大于最大线程的异常处理策略。有以下取值

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

package threadPool;

import java.util.Date;
import java.util.concurrent.*;

/**
 *
 * 自定义线程池。
 * ThreadPoolExecutor<b>构造参数如下</b><br/>
 *
 * int corePoolSize, 核心线程大小(当前最大并行运行线程数)<br/>
 *
 * int maximumPoolSize,最大线程大小（当前最大创建线程数）<br/>
 *
 * long keepAliveTime, 超过corePoolSize的线程多久不活动被销毁时间<br/>
 *
 * TimeUnit unit,时间单位<br/>
 *
 * ArrayBlockingQueue<>(3),有界任务队列，num <br/>
 *
 * ThreadFactory threadFactory 线程池工厂<br/>
 *
 * RejectedExecutionHandler handler 拒绝策略，当可加入线程池的任务满时，maximumPoolSize+num<br/>
 * @author 15594
 */
public class ThreadPoolExecutor_ {

    public static void main(String[] args) {
        //自定义线程池，该线程池最多能放2+3个任务
        ThreadPoolExecutor myPool = new ThreadPoolExecutor(3,
                4,
                60,
                TimeUnit.SECONDS,
//                new LinkedTransferQueue<>(),无界队列,
                //有界队列
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                //new ThreadPoolExecutor.AbortPolicy(), 拒绝策略，直接拒绝
                new MyRejected());
        for (int i = 0; i <100 ; i++) {
            //执行任务
            myPool.execute(new MyTask(i,"name："+i));
        }
        //关闭任务
        myPool.shutdown();
    }
}


/**
 * 自定义拒绝器
 * */
class MyRejected implements RejectedExecutionHandler {



    @Override

    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {

        MyTask task = (MyTask) r;



        System.out.println("报警信息："+task.getTaskName()+" 被线程池拒绝，没有被执行");

        //可以往消息队列中间件里面放 可以发Email等等

    }

}

/**
 * 线程需要执行的任务
 **/
class MyTask implements Runnable {



    private int taskId;



    private String taskName;



    public int getTaskId() {

        return taskId;

    }



    public void setTaskId(int taskId) {

        this.taskId = taskId;

    }



    public String getTaskName() {

        return taskName;

    }



    public void setTaskName(String taskName) {

        this.taskName = taskName;

    }



    public MyTask(int taskId, String taskName) {

        this.taskId = taskId;

        this.taskName = taskName;

    }



    @Override

    public void run() {



        try {

            Thread.sleep(3000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }
        System.out.println(System.currentTimeMillis()+"taskId:" + taskId + ",taskName:" + taskName);
    }

}

二、java提供的四种线程池

参考

package threadPool;

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

/**
 * JDK提供的线程池：<br/>
 * 有四种<br/>
 * newSingleThreadExecutor 创建一个<b>单线程化</b>的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
 * newFixedThreadPool  创建一个<b>定长</b>线程池，可控制线程最大并发数，超出的线程会在队列中等待。
 * newScheduledThreadPool 创建一个<b>可定期或者延时执行任务</b>的定长线程池，支持定时及周期性任务执行。
 * newCachedThreadPool 创建一个<b>可缓存</b>线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
 *
 * @author 15594
 */
public class JDKThreadPoolExecutor_ {
    public static void main(String[] args) {
        //定长的线程池，传入的参数，同时决定了最大的线程并发数（corePoolSize）和创建线程的最大值（maximumPoolSize）。都为10。同时线程队列是无界的（也就是当并发线程任务满时，可以加入的线程队列是没有限制的）
        ExecutorService service = Executors.newFixedThreadPool(10);

        //可定期执行任务的线程池
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);

        //可缓存的线程池
        ExecutorService service1 = Executors.newCachedThreadPool();
        //单线程,的线程池。corePoolSize和maximumPoolSize都为1
        ExecutorService service2 = Executors.newSingleThreadExecutor();
    }
}

三、java定时任务

参考

package timer;

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * java定时任务
 * @author 15594
 */
public class TimerTest {

    public static void main(String[] args) {

        //方式一：Timer
        Timer timer = new Timer();

        timer.scheduleAtFixedRate(new TimerTask01(),3000,1000);

        //方式二：线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程池的方式+123");
            }
        },5,2, TimeUnit.SECONDS);

    }


}
class TimerTask01 extends TimerTask {

    @Override
    public void run() {
        System.out.println("123");
    }
}