多线程——线程池和计时器Timer的基本使用

线程池

有非常的多的任务需要多线程来完成，且每个线程执行时间不会太长，这样会频繁的创建和销毁线程。频繁创建和销毁线程会比较耗性能。如果有了线程池就不要创建更多的线程来完成任务，因为线程可以重用。

线程池用维护者一个队列，队列中保存着处于等待（空闲）状态的线程。不用每次都创建新的线程。
和线程池相关的接口和类存在java.util.concurrent并发包中。

接口:

1. Executor：线程池的核心接口，负责线程的创建使用和调度的根接口。

2. ExecutorService: Executor的子接口，线程池的主要接口, 提供基本功能。

3. ScheduledExecutorService: ExecutorService的子接口,负责线程调度的子接口。

实现类：

1. ThreadPoolExecutor：ExecutorService的实现类，负责线程池的创建使用。

2. ScheduledThreadPoolExecutor：继承 ThreadPoolExecutor，并实现 ScheduledExecutorService接口，既有线程池的功能，又具有线程调度功能。

3. Executors：线程池的工具类，静态方法，负责线程池的创建。

/*创建固定大小线程池*/
newFixedThreadPool(int nThreads);
/*创建缓存线程池，线程池大小没有限制，根据需求自动调整线程数量*/
newCachedThreadPool();
/*创建单个线程的线程池，只有一个线程*/
newSingleThreadExecutor();
/*创建固定大小的线程池，可以延迟或定时执行任务*/
newScheduledThreadPool(int corePoolSize);

/*执行线程，上面构造方法创建的对象直接调用，返回值是任务类*/
Future<?> submit(Runnable task);

/*ScheduledThreadPool类下方法*/
/*创建并执行在给定延迟后启用线程，TimeUnit是时间单位，可以静态调用单位*/
schedule(Callable<V> callable, long delay, TimeUnit unit);
schedule(Runnable command, long delay, TimeUnit unit);
/*
* 整体延迟执行，按照固定速率，周期period执行，【包含线程执行时间】
* 【如果执行时间>周期，则会出现线程追赶进度的情况，在后面的timer部分会详解】
* 【与timer的scheduleAtFixedRate方法一致】
*/
scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);
/*整体延迟执行，在每一次执行终止和下一次执行开始之间都存在给定的周期延迟，【不包含线程执行时间】*/
scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit);

案例1

public class Sum {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //缓冲线线程池，没有固定线程数量，默认一个任务创建一个线程
        ExecutorService executorService1 = Executors.newCachedThreadPool();
        
        //固定5个线程，后面任务是100个，但是只能创建5个线程
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        List<Future<Integer>> list = new ArrayList<>();
        
        //给线程分配任务
        for (int i = 0; i < 100; i++) {
            //该方法返回的都是Future类
            Future<Integer> future = executorService.submit(new Callable<Integer>() {
               public Integer call() throws  Exception {
                   int sum = 0;
                   for (int j = 0; j <= 100; j++) {
                       sum += j;
                   }
                   System.out.println(Thread.currentThread().getName());
                   return sum;
               }
            });
            list.add(future);
        }

        for (Future<Integer> future : list) {
            System.out.println(future.get());
        }

        executorService.shutdown();
    }
}

案例2

public class test {
    /**
     * 并发：多个线程同时执行，并不一定同步，当并发的线程有资源共享问题，一定需要同步
     * 并行：真正的并发，多核CPU，每个内核执行一个线程
     */
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        //创建线程池,2个线程
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        //分配任务，4个任务，但是反复只能创建2个线程
        for (int i = 0; i < 4; i++) {
            //submit提交,就是线程执行了
            executorService.submit(ticket);
        }

        //关闭线程池
        executorService.shutdown();
    }
}

案例3

public class Demo5 {
    public static void main(String[] args) {
        //1创建线程池
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
        //2分配任务，设定时间
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                long start=System.currentTimeMillis();
                System.out.println("开始时间:"+new Date(start).toLocaleString());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                long end=System.currentTimeMillis();
                System.out.println("用时:"+(end-start));
                System.out.println("结束时间:"+new Date(end).toLocaleString());

            }
        },0,5, TimeUnit.SECONDS);	//调用时间单位秒，延迟0秒，周期速率为5秒
    }
}

Timer计时器

可以控制线程的开始时间、间隔和周期时间等。

/**
* 构造方法
*/
Timer timer = new Timer();

//该类遵从Runnable接口，重写run方法，用法和一般的遵从Runnable方法一样
TimerTask tt = new TimerTask();	

/**
* 控制线程方法，将TimerTask对象传入，执行线程
*/
//终止此计时器，丢弃所有当前已安排的任务
void cancel();

//安排在指定的时间（Date时刻表）执行指定的任务，需要cancel()方法终止程序
void schedule(TimerTask task, Date time);

//安排指定的任务在指定的时间（Date时刻表）开始进行重复的固定延迟执行(周期)，需要cancel()方法终止程序
void schedule(TimerTask task, Date firstTime, long period);

//安排在指定延迟后执行指定的任务，需要cancel()方法终止程序
void schedule(TimerTask task, long delay);

//安排指定的任务从指定的延迟后开始进行重复的固定延迟执行，需要cancel()方法终止程序
void schedule(TimerTask task, long delay, long period);

//安排指定的任务在指定的时间（Date时刻表）开始进行重复的固定速率执行，需要cancel()方法终止程序
void scheduleAtFixedRate(TimerTask task, Date firstTime, long period);
 
//安排指定的任务在指定的延迟后开始进行重复的固定速率执行，需要cancel()方法终止程序
void scheduleAtFixedRate(TimerTask task, long delay, long period);

void schedule(TimerTask task, long delay) 方法分析

public class Test {
    public static void main(String[] args) {
        //创建Timer对象
        Timer timer = new Timer();
        //创建任务,是继承Runnable接口的子类
        TimerTask tt = new TimerTask() {
            int index = 0;
            @Override
            public void run() {
                long start = System.currentTimeMillis();
                System.out.println("开始时间：" + new Date(start).toLocaleString());
                index++;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (10 == index) {
                    timer.cancel();
                }
                long end = System.currentTimeMillis();
                System.out.println("用时：" + (end - start));
                System.out.println("结束时间：" + new Date(end).toLocaleString());
            }
        };
        //分配任务
        timer.schedule(tt, 2000);
    }
}

//打印结果，只执行一次，不循环周期执行
开始时间：2019-8-13 16:52:39
用时：1019
结束时间：2019-8-13 16:52:40

只循环一次，且在开始前有2秒的等待，即【long delay】里的参数设置，用时的1秒为sleep。如果将睡眠的时间改为3000，即，大于delay时间，打印结果如下：

开始时间：2019-8-13 16:56:44
用时：3025
结束时间：2019-8-13 16:56:47

显然，并不影响执行时间，只是延迟启动（即整体的第一次启动）。

void schedule(TimerTask task, long delay, long period)方法分析

//将最后的任务分配修改，睡眠时间为1000（1秒）
timer.schedule(tt, 2000, 5000);
//打印结果
开始时间：2019-8-13 16:59:12
用时：1041
结束时间：2019-8-13 16:59:14
开始时间：2019-8-13 16:59:17
用时：1000
结束时间：2019-8-13 16:59:18
开始时间：2019-8-13 16:59:22
用时：1000
结束时间：2019-8-13 16:59:23

//将睡眠时间修改为大于周期period时间，比如6000毫秒，打印结果
开始时间：2019-8-13 17:01:20
用时：6023
结束时间：2019-8-13 17:01:26
开始时间：2019-8-13 17:01:26
用时：6001
结束时间：2019-8-13 17:01:32
开始时间：2019-8-13 17:01:32

可以发现，delay时间仅仅影响整个线程第一次开始的时间，后面的循环不影响；period周期时间计算的是从开始时间到下一次开始时间的间隔，里面包含了sleep时间，所以，当sleep时间大于周期时间的时候，以sleep时间为准，而小于等于的时候，以周期时间为准。

void scheduleAtFixedRate(TimerTask task, long delay, long period)方法分析

该方法与线程池的一样，会有个线程追赶执行问题，这里需要将代码进行一下改动，当执行周期数等于3的时候休眠5秒（大于period），然后继续执行。

public class Test {
    public static void main(String[] args) {
        //创建Timer对象
        Timer timer = new Timer();
        //创建任务,是继承Runnable接口的子类
        TimerTask tt = new TimerTask() {
            int index = 0;
            @Override
            public void run() {
                long start = System.currentTimeMillis();
                System.out.println("开始时间：" + new Date(start).toLocaleString());
                index++;
                try {
                    if(index==3){
                    	System.out.println("【开始休眠5秒】");
                        Thread.sleep(5000);	//等于3的时候睡眠5秒
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                long end = System.currentTimeMillis();
                System.out.println("用时：" + (end - start));
                System.out.println("结束时间：" + new Date(end).toLocaleString());
            }
        };
        //分配任务
        timer.scheduleAtFixedRate(tt, 0, 1000);	//延迟0秒，周期速率为1秒
    }
}

//打印结果：
开始时间：2019-8-13 19:09:05
用时：0
结束时间：2019-8-13 19:09:05
开始时间：2019-8-13 19:09:06
用时：0
结束时间：2019-8-13 19:09:06
开始时间：2019-8-13 19:09:07
【开始休眠5秒】
用时：5001
结束时间：2019-8-13 19:09:12
开始时间：2019-8-13 19:09:12
用时：1
结束时间：2019-8-13 19:09:12
开始时间：2019-8-13 19:09:12
用时：1
结束时间：2019-8-13 19:09:12
开始时间：2019-8-13 19:09:12
用时：1
结束时间：2019-8-13 19:09:12
开始时间：2019-8-13 19:09:12
用时：0
结束时间：2019-8-13 19:09:12
开始时间：2019-8-13 19:09:12
用时：0
结束时间：2019-8-13 19:09:12
开始时间：2019-8-13 19:09:13
用时：0
结束时间：2019-8-13 19:09:13

可以发现，从休眠结束后，共打印出来了5对都是 “2019-8-13 19:09:12” 的时刻，这是因为，此方法不会像 schedule 方法那些做出让步，不管你的执行时间是多少，我都按照我的速率执行，并对下次开始执行时间做出预期，即使执行时间大于我的速率，我也会追赶，直到与我预期时间一致。