卡斯特梅的雨伞
卡斯特梅的雨伞

Java高并发系列——检视阅读（五）

Java高并发系列——线程池

JAVA线程池

线程池实现原理

类似于一个工厂的运作。

当向线程池提交一个任务之后，线程池的处理流程如下：

  1. 判断是否达到核心线程数，若未达到，则直接创建新的线程处理当前传入的任务，否则进入下个流程
  2. 线程池中的工作队列是否已满，若未满，则将任务丢入工作队列中先存着等待处理，否则进入下个流程
  3. 是否达到最大线程数，若未达到，则创建新的线程处理当前传入的任务，否则交给线程池中的饱和策略进行处理。
image.png

java中的线程池

jdk中提供了线程池的具体实现，实现类是：java.util.concurrent.ThreadPoolExecutor，主要构造方法：

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

corePoolSize：核心线程大小，当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使有其他空闲线程可以处理任务也会创新线程，等到工作的线程数大于核心线程数时就不会在创建了。如果调用了线程池的prestartAllCoreThreads方法，线程池会提前把核心线程都创造好，并启动。(prestartCoreThread:启动一个核心线程或 prestartAllCoreThreads:启动全部核心线程 )

maximumPoolSize：线程池允许创建的最大线程数。如果队列满了，并且以创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。如果我们使用了无界队列(或者大小是Integer.MAX_VALUE，可能还没达到就OOM了)，那么所有的任务会加入队列，这个参数就没有什么效果了。

keepAliveTime：线程池的工作线程空闲后，保持存活的时间。如果没有任务处理了，有些线程会空闲，空闲的时间超过了这个值，会被回收掉。如果任务很多，并且每个任务的执行时间比较短，避免线程重复创建和回收，可以调大这个时间，提高线程的利用率

unit：keepAliveTIme的时间单位，可以选择的单位有天、小时、分钟、毫秒、微妙、千分之一毫秒和纳秒。类型是一个枚举java.util.concurrent.TimeUnit，这个枚举也经常使用，有兴趣的可以看一下其源码

workQueue：工作队列，用于缓存待处理任务的阻塞队列，常见的有4种（ArrayBlockingQueue 、LinkedBlockingQueue 、SynchronousQueue 、PriorityBlockingQueue ）

threadFactory：线程池中创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字

handler：饱和策略，当线程池无法处理新来的任务了，那么需要提供一种策略处理提交的新任务，默认有4种策略（AbortPolicy 、CallerRunsPolicy 、DiscardOldestPolicy、DiscardPolicy ）

调用线程池的execute方法处理任务，执行execute方法的过程：

  1. 判断线程池中运行的线程数是否小于corepoolsize，是：则创建新的线程来处理任务，否：执行下一步
  2. 试图将任务添加到workQueue指定的队列中，如果无法添加到队列，进入下一步
  3. 判断线程池中运行的线程数是否小于maximumPoolSize，是：则新增线程处理当前传入的任务，否：将任务传递给handler对象rejectedExecution方法处理

线程池的使用步骤：

  1. 调用构造方法创建线程池
  2. 调用线程池的方法处理任务
  3. 关闭线程池

线程池中常见5种工作队列

任务太多的时候，工作队列用于暂时缓存待处理的任务，jdk中常见的4种阻塞队列：

ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按照先进先出原则对元素进行排序

LinkedBlockingQueue：是一个基于链表结构的阻塞队列，此队列按照先进先出排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool使用了这个队列。

SynchronousQueue ：一个不存储元素的阻塞队列，每个插入操作必须等到另外一个线程调用移除操作，否则插入操作一直处理阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用这个队列。

PriorityBlockingQueue：优先级队列，进入队列的元素按照优先级会进行排序。

SynchronousQueue队列的线程池

使用Executors.newCachedThreadPool()创建线程池，看一下的源码：

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

newCachedThreadPool()使用了SynchronousQueue同步队列，这种队列比较特殊，放入元素必须要有另外一个线程去获取这个元素，否则放入元素会失败或者一直阻塞在那里直到有线程取走，示例中任务处理休眠了指定的时间，导致已创建的工作线程都忙于处理任务，所以新来任务之后，将任务丢入同步队列会失败，丢入队列失败之后，会尝试新建线程处理任务。使用上面的方式创建线程池需要注意，如果需要处理的任务比较耗时，会导致新来的任务都会创建新的线程进行处理，可能会导致创建非常多的线程，最终耗尽系统资源，触发OOM。

//SynchronousQueue队列默认是false,采用先进后出的栈处理，也可以是公平队列先进先出。
public SynchronousQueue(boolean fair) {
    transferer = fair ? new TransferQueue() : new TransferStack();
}
PriorityBlockingQueue优先级队列的线程池

输出中，除了第一个任务，其他任务按照优先级高低按顺序处理。原因在于：创建线程池的时候使用了优先级队列，进入队列中的任务会进行排序，任务的先后顺序由Task中的i变量决定。向PriorityBlockingQueue加入元素的时候，内部会调用代码中Task的compareTo方法决定元素的先后顺序。

示例：

public class ThreadPoolExecutorPriorityTest {
    /**
     * 优先级队列执行的任务要实现Comparable比较
     */
    static class Task implements Runnable, Comparable {
        private int i;
        private String name;
        public Task(int i, String name) {
            this.i = i;
            this.name = name;
        }
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "处理" + this.name);
        }
        @Override
        public int compareTo(Task o) {
            return Integer.compare(o.i, this.i);
        }
    }

    //自定义线程工厂,优先级队列
    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 60,
            TimeUnit.SECONDS, new PriorityBlockingQueue<>(), new DemoThreadFactory("订单创建组"), new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            int j = i;
            String taskName = "task" + j;
            executor.execute(new Task(j,taskName));
        }

        for (int i = 90; i <= 100; i++) {
            int j = i;
            String taskName = "task" + j;
            executor.execute(new Task(j,taskName));
        }
        executor.shutdown();
    }
}

输出：

From DemoThreadFactory's 订单创建组-Worker-1处理task1
From DemoThreadFactory's 订单创建组-Worker-1处理task100
From DemoThreadFactory's 订单创建组-Worker-1处理task99
From DemoThreadFactory's 订单创建组-Worker-1处理task98
From DemoThreadFactory's 订单创建组-Worker-1处理task97
From DemoThreadFactory's 订单创建组-Worker-1处理task96
From DemoThreadFactory's 订单创建组-Worker-1处理task95
From DemoThreadFactory's 订单创建组-Worker-1处理task94
From DemoThreadFactory's 订单创建组-Worker-1处理task93
From DemoThreadFactory's 订单创建组-Worker-1处理task92
From DemoThreadFactory's 订单创建组-Worker-1处理task91
From DemoThreadFactory's 订单创建组-Worker-1处理task90
From DemoThreadFactory's 订单创建组-Worker-1处理task10
From DemoThreadFactory's 订单创建组-Worker-1处理task9
From DemoThreadFactory's 订单创建组-Worker-1处理task8
From DemoThreadFactory's 订单创建组-Worker-1处理task7
From DemoThreadFactory's 订单创建组-Worker-1处理task6
From DemoThreadFactory's 订单创建组-Worker-1处理task5
From DemoThreadFactory's 订单创建组-Worker-1处理task4
From DemoThreadFactory's 订单创建组-Worker-1处理task3
From DemoThreadFactory's 订单创建组-Worker-1处理task2

自定义创建线程的工厂

给线程池中线程起一个有意义的名字，在系统出现问题的时候，通过线程堆栈信息可以更容易发现系统中问题所在。通过jstack查看线程的堆栈信息，也可以看到我们自定义的名称 。

自定义创建工厂需要实现java.util.concurrent.ThreadFactory接口中的Thread newThread(Runnable r)方法，参数为传入的任务，需要返回一个工作线程。

示例：

public class ThreadPoolExecutorTest {

    //默认线程创建
    /*  private static ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 60,
              TimeUnit.SECONDS, new LinkedBlockingQueue<>(15), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());*/

    //自定义线程工厂1
/*    private static final AtomicInteger nextId = new AtomicInteger(1);
    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 60,
            TimeUnit.SECONDS, new LinkedBlockingQueue<>(12), (r -> {
        Thread t = new Thread(r);
        t.setName("示范线程" + nextId.getAndIncrement());
        return t;
    }), new ThreadPoolExecutor.AbortPolicy());*/

    //自定义线程工厂2 ，推荐
    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 60,
            TimeUnit.SECONDS, new LinkedBlockingQueue<>(15), new DemoThreadFactory("订单创建组"), new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {
        //提前启动所有核心线程
        executor.prestartAllCoreThreads();
        //提前启动一个核心线程
        executor.prestartCoreThread();
        for (int i = 1; i <= 20; i++) {
            int j = i;
            String taskName = "task" + j;
            executor.execute(() -> {
                try {
                    TimeUnit.SECONDS.sleep(j);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "线程执行" + taskName + "完毕！");
            });
        }
        executor.shutdown();
    }
}

输出：

From DemoThreadFactory's 订单创建组-Worker-1线程执行task1完毕！
From DemoThreadFactory's 订单创建组-Worker-3线程执行task2完毕！
From DemoThreadFactory's 订单创建组-Worker-2线程执行task3完毕！
From DemoThreadFactory's 订单创建组-Worker-4线程执行task4完毕！
From DemoThreadFactory's 订单创建组-Worker-5线程执行task5完毕！
From DemoThreadFactory's 订单创建组-Worker-1线程执行task6完毕！
From DemoThreadFactory's 订单创建组-Worker-3线程执行task7完毕！
From DemoThreadFactory's 订单创建组-Worker-2线程执行task8完毕！
From DemoThreadFactory's 订单创建组-Worker-4线程执行task9完毕！
From DemoThreadFactory's 订单创建组-Worker-5线程执行task10完毕！
From DemoThreadFactory's 订单创建组-Worker-6线程执行task17完毕！
From DemoThreadFactory's 订单创建组-Worker-1线程执行task11完毕！
From DemoThreadFactory's 订单创建组-Worker-7线程执行task20完毕！
From DemoThreadFactory's 订单创建组-Worker-3线程执行task12完毕！
From DemoThreadFactory's 订单创建组-Worker-2线程执行task13完毕！
From DemoThreadFactory's 订单创建组-Worker-4线程执行task14完毕！
From DemoThreadFactory's 订单创建组-Worker-5线程执行task15完毕！

四种常见饱和策略

当线程池中队列已满，并且线程池已达到最大线程数，线程池会将任务传递给饱和策略进行处理。这些策略都实现了RejectedExecutionHandler接口。接口中有个方法：

void rejectedExecution(Runnable r, ThreadPoolExecutor executor)

参数说明：

r：需要执行的任务

executor：当前线程池对象

JDK中提供了4种常见的饱和策略:

AbortPolicy：直接抛出异常。

CallerRunsPolicy：在当前调用者的线程中运行任务，即谁丢来的任务，由他自己去处理。

DiscardOldestPolicy：丢弃队列中最老的一个任务，即丢弃队列头部的一个任务，然后执行当前传入的任务。

DiscardPolicy：不处理，直接丢弃掉，方法内部为空。

解释：

//自定义线程工厂
private static ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 5, 60,
        TimeUnit.SECONDS, new LinkedBlockingQueue<>(5),
        new DemoThreadFactory("订单创建组"), new ThreadPoolExecutor.CallerRunsPolicy());
        
AbortPolicy：直接抛出异常。
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    throw new RejectedExecutionException("Task " + r.toString() +
    " rejected from " +
    e.toString());
}
输出：到饱和策略时抛出异常记录，丢弃掉任务11个。
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.self.current.ThreadPoolExecutorTest$$Lambda$1/1915503092@50134894 rejected from java.util.concurrent.ThreadPoolExecutor@2957fcb0[Running, pool size = 5, active threads = 4, queued tasks = 5, completed tasks = 0]
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
    at com.self.current.ThreadPoolExecutorTest.main(ThreadPoolExecutorTest.java:47)
From DemoThreadFactory's 订单创建组-Worker-1线程执行task1完毕！
From DemoThreadFactory's 订单创建组-Worker-1线程执行task2完毕！
From DemoThreadFactory's 订单创建组-Worker-2线程执行task6完毕！
From DemoThreadFactory's 订单创建组-Worker-1线程执行task3完毕！
From DemoThreadFactory's 订单创建组-Worker-3线程执行task7完毕！
From DemoThreadFactory's 订单创建组-Worker-4线程执行task8完毕！
From DemoThreadFactory's 订单创建组-Worker-5线程执行task9完毕！
From DemoThreadFactory's 订单创建组-Worker-2线程执行task4完毕！
From DemoThreadFactory's 订单创建组-Worker-1线程执行task5完毕！

        
CallerRunsPolicy：在当前调用者的线程中运行任务，即随丢来的任务，由他自己去处理。如main方法调用的线程池，则如果走到饱和策略处理时，由main方法处理这个任务。不会丢弃任何一个任务，但执行会变得很慢。
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }    
输出：
From DemoThreadFactory's 订单创建组-Worker-1线程执行task1完毕！
From DemoThreadFactory's 订单创建组-Worker-1线程执行task2完毕！
From DemoThreadFactory's 订单创建组-Worker-2线程执行task6完毕！
From DemoThreadFactory's 订单创建组-Worker-1线程执行task3完毕！
From DemoThreadFactory's 订单创建组-Worker-3线程执行task8完毕！
From DemoThreadFactory's 订单创建组-Worker-4线程执行task9完毕！
From DemoThreadFactory's 订单创建组-Worker-2线程执行task4完毕！
From DemoThreadFactory's 订单创建组-Worker-5线程执行task10完毕！
main线程执行task11完毕！
From DemoThreadFactory's 订单创建组-Worker-1线程执行task5完毕！
From DemoThreadFactory's 订单创建组-Worker-3线程执行task7完毕！
From DemoThreadFactory's 订单创建组-Worker-4线程执行task12完毕！
From DemoThreadFactory's 订单创建组-Worker-2线程执行task13完毕！
From DemoThreadFactory's 订单创建组-Worker-5线程执行task14完毕！
From DemoThreadFactory's 订单创建组-Worker-1线程执行task15完毕！
main线程执行task17完毕！
From DemoThreadFactory's 订单创建组-Worker-3线程执行task16完毕！

DiscardOldestPolicy：丢弃队列中最老的一个任务，即丢弃队列头部的一个任务，然后执行当前传入的任务。这时候线程池会在执行到饱和策略时丢弃掉头部最老的认为，没有任何记录，任务就丢掉了。
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if (!e.isShutdown()) {
    e.getQueue().poll();
    e.execute(r);
    }
}

输出：20个任务被无声无息地丢掉了11个
From DemoThreadFactory's 订单创建组-Worker-2线程执行task6完毕！
From DemoThreadFactory's 订单创建组-Worker-3线程执行task7完毕！
From DemoThreadFactory's 订单创建组-Worker-4线程执行task8完毕！
From DemoThreadFactory's 订单创建组-Worker-5线程执行task9完毕！
From DemoThreadFactory's 订单创建组-Worker-1线程执行task16完毕！
From DemoThreadFactory's 订单创建组-Worker-2线程执行task17完毕！
From DemoThreadFactory's 订单创建组-Worker-3线程执行task18完毕！
From DemoThreadFactory's 订单创建组-Worker-4线程执行task19完毕！
From DemoThreadFactory's 订单创建组-Worker-5线程执行task20完毕！

DiscardPolicy：不处理，直接丢弃掉，方法内部为空。没处理Runnable r就表示丢弃了。
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}
输出：20个任务被无声无息地丢掉了10个
From DemoThreadFactory's 订单创建组-Worker-1线程执行task1完毕！
From DemoThreadFactory's 订单创建组-Worker-1线程执行task2完毕！
From DemoThreadFactory's 订单创建组-Worker-1线程执行task3完毕！
From DemoThreadFactory's 订单创建组-Worker-2线程执行task7完毕！
From DemoThreadFactory's 订单创建组-Worker-3线程执行task8完毕！
From DemoThreadFactory's 订单创建组-Worker-4线程执行task9完毕！
From DemoThreadFactory's 订单创建组-Worker-5线程执行task10完毕！
From DemoThreadFactory's 订单创建组-Worker-1线程执行task4完毕！
From DemoThreadFactory's 订单创建组-Worker-2线程执行task5完毕！
From DemoThreadFactory's 订单创建组-Worker-3线程执行task6完毕！

自定义饱和策略

需要实现RejectedExecutionHandler接口。任务无法处理的时候，我们想记录一下日志，我们需要自定义一个饱和策略。记录了任务的日志，对于无法处理多任务，我们最好能够记录一下，让开发人员能够知道。 任务进入了饱和策略，说明线程池的配置可能不是太合理，或者机器的性能有限，需要做一些优化调整。

实例：

public class ThreadPoolExecutorRejectHandlerTest {
    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "处理" + this.name);
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        @Override
        public String toString() {
            return "Task{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
    //自定义包含策略:可以直接用函数式方法定义，也可以实现RejectedExecutionHandler自定义
    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 5, 60,
            TimeUnit.SECONDS, new LinkedBlockingQueue<>(5),
            new DemoThreadFactory("订单创建组"), (r,executor)->{
        //自定义饱和策略
        //记录一下无法处理的任务
        System.out.println("无法处理的任务：" + r.toString());
    });

    public static void main(String[] args) {
        //提前启动所有核心线程
        executor.prestartAllCoreThreads();
        //提前启动一个核心线程
        executor.prestartCoreThread();
        for (int i = 1; i <= 20; i++) {
            int j = i;
            String taskName = "task" + j;
            executor.execute(new Task(taskName));
        }
        executor.shutdown();
    }
}

输出：

无法处理的任务：Task{name='task10'}
无法处理的任务：Task{name='task11'}
无法处理的任务：Task{name='task12'}
无法处理的任务：Task{name='task13'}
无法处理的任务：Task{name='task14'}
无法处理的任务：Task{name='task15'}
无法处理的任务：Task{name='task16'}
无法处理的任务：Task{name='task17'}
无法处理的任务：Task{name='task18'}
无法处理的任务：Task{name='task19'}
无法处理的任务：Task{name='task20'}
From DemoThreadFactory's 订单创建组-Worker-1处理task1
From DemoThreadFactory's 订单创建组-Worker-2处理task6
From DemoThreadFactory's 订单创建组-Worker-3处理task7
From DemoThreadFactory's 订单创建组-Worker-4处理task8
From DemoThreadFactory's 订单创建组-Worker-5处理task9
From DemoThreadFactory's 订单创建组-Worker-2处理task2
From DemoThreadFactory's 订单创建组-Worker-1处理task3
From DemoThreadFactory's 订单创建组-Worker-4处理task5
From DemoThreadFactory's 订单创建组-Worker-3处理task4

线程池中的2个关闭方法

线程池提供了2个关闭方法：shutdown和shutdownNow，当调用者两个方法之后，线程池会遍历内部的工作线程，然后调用每个工作线程的interrrupt方法给线程发送中断信号，内部如果无法响应中断信号的可能永远无法终止，所以如果内部有无线循环的，最好在循环内部检测一下线程的中断信号，合理的退出。调用者两个方法中任意一个，线程池的isShutdown方法（是否执行了关闭线程池命令）就会返回true，当所有的任务线程都关闭之后，才表示线程池关闭成功，这时调用isTerminaed方法（是否关闭成功）会返回true。

调用shutdown方法之后，线程池将不再接受新任务，内部会将所有已提交的任务处理完毕，处理完毕之后，工作线程自动退出。

而调用shutdownNow方法后，线程池会将还未处理的（在队里等待处理的任务）任务移除，将正在处理中的处理完毕之后，工作线程自动退出。

至于调用哪个方法来关闭线程，应该由提交到线程池的任务特性决定，多数情况下调用shutdown方法来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow方法。

扩展线程池

ThreadPoolExecutor内部提供了几个方法beforeExecute、afterExecute、terminated，可以由开发人员自己去重写实现这些方法。

看一下线程池内部的源码：

try {
    beforeExecute(wt, task);//任务执行之前调用的方法
    Throwable thrown = null;
    try {
        task.run();
    } catch (RuntimeException x) {
        thrown = x;
        throw x;
    } catch (Error x) {
        thrown = x;
        throw x;
    } catch (Throwable x) {
        thrown = x;
        throw new Error(x);
    } finally {
        afterExecute(task, thrown);//任务执行完毕之后调用的方法
    }
} finally {
    task = null;
    w.completedTasks++;
    w.unlock();
}

beforeExecute：任务执行之前调用的方法，有2个参数，第1个参数是执行任务的线程，第2个参数是任务

protected void beforeExecute(Thread t, Runnable r) { }

afterExecute：任务执行完成之后调用的方法，2个参数，第1个参数表示任务，第2个参数表示任务执行时的异常信息，如果无异常，第二个参数为null

protected void afterExecute(Runnable r, Throwable t) { }

terminated：线程池最终关闭之后调用的方法。所有的工作线程都退出了，最终线程池会退出，退出时调用该方法

实例：

public class ThreadPoolExecutorExtensionTest {
    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "处理" + this.name);
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        @Override
        public String toString() {
            return "Task{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
    //扩展线程池,可以继承也可以直接重写
    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 60,
            TimeUnit.SECONDS, new LinkedBlockingQueue<>(15),
            new DemoThreadFactory("订单创建组"), new ThreadPoolExecutor.AbortPolicy()){
        @Override
        protected void beforeExecute(Thread t, Runnable r) {
            System.out.println(t.getName() + ",开始执行任务:" + r.toString());
        }

        @Override
        protected void afterExecute(Runnable r, Throwable t) {
            System.out.println(Thread.currentThread().getName() + ",任务:" + r.toString() + "，执行完毕!");
        }

        @Override
        protected void terminated() {
            System.out.println(Thread.currentThread().getName() + "，关闭线程池!");
        }
    };

    public static void main(String[] args) {
        for (int i = 1; i <= 3; i++) {
            int j = i;
            String taskName = "task" + j;
            executor.execute(new Task(taskName));
        }
        executor.shutdown();
    }
}

输出：

From DemoThreadFactory's 订单创建组-Worker-1,开始执行任务:Task{name='task1'}
From DemoThreadFactory's 订单创建组-Worker-1处理task1
From DemoThreadFactory's 订单创建组-Worker-2,开始执行任务:Task{name='task2'}
From DemoThreadFactory's 订单创建组-Worker-2处理task2
From DemoThreadFactory's 订单创建组-Worker-3,开始执行任务:Task{name='task3'}
From DemoThreadFactory's 订单创建组-Worker-3处理task3
From DemoThreadFactory's 订单创建组-Worker-1,任务:Task{name='task1'}，执行完毕!
From DemoThreadFactory's 订单创建组-Worker-2,任务:Task{name='task2'}，执行完毕!
From DemoThreadFactory's 订单创建组-Worker-3,任务:Task{name='task3'}，执行完毕!
From DemoThreadFactory's 订单创建组-Worker-3，关闭线程池!

合理地配置线程池

要想合理的配置线程池，需要先分析任务的特性，可以冲一下四个角度分析：

  • 任务的性质：CPU密集型任务、IO密集型任务和混合型任务
  • 任务的优先级：高、中、低
  • 任务的执行时间：长、中、短
  • 任务的依赖性：是否依赖其他的系统资源，如数据库连接。

性质不同任务可以用不同规模的线程池分开处理。CPU密集型任务应该尽可能小的线程，如配置cpu数量+1个线程的线程池。由于IO密集型任务并不是一直在执行任务，不能让cpu闲着，则应配置尽可能多的线程，如：cup数量2。混合型的任务，如果可以拆分，将其拆分成一个CPU密集型任务和一个IO密集型任务*，只要这2个任务执行的时间相差不是太大，那么分解后执行的吞吐量将高于串行执行的吞吐量。可以通过Runtime.getRuntime().availableProcessors()方法获取cpu数量。优先级不同任务可以对线程池采用优先级队列来处理，让优先级高的先执行。

使用队列的时候建议使用有界队列，有界队列增加了系统的稳定性，如果采用无界队列，任务太多的时候可能导致系统OOM，直接让系统宕机。

线程池中线程数量的配置

线程池中总线程大小对系统的性能有一定的影响，我们的目标是希望系统能够发挥最好的性能，过多或者过小的线程数量无法有效的使用机器的性能。在Java Concurrency in Practice书中给出了估算线程池大小的公式：

Ncpu = CUP的数量
Ucpu = 目标CPU的使用率，0<=Ucpu<=1
W/C = 等待时间与计算时间的比例
为保存处理器达到期望的使用率，最优的线程池的大小等于：
Nthreads = Ncpu × Ucpu × (1+W/C)
线程池数量 = CUP的数量 * 目标CPU的使用率 * 等待时间与计算时间的比例

使用建议

在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等创建线程池的方法，但都有其局限性，不够灵活；另外由于前面几种方法内部也是通过ThreadPoolExecutor方式实现，使用ThreadPoolExecutor有助于大家明确线程池的运行规则，创建符合自己的业务场景需要的线程池，避免资源耗尽的风险。

线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

说明：Executors返回的线程池对象的弊端如下：

1） FixedThreadPool和SingleThreadPool：

允许的请求队列：LinkedBlockingQueue长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。

2） CachedThreadPool：

允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

疑问：

Q:LinkedBlockingQueue吞吐量通常要高于ArrayBlockingQueue，为什么？

LinkedBlockingQueue底层是链表，增删效率比较高，而ArrayBlockingQueue底层是数组，增删效率比较低。

最主要的是ArrayBlockingQueue数据的插入与取出共用同一个锁，因此ArrayBlockingQueue并不能实现生产、消费同时进行；
LinkedBlockingQueue中用于阻塞生产者、消费者的锁是两个（锁分离：注意这里是JDK8之前的设计，JDK8之后是用一个锁实现），因此生产与消费是可以同时进行的。

JUC中的Executor框架

Excecutor框架主要包含3部分的内容：

  1. 任务相关的：包含被执行的任务要实现的接口：Runnable接口或Callable接口
  2. 任务的执行相关的：包含任务执行机制的核心接口Executor，以及继承自Executor的ExecutorService接口。Executor框架中有两个关键的类实现了ExecutorService接口（ThreadPoolExecutor和ScheduleThreadPoolExecutor）
  3. 异步计算结果相关的：包含接口Future和实现Future接口的FutureTask类

Executors框架包括：

  • Executor
  • ExecutorService
  • ThreadPoolExecutor
  • Executors
  • Future
  • Callable
  • FutureTask
  • CompletableFuture
  • CompletionService
  • ExecutorCompletionService

Executor接口

Executor接口中定义了方法execute(Runable able)接口，该方法接受一个Runable实例，他来执行一个任务，任务即实现一个Runable接口的类。

ExecutorService接口

ExecutorService继承于Executor接口，他提供了更为丰富的线程实现方法，比如ExecutorService提供关闭自己的方法，以及为跟踪一个或多个异步任务执行状况而生成Future的方法。

ExecutorService有三种状态：运行、关闭、终止。创建后便进入运行状态，当调用了shutdown()方法时，便进入了关闭状态，此时意味着ExecutorService不再接受新的任务，但是他还是会执行已经提交的任务，当所有已经提交了的任务执行完后，便达到终止状态。如果不调用shutdown方法，ExecutorService方法会一直运行下去，系统一般不会主动关闭。

ThreadPoolExecutor类

线程池类，实现了ExecutorService接口中所有方法，参考线程池的使用。

ScheduleThreadPoolExecutor定时器

ScheduleThreadPoolExecutor继承自ThreadPoolExecutor(实现了线程池的核心功能),实现了ScheduledExecutorService（实现了定时器调度功能），他主要用来延迟执行任务，或者定时执行任务。功能和Timer类似，但是ScheduleThreadPoolExecutor更强大、更灵活一些。Timer后台是单个线程，而ScheduleThreadPoolExecutor可以在创建的时候指定多个线程。

public class ScheduledThreadPoolExecutor
        extends ThreadPoolExecutor
        implements ScheduledExecutorService {
            public  ScheduledFuture schedule(Callable callable,
                                           long delay, TimeUnit unit);
        }
schedule:延迟执行任务1次

使用ScheduleThreadPoolExecutor的schedule方法，看一下这个方法的声明：

public ScheduledFuture schedule(Runnable command, long delay, TimeUnit unit)

3个参数：

command：需要执行的任务

delay：需要延迟的时间

unit：参数2的时间单位，是个枚举，可以是天、小时、分钟、秒、毫秒、纳秒等

实例：

//只延迟调度一次
public static void main(String[] args) {
    ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3,
            new DemoThreadFactory("延迟调度线程池"));
    scheduledThreadPool.schedule(()->{
        System.out.println(System.currentTimeMillis()+"开始执行调度！");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(System.currentTimeMillis()+"执行调度结束！");
    },3,TimeUnit.SECONDS);
}

输出：

1598509985652开始执行调度！
1598509990653执行调度结束！
scheduleAtFixedRate:固定的频率执行任务

使用ScheduleThreadPoolExecutor的scheduleAtFixedRate方法，该方法设置了执行周期，下一次执行时间相当于是上一次的执行时间加上period，任务每次执行完毕之后才会计算下次的执行时间。

看一下这个方法的声明：

public ScheduledFuture scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);

4个参数：

command：表示要执行的任务

initialDelay：表示延迟多久执行第一次

period：连续执行之间的时间间隔

unit：参数2和参数3的时间单位，是个枚举，可以是天、小时、分钟、秒、毫秒、纳秒等

假设系统调用scheduleAtFixedRate的时间是T1，那么执行时间如下：

第1次：T1+initialDelay

第2次：T1+initialDelay+period(这时候如果第一次执行完后时间大于固定频率的时间，就会被马上调度起来)

第3次：T1+initialDelay+2*period

第n次：T1+initialDelay+(n-1)*period

实例：

//scheduleAtFixedRate()表示每次方法的执行周期是多久关注的是执行周期，如果已经到了执行周期，就会立即开启调度任务，时间间隔是调度任务开始时间加周期
public static void main2(String[] args) throws ExecutionException, InterruptedException {
    //任务执行计数器
    AtomicInteger count = new AtomicInteger(1);
    ScheduledExecutorService scheduledThreadPool = new ScheduledThreadPoolExecutor(3,
            new DemoThreadFactory("延迟调度线程池"),new ThreadPoolExecutor.AbortPolicy());
    ScheduledFuture schedule = scheduledThreadPool.scheduleAtFixedRate(() -> {
        int currCount = count.getAndIncrement();
        System.out.println(Thread.currentThread().getName()+":"+new Date(System.currentTimeMillis()) + " 第" + currCount + "次" + "开始执行");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+":"+new Date(System.currentTimeMillis()) + " 第" + currCount + "次" + "结束执行");
    }, 1,3, TimeUnit.SECONDS);

}

输出：

From DemoThreadFactory's 延迟调度线程池-Worker-1:Thu Aug 27 14:36:17 CST 2020 第1次开始执行
From DemoThreadFactory's 延迟调度线程池-Worker-1:Thu Aug 27 14:36:22 CST 2020 第1次结束执行
From DemoThreadFactory's 延迟调度线程池-Worker-1:Thu Aug 27 14:36:22 CST 2020 第2次开始执行
From DemoThreadFactory's 延迟调度线程池-Worker-1:Thu Aug 27 14:36:27 CST 2020 第2次结束执行
From DemoThreadFactory's 延迟调度线程池-Worker-2:Thu Aug 27 14:36:27 CST 2020 第3次开始执行
任务当前执行完毕之后会计算下次执行时间，下次执行时间为上次执行的开始时间+period，这个时间小于第一次结束的时间了，说明小于系统当前时间了，会立即执行。
scheduleWithFixedDelay:固定的间隔执行任务

使用ScheduleThreadPoolExecutor的scheduleWithFixedDelay方法，该方法设置了执行周期，与scheduleAtFixedRate方法不同的是，下一次执行时间是上一次任务执行完的系统时间加上period，因而具体执行时间不是固定的，但周期是固定的，是采用相对固定的延迟来执行任务。看一下这个方法的声明：

public ScheduledFuture scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);

4个参数：

command：表示要执行的任务

initialDelay：表示延迟多久执行第一次

period：表示下次执行时间和上次执行结束时间之间的间隔时间

unit：参数2和参数3的时间单位，是个枚举，可以是天、小时、分钟、秒、毫秒、纳秒等

假设系统调用scheduleAtFixedRate的时间是T1，那么执行时间如下：

第1次：T1+initialDelay，执行结束时间：E1(执行结束时间是不固定的)

第2次：E1+period，执行结束时间：E2

第3次：E2+period，执行结束时间：E3

第4次：E3+period，执行结束时间：E4

第n次：上次执行结束时间+period

实例：

//scheduleWithFixedDelay()表示每次方法执行完后延迟多久执行，关注的是延迟时间，时间间隔是调度任务结束时间加延迟时间
public static void main(String[] args) throws ExecutionException, InterruptedException {
    //任务执行计数器
    AtomicInteger count = new AtomicInteger(1);
    ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4,
            new DemoThreadFactory("延迟调度线程池"));
    ScheduledFuture schedule = scheduledThreadPool.scheduleWithFixedDelay(() -> {
        int currCount = count.getAndIncrement();
        System.out.println(Thread.currentThread().getName()+":"+new Date(System.currentTimeMillis()) + " 第" + currCount + "次" + "开始执行");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+":"+new Date(System.currentTimeMillis()) + " 第" + currCount + "次" + "结束执行");
    }, 1,3, TimeUnit.SECONDS);

}

输出：

From DemoThreadFactory's 延迟调度线程池-Worker-1:Thu Aug 27 14:39:16 CST 2020 第1次开始执行
From DemoThreadFactory's 延迟调度线程池-Worker-1:Thu Aug 27 14:39:22 CST 2020 第1次结束执行
From DemoThreadFactory's 延迟调度线程池-Worker-1:Thu Aug 27 14:39:25 CST 2020 第2次开始执行
From DemoThreadFactory's 延迟调度线程池-Worker-1:Thu Aug 27 14:39:30 CST 2020 第2次结束执行
From DemoThreadFactory's 延迟调度线程池-Worker-2:Thu Aug 27 14:39:33 CST 2020 第3次开始执行
延迟1秒之后执行第1次，后面每次的执行时间和上次执行结束时间间隔3秒。

定时任务有异常——没有对异常处理则定时任务会结束

先说补充点知识：schedule、scheduleAtFixedRate、scheduleWithFixedDelay这几个方法有个返回值ScheduledFuture，通过ScheduledFuture可以对执行的任务做一些操作，如判断任务是否被取消、是否执行完成。

再回到上面代码，任务中有个10/0的操作，会触发异常，发生异常之后没有任何现象，被ScheduledExecutorService内部给吞掉了，然后这个任务再也不会执行了，scheduledFuture.isDone()输出true，表示这个任务已经结束了，再也不会被执行了。所以如果程序有异常，开发者自己注意try-catch处理一下，不然跑着跑着发现任务怎么不跑了，也没有异常输出。

实例：

public static void main(String[] args) throws ExecutionException, InterruptedException {
    //任务执行计数器
    AtomicInteger count = new AtomicInteger(1);
    ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4,
            new DemoThreadFactory("延迟调度线程池"));
    ScheduledFuture schedule = scheduledThreadPool.scheduleWithFixedDelay(() -> {
        int currCount = count.getAndIncrement();
        System.out.println(Thread.currentThread().getName()+":"+new Date(System.currentTimeMillis()) + " 第" + currCount + "次" + "开始执行");
    /*    try {
            System.out.println(10/0);
        } catch (Exception e) {
            e.printStackTrace();
        }*/
        System.out.println(10/0);
        System.out.println(Thread.currentThread().getName()+":"+new Date(System.currentTimeMillis()) + " 第" + currCount + "次" + "结束执行");
    }, 1,3, TimeUnit.SECONDS);
    TimeUnit.SECONDS.sleep(3);
    System.out.println(schedule.isCancelled());
    System.out.println(schedule.isDone());
}

输出：

From DemoThreadFactory's 延迟调度线程池-Worker-1:Thu Aug 27 14:45:09 CST 2020 第1次开始执行
false
true

取消定时任务的执行——调用ScheduledFuture的cancel方法

可能任务执行一会，想取消执行，可以调用ScheduledFuture的cancel方法，参数表示是否给任务发送中断信号。

示例：

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //任务执行计数器
        AtomicInteger count = new AtomicInteger(1);
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4,
                new DemoThreadFactory("延迟调度线程池"));
        ScheduledFuture schedule = scheduledThreadPool.scheduleWithFixedDelay(() -> {
            int currCount = count.getAndIncrement();
            System.out.println(Thread.currentThread().getName()+":"+new Date(System.currentTimeMillis()) + " 第" + currCount + "次" + "开始执行");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+new Date(System.currentTimeMillis()) + " 第" + currCount + "次" + "结束执行");
        }, 1,3, TimeUnit.SECONDS);
        TimeUnit.SECONDS.sleep(5);
        schedule.cancel(false);
        TimeUnit.SECONDS.sleep(1);
        System.out.println("任务是否被取消："+schedule.isCancelled());
        System.out.println("任务是否已完成："+schedule.isDone());
    }
}

输出：

From DemoThreadFactory's 延迟调度线程池-Worker-1:Thu Aug 27 14:53:12 CST 2020 第1次开始执行
任务是否被取消：true
任务是否已完成：true
From DemoThreadFactory's 延迟调度线程池-Worker-1:Thu Aug 27 14:53:17 CST 2020 第1次结束执行

Executors类——线程池工具类

Executors类，提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。常用的方法有：

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor()
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)

创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。内部使用了无限容量的LinkedBlockingQueue阻塞队列来缓存任务，任务如果比较多，单线程如果处理不过来，会导致队列堆满，引发OOM。

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)

创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，在提交新任务，任务将会进入等待队列中等待。如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。内部使用了无限容量的LinkedBlockingQueue阻塞队列来缓存任务，任务如果比较多，如果处理不过来，会导致队列堆满，引发OOM。

newCachedThreadPool

public static ExecutorService newCachedThreadPool()
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，

那么就会回收部分空闲（60秒处于等待任务到来）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池的最大值是Integer的最大值(2^31-1)。内部使用了SynchronousQueue同步队列来缓存任务，此队列的特性是放入任务时必须要有对应的线程获取任务，任务才可以放入成功。如果处理的任务比较耗时，任务来的速度也比较快，会创建太多的线程引发OOM。

newScheduledThreadPool

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等创建线程池的方法，但都有其局限性，不够灵活；另外由于前面几种方法内部也是通过ThreadPoolExecutor方式实现，使用ThreadPoolExecutor有助于大家明确线程池的运行规则，创建符合自己的业务场景需要的线程池，避免资源耗尽的风险。

Future、Callable接口

Future、Callable接口需要结合ExecutorService来使用，需要有线程池的支持。

Future接口定义了操作异步异步任务执行一些方法，如获取异步任务的执行结果、取消任务的执行、判断任务是否被取消、判断任务执行是否完毕等。

Callable接口中定义了需要有返回的任务需要实现的方法。——相当于有返回值的Runnable

@FunctionalInterface
public interface Callable {
    V call() throws Exception;
}

比如主线程让一个子线程去执行任务，子线程可能比较耗时，启动子线程开始执行任务后，主线程就去做其他事情了，过了一会才去获取子任务的执行结果。

Future其他方法介绍一下

cancel：取消在执行的任务，参数表示是否对执行的任务发送中断信号，方法声明如下：

boolean cancel(boolean mayInterruptIfRunning);

isCancelled：用来判断任务是否被取消

isDone：判断任务是否执行完毕。

调用线程池的submit方法执行任务，submit参数为Callable接口：表示需要执行的任务有返回值，submit方法返回一个Future对象，Future相当于一个凭证，可以在任意时间拿着这个凭证去获取对应任务的执行结果（调用其get方法），代码中调用了result.get()方法之后，此方法会阻塞当前线程直到任务执行结束。

实例：

    public static void main(String[] args) throws ExecutionException, InterruptedException {
            String taskName = "task";
        Future future = executor.submit(() -> {
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
           // System.out.println(Thread.currentThread().getName() + "线程执行" + taskName + "完毕！");
            return "finished";
        });
        TimeUnit.SECONDS.sleep(1);
        //取消正在执行的任务，mayInterruptIfRunning:是否发送中断信息
        future.cancel(false);
        System.out.println(future.isCancelled());
        System.out.println(future.isDone());
        //System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + ",结果：" + future.get());
        try {
            //超时获取异步任务执行结果
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + ",结果：" + future.get(10,TimeUnit.SECONDS));
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        executor.shutdown();
    }
}

输出：

Exception in thread "main" java.util.concurrent.CancellationException
    at java.util.concurrent.FutureTask.report(FutureTask.java:121)
    at java.util.concurrent.FutureTask.get(FutureTask.java:206)
    at com.self.current.FutureTest.main(FutureTest.java:46)
true
true

FutureTask类

FutureTask除了实现Future接口，还实现了Runnable接口，因此FutureTask可以交给Executor执行，也可以交给线程执行执行（Thread有个Runnable的构造方法），FutureTask表示带返回值结果的任务。线程池的submit方法返回的Future实际类型正是FutureTask对象 。

疑问：

Q:线程池执行submit()方法是如何调用Callable任务的？

A:Callable通过线程池执行的过程，封装为Runnable。线程池执行submit()方法会把Callable包装成FutrueTask对象，此对象实现了Runnable接口，当调用FutrueTask的run方法时，会把其属性中的Callable拿出来执行call()方法。示例代码如下：

  public  Future submit(Callable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }
    
        public void run() {
        try {
            Callable c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        }
    }

Q:多线程并行处理定时任务时，Timer运行多个TimeTask时，只要其中之一没有捕获抛出的异常，其它任务便会自动终止运行，使用ScheduledExecutorService则没有这个问题。是因为ScheduledExecutorService是多线程么？

A:是因为Timer只有一个线程在运行，while(true)循环不断地从队列中获取任务执行，而当线程被被杀死或者中断时，就相当于关闭了Timer.

Q: ScheduleThreadPoolExecutor定时器并不关心线程数多少，他不是并发的执行多任务，只关心调度一个定时任务，线程数的多少只是影响多个任务再调度时需要多个线程，这样理解对么？

A:我认为这样理解是对的，而这样也可以解释上面Timer运行多个TimeTask时，只要其中之一没有捕获抛出的异常，其它任务便会自动终止运行的原因，是因为Timer只有一个线程在运行，while(true)循环不断地从队列中获取任务执行，而当线程被被杀死或者中断时，就相当于关闭了Timer.下面是多个任务调度时会创建多个线程去执行。

From DemoThreadFactory's 延迟调度线程池-Worker-1:Thu Aug 27 14:22:22 CST 2020 第1次开始执行
From DemoThreadFactory's 延迟调度线程池-Worker-2:Thu Aug 27 14:22:22 CST 2020 第2次开始执行
From DemoThreadFactory's 延迟调度线程池-Worker-3:Thu Aug 27 14:22:22 CST 2020 第3次开始执行
From DemoThreadFactory's 延迟调度线程池-Worker-1:Thu Aug 27 14:22:27 CST 2020 第1次结束执行
From DemoThreadFactory's 延迟调度线程池-Worker-2:Thu Aug 27 14:22:27 CST 2020 第2次结束执行
From DemoThreadFactory's 延迟调度线程池-Worker-3:Thu Aug 27 14:22:27 CST 2020 第3次结束执行
From DemoThreadFactory's 延迟调度线程池-Worker-1:Thu Aug 27 14:22:30 CST 2020 第4次开始执行
From DemoThreadFactory's 延迟调度线程池-Worker-4:Thu Aug 27 14:22:30 CST 2020 第5次开始执行
From DemoThreadFactory's 延迟调度线程池-Worker-2:Thu Aug 27 14:22:30 CST 2020 第6次开始执行

CompletionService接口——获取线程池中已经完成的任务

CompletionService相当于一个执行任务的服务，通过submit丢任务给这个服务，服务内部去执行任务，可以通过服务提供的一些方法获取服务中已经完成的任务。

接口内的几个方法：

Future submit(Callable task);

用于向服务中提交有返回结果的任务，并返回Future对象

Future submit(Runnable task, V result);

用户向服务中提交有返回值的任务去执行，并返回Future对象。Runnable会被包装成有返回值的Callable，返回值为传入的result。

Future take() throws InterruptedException;

从服务中返回并移除一个已经完成的任务，如果获取不到，会一致阻塞到有返回值为止。此方法会响应线程中断。

Future poll();

从服务中返回并移除一个已经完成的任务，如果内部没有已经完成的任务，则返回空，此方法会立即响应。

Future poll(long timeout, TimeUnit unit) throws InterruptedException;

尝试在指定的时间内从服务中返回并移除一个已经完成的任务，等待的时间超时还是没有获取到已完成的任务，则返回空。此方法会响应线程中断

通过submit向内部提交任意多个任务，通过take方法可以获取已经执行完成的任务，如果获取不到将等待。

ExecutorCompletionService

ExecutorCompletionService类是CompletionService接口的具体实现。

说一下其内部原理，ExecutorCompletionService创建的时候会传入一个线程池，调用submit方法传入需要执行的任务，任务由内部的线程池来处理；ExecutorCompletionService内部有个阻塞队列，任意一个任务完成之后，会将任务的执行结果（Future类型）放入阻塞队列中，然后其他线程可以调用它take、poll方法从这个阻塞队列中获取一个已经完成的任务，获取任务返回结果的顺序和任务执行完成的先后顺序一致，所以最先完成的任务会先返回。

看一下构造方法：

public ExecutorCompletionService(Executor executor) {
        if (executor == null)
            throw new NullPointerException();
        this.executor = executor;
        this.aes = (executor instanceof AbstractExecutorService) ?
            (AbstractExecutorService) executor : null;
        this.completionQueue = new LinkedBlockingQueue>();
    }

构造方法需要传入一个Executor对象，这个对象表示任务执行器，所有传入的任务会被这个执行器执行。

completionQueue是用来存储任务结果的阻塞队列，默认用采用的是LinkedBlockingQueue，也支持开发自己设置。通过submit传入需要执行的任务，任务执行完成之后，会放入completionQueue中。

任务完成入队操作原理：

还是通过线程池execute()方法执行一个FutureTask包装的Callable任务，FutureTask里的run方法会调用Callable任务call()方法执行具体的行为，并在执行结算后执行set(result);设置返回值操作，而设置返回值操作中的finishCompletion()方法会调用钩子方法done(),ExecutorCompletionService里定义的QueueingFuture继承了FutureTask，重写了钩子方法，把完成的方法入队保存起来了。

场景：买新房了，然后在网上下单买冰箱、洗衣机，电器商家不同，所以送货耗时不一样，然后等他们送货，快递只愿送到楼下，然后我们自己将其搬到楼上的家中。 这时候我们需要根据异步先完成的快递，拿个先到对其获取做处理——搬上楼。

示例：

public class ExecutorCompletionServiceTest {

    static class GoodsModel {
        //商品名称
        String name;
        //购物开始时间
        long startime;
        //送到的时间
        long endtime;

        public GoodsModel(String name, long startime, long endtime) {
            this.name = name;
            this.startime = startime;
            this.endtime = endtime;
        }

        @Override
        public String toString() {
            return name + "，下单时间[" + this.startime + "," + endtime + "]，耗时:" + (this.endtime - this.startime);
        }
    }
    /**
     * 将商品搬上楼
     *
     * @param goodsModel
     * @throws InterruptedException
     */
    static void moveUp(GoodsModel goodsModel) throws InterruptedException {
        //休眠5秒，模拟搬上楼耗时
        TimeUnit.SECONDS.sleep(5);
        System.out.println("将商品搬上楼，商品信息:" + goodsModel);
    }

    /**
     * 模拟下单
     *
     * @param name     商品名称
     * @param costTime 耗时
     * @return
     */
    static Callable buyGoods(String name, long costTime) {
        return () -> {
            long startTime = System.currentTimeMillis();
            System.out.println(startTime + "购买" + name + "下单!");
            //模拟送货耗时
            try {
                TimeUnit.SECONDS.sleep(costTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            long endTime = System.currentTimeMillis();
            System.out.println(endTime + name + "送到了!");
            return new GoodsModel(name, startTime, endTime);
        };
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        long st = System.currentTimeMillis();
        System.out.println(st + "开始购物!");
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 60,
                TimeUnit.SECONDS, new LinkedBlockingQueue<>(10),
                new DemoThreadFactory("订单创建组"), new ThreadPoolExecutor.AbortPolicy());
        ExecutorCompletionService completionService = new ExecutorCompletionService<>(executor);
        //异步下单购买
        completionService.submit(buyGoods("电视机", 3));
        completionService.submit(buyGoods("洗碗机", 5));
        executor.shutdown();
        for (int i = 0; i < 2; i++) {
            //可以获取到最先到的商品
            GoodsModel goodsModel = completionService.take().get();
            //将最先到的商品送上楼
            moveUp(goodsModel);
        }
        long et = System.currentTimeMillis();
        System.out.println(et + "货物已送到家里咯，哈哈哈！");
        System.out.println("总耗时:" + (et - st));
    }
}

1598583792616开始购物!
1598583792707购买电视机下单!
1598583792708购买洗碗机下单!
1598583795708电视机送到了!
1598583797709洗碗机送到了!
将商品搬上楼，商品信息:电视机，下单时间[1598583792707,1598583795708]，耗时:3001
将商品搬上楼，商品信息:洗碗机，下单时间[1598583792708,1598583797709]，耗时:5001
1598583805710货物已送到家里咯，哈哈哈！
总耗时:13094

异步执行一批任务，有一个完成立即返回，其他取消——线程池invokeAny ()方法

如果是要返回所有的任务结果，则调用 invokeAll(Collection> tasks)方法，invokeAny ()和invokeAll（）都有超时调用方法。如果超时时间到了，调用结束后还没有全部完成，会对所有工作线程发送中断信号中断操作。

方法声明如下：

 T invokeAny(Collection> tasks)
        throws InterruptedException, ExecutionException;

示例：

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        long st = System.currentTimeMillis();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 60,
                TimeUnit.SECONDS, new LinkedBlockingQueue<>(10),
                new DemoThreadFactory("订单创建组"), new ThreadPoolExecutor.AbortPolicy());
        List> list = new ArrayList<>();
        int taskCount = 5;
        for (int i = taskCount; i > 0; i--) {
            int j = i * 2;
            String taskName = "任务"+i;
            list.add(() -> {
                TimeUnit.SECONDS.sleep(j);
                System.out.println(taskName+"执行完毕!");
                return j;
            });
        }
        //Integer integer = invokeAny(executor, list);
        //ExecutorService提供异步执行一批任务，有一个完成立即返回，其他取消
        Integer integer = executor.invokeAny(list);
        System.out.println("耗时:" + (System.currentTimeMillis() - st) + ",执行结果:" + integer);
        executor.shutdown();
    }

    private static  T invokeAny(ThreadPoolExecutor executor, List> list) throws InterruptedException, ExecutionException {
        ExecutorCompletionService completionService = new ExecutorCompletionService(executor);
        List> futureList = new ArrayList<>();
        for (Callable s : list) {
            futureList.add(completionService.submit(s));
        }
        int n = list.size();
        try {
            for (int i = 0; i < n; ++i) {
                T r = completionService.take().get();
                if (r != null) {
                    return r;
                }
            }
        } finally {
            for (Future future : futureList) {
                future.cancel(true);
            }
        }
        return null;
    }
}

输出：

任务1执行完毕!
耗时:2053,执行结果:2

CompletableFuture——当异步任务完成或者发生异常时，自动调用回调对象的回调方法，主线程无需等待获取结果,异步是以守护线程执行的，如果是用线程池作为执行器则不是守护线程

使用Future获得异步执行结果时，要么调用阻塞方法get()，要么轮询看isDone()是否为true，这两种方法都不是很好，因为主线程也会被迫等待。

从Java 8开始引入了CompletableFuture，它针对Future做了改进，可以传入回调对象，当异步任务完成或者发生异常时，自动调用回调对象的回调方法。

我们以获取股票价格为例，看看如何使用CompletableFuture：

CompletableFuture的优点是：

  • 异步任务结束时，会自动回调某个对象的方法；
  • 异步任务出错时，会自动回调某个对象的方法；
  • 主线程设置好回调后，不再关心异步任务的执行。

如果只是实现了异步回调机制，我们还看不出CompletableFuture相比Future的优势。CompletableFuture更强大的功能是，多个CompletableFuture可以串行执行，多个CompletableFuture还可以并行执行。

除了anyOf()可以实现“任意个CompletableFuture只要一个成功”，allOf()可以实现“所有CompletableFuture都必须成功”，这些组合操作可以实现非常复杂的异步流程控制。

最后我们注意CompletableFuture的命名规则：

  • xxx()：表示该方法将继续在已有的线程中执行；
  • xxxAsync()：表示将异步在线程池中执行。

示例：

public class CompletableFutureTest {

    public static void main(String[] args) throws Exception {
        // 创建异步执行任务:
        CompletableFuture cf = CompletableFuture.supplyAsync(CompletableFutureTest::fetchPrice);
        // 如果执行成功:
        cf.thenAccept((result) -> {
            System.out.println("price: " + result);
        });
        // 如果执行异常:
        cf.exceptionally((e) -> {
            e.printStackTrace();
            return null;
        });
        // 主线程不要立刻结束，否则CompletableFuture默认使用的线程池会立刻关闭:
        Thread.sleep(200);
    }

    static Double fetchPrice() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
        }
        if (Math.random() < 0.3) {
            throw new RuntimeException("fetch price failed!");
        }
        return 5 + Math.random() * 20;
    }

}

定义两个CompletableFuture，第一个CompletableFuture根据证券名称查询证券代码，第二个CompletableFuture根据证券代码查询证券价格，这两个CompletableFuture实现串行操作如下：

public class CompletableFutureSerialTest {

    public static void main(String[] args) throws InterruptedException {
        //先获取股票代码
        CompletableFuture tesla = CompletableFuture.supplyAsync(() -> {
            return CompletableFutureSerialTest.queryCode("tesla");
        });
        //再获取股票代码对应的股价
        CompletableFuture priceFuture = tesla.thenApplyAsync((code) -> {
            return CompletableFutureSerialTest.fetchPrice(code);
        });
        //打印结果
        priceFuture.thenAccept((price)->{
            System.out.println("price: " + price);
        });
        // 主线程不要立刻结束，否则CompletableFuture默认使用的线程池会立刻关闭:
        Thread.sleep(2000);
    }

    static String queryCode(String name) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
        }
        return "601857";
    }

    static Double fetchPrice(String code) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
        }
        return 5 + Math.random() * 20;
    }
}

输出：

price: 23.116752498711122

示例：同时从新浪和网易查询证券代码，只要任意一个返回结果，就进行下一步查询价格，查询价格也同时从新浪和网易查询，只要任意一个返回结果，就完成操作。

public class CompletableFutureParallelTest {

    public static void main(String[] args) throws InterruptedException {
        // 两个CompletableFuture执行异步查询:
        CompletableFuture teslaSina = CompletableFuture.supplyAsync(() -> {
            return CompletableFutureParallelTest.queryCode("tesla","https://finance.sina.com.cn/code/");
        });

        CompletableFuture tesla163 = CompletableFuture.supplyAsync(() -> {
            return CompletableFutureParallelTest.queryCode("tesla","https://money.163.com/code/");
        });
        // 用anyOf合并为一个新的CompletableFuture:
        CompletableFuture stockFuture = CompletableFuture.anyOf(tesla163, teslaSina);

        //再获取股票代码对应的股价
        // 两个CompletableFuture执行异步查询:
        CompletableFuture priceSina = stockFuture.thenApplyAsync((code) -> {
            return CompletableFutureParallelTest.fetchPrice(String.valueOf(code),"https://money.163.com/code/");
        });
        CompletableFuture price163 = stockFuture.thenApplyAsync((code) -> {
            return CompletableFutureParallelTest.fetchPrice(String.valueOf(code),"https://money.163.com/code/");
        });
        // 用anyOf合并为一个新的CompletableFuture:
        CompletableFuture priceFuture = CompletableFuture.anyOf(priceSina, price163);

        //打印结果
        priceFuture.thenAccept((price)->{
            System.out.println("price: " + price);
        });
        // 主线程不要立刻结束，否则CompletableFuture默认使用的线程池会立刻关闭:
        Thread.sleep(2000);
    }

    static String queryCode(String name, String url) {
        System.out.println("query code from " + url + "...");
        try {
            Thread.sleep((long) (Math.random() * 100));
        } catch (InterruptedException e) {
        }
        return "601857";
    }

    static Double fetchPrice(String code, String url) {
        System.out.println("query price from " + url + "...");
        try {
            Thread.sleep((long) (Math.random() * 100));
        } catch (InterruptedException e) {
        }
        return 5 + Math.random() * 20;
    }
}


query code from https://finance.sina.com.cn/code/...
query code from https://money.163.com/code/...
query price from https://money.163.com/code/...
query price from https://money.163.com/code/...
price: 17.34369661842006

























你可能感兴趣的:(Java高并发系列——检视阅读（五）)






    

  • 迎接2019
唯有杜康1994

    告别2018这一年是机遇与挑战，痛苦与喜悦，失去与收获的一年一月:收获了第一份爱情，开始真正想去了解一个人三月:对工作有了更深入的认识，靠自己的力量完成晋升五月:搬家，住进了自己理想的公寓，一间属于自己的屋子。满地的书六月:外调广州，升经理，有了自己的第一个团队。七月:怀着自我否定，第一次完成了部门任务八月:第一个员工流失，痛哭不已明白无不散之筵席九月:员工陆续离开，经济是一切的根本。十月:陪员工
    

    • 

  • 被隔离的日子（五）@三七会写作营
三七会萍海临风

    从隔离的初期，我们三人都不适应，彼此说话都还火药味十足。后随着时间的推移，到现在，我们仨人能够心平气和，幽默地对待彼此。看来，时间可真是个好东西，不仅能见证一个人的心性，还能看清自己的需求、他人的本质。今天晚上，孩子跑到厨房，告诉我她给人捐款了。我纳闷，不是给河南捐过款了么。当时，我还落后于她捐的呢。这次又捐给谁？看到我一脸狐疑，孩子说，还记得初四给她补课的那个男老师么？当让记得，当时，就因为是男
    

    • 

  • word字号和mathtype磅值关系及批量修改
小铁匠-Ma
office小技巧经验分享

    word字号和mathtype磅值关系及批量修改1.字号与磅值关系字号「八号」对应磅值5字号「七号」对应磅值5.5字号「小六」对应磅值6.5字号「六号」对应磅值7.5字号「小五」对应磅值9字号「五号」对应磅值10.5字号「小四」对应磅值12字号「四号」对应磅值14字号「小三」对应磅值15字号「三号」对应磅值16字号「小二」对应磅值18字号「二号」对应磅值22字号「小一」对应磅值24字号「一号」对应
    

    • 

  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）
华为OD题库
华为od链表java

    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
    

    • 

  • 学习JavaEE的日子 Day32 线程池
A 北枝
学习JavaEE学习java-eejava线程池

    Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
    

    • 

  • 为什么说仪式和习惯非常重要？
章鱼老师zy

    这是章鱼姐第【40】篇原创文章，日更计划第【37/100】天。阅读张萌萌姐【精力管理手册】第【6/7】章。一阅读摘要这一章萌姐讲到了习惯的重要性，为什么说养成一个习惯很重要？如何养成一个好习惯？如何建立自己的仪式感？二金句精力管理最重要的是产生什么效果。当你想做却没有动力去做一件事情时，你就应该把它养成习惯。习惯可以帮我们创造稳定框架。对于那些特别考验意志的事情，我们应该先行后思。三思考题，萌姐讲
    

    • 

  • 细水长流的日子之二百五十二（一点一点慢慢长大）
独一无二的小茶叶

    2021-10-22今天小妹妹刚来，见到放在桌篓子里晾着的薰青豆，想要吃，给她拿个小碗装了点，我正在厨房收拾，嘱咐她自己去坐在小椅子上吃，她却一屁股坐在厨房门口的地板上吃起来不小心打翻了，就直接趴在地板上一粒一粒地捡拾。口渴了，自己去把奶瓶里剩下的奶喝掉，然后到厨房门口将奶瓶提给我让我洗干净，把手伸的很长，边小嘴巴里说哇哇，我不让她的小脚跨进厨房半步，怕自己有时没看好出现意外，她牢牢记着，脚绝对不
    

    • 

  • 【算法分析与设计】去除重复字母
五敷有你
算法分析与设计javajavascript开发语言算法数据结构

    个人主页：五敷有你系列专栏：算法分析与设计⛺️稳中求进，晒太阳题目给你一个字符串s，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证返回结果的字典序最小（要求不能打乱其他字符的相对位置）。示例示例1：输入：s="bcabc"输出："abc"示例2：输入：s="cbacdcbc"输出："acdb"思路贪心+单调栈实现【字符串删除一个字符使其字典序最小的贪心策略】：对于两个长度相同的字符串，
    

    • 

  • 12-25
yummy0632

    72.4kg早饭：一碗面条，俩鸡蛋，三个砂糖桔。五天过去了，这本书我听完了。哈哈简直了。真兴奋，我准备好了，迎接新的自己。午饭：一个花卷，一碗汤，一份油菜，一份冬瓜粉条，一份红烧肉。晚饭：一个花卷，一份芹菜，一份土豆，一份鸭子。很咸。
    

    • 

  • 没有如释重负
君远近

    虽然只有短短的一个多月的努力复习时间，但今天的整个考试经过，还是发现了效果的，题目做的比较自如，没有慌里慌张，而且提前五分钟完成。至于考试成绩，没有实足的把握，60分都不敢保证。但绝对相信自己，比去年肯定要好！今天早早的赶到考场，见到了刘老师，谈起来学习情况，坦率的说，真的是自己不够重视。总以为会很难，没有信心。其实不是的，只要认真对待，树立足够的信心，绝对可以通过考试的。还向老师询问了，后续再报
    

    • 

  • 入伏（五）
喜马ma

    图片发自App入伏13今天我看见很多蜻蜓在飞飞得很低想起小学时学的那点知识在这闷热的午后真能来一场暴雨太过瘾了入伏14有点像瓢虫的昆虫喜欢吃葡萄叶喜欢交配在炎热的夏天如果你在葡萄园看见两只昆虫它们不是在吃葡萄叶就是在交配请记住它们的名字叫葡萄十星红甲
    

    • 

  • 2021.12.13 自律日记
夏舒帅然a

    深感时光转瞬即逝，如指缝流金！自律、习惯养成、执行力提高迫在眉睫！今天是什么日子：平日艳阳天起床：7：50任务清单（明日）1.起床：7:302.就寝：10：103.读书30分钟4.打两套太极5.两次静坐（每次15分钟）昨日完成的任务情况，最重要的三件事一.读书30分。未完成二.就寝10：00完成三.起床7：30未完成四.打两套太极未完成五.两次静坐（每次15分钟）未完成习惯养成：早睡早起、每日读书
    

    • 

  • 2022-2-13晨间日记
越亮也打烊

    今天是什么日子起床：7:00就寝：12:08天气：晴心情：糟糕纪念日：无任务清单昨日完成的任务，最重要的三件事：寒假作业，网课，画画改进：作业时间剪短习惯养成：网课不逃～周目标·完成进度数学卷子100％学习·信息·阅读《傅雷家书》《钢铁是怎样炼成的》健康·饮食·锻炼我终于不喝饮料啦，喝茶～人际·家人·朋友邝姐姐带我吃火锅工作·思考啥时候开学，我还有几天赶完作业最美好的三件事1.卷子写完了2.我有冰
    

    • 

  • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？
AaronWang94
shirojavajava安全开发语言

    请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
    

    • 

  • 中国最美的100个地方，待“软禁”结束后，满血复活去一次旅行！
是北河二1995

    【阅读原文，请点击：原文，硬核100个】离成为一个倾国倾城、走路带风的女子还有365天！大家好，我是小草们的北河二~一转眼，2020年已过1/4，突如其来的病毒，搅得人心惶惶。原本的3月里，景区爆满、街道拥堵、小吃铺做无缺席。然而，地球妈妈不会一直宠着我们，给了我们好几个警告。如今，连CCTV-1播出的《人与自然》，我都可以看上好一会儿......高山、流水、湖泊、森林、大海.....它们也在这初
    

    • 

  • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？
大龄下岗程序员
mysqljavamysqlspring

    Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
    

    • 

  • 标定系列——基于OpenCV实现普通相机、鱼眼相机不同标定板下的标定（五）
JANGHIGH
标定opencv

    标定系列——基于OpenCV实现相机标定（五）说明代码解析VID5.xmlin_VID5.xmlcamera_calibration.cpp说明该程序可以实现多种标定板的相机标定工作代码解析VID5.xmlimages/CameraCalibration/VID5/xx1.jpgimages/CameraCalibration/VID5/xx2.jpgimages/CameraCalibratio
    

    • 

  • 3、JavaWeb-Ajax/Axios-前端工程化-Element
所谓远行Misnearch
#JavaWeb前端ajaxelementuijava前端框架

    P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
    

    • 

  • 机会是争取来的
正版小强强

    结束了这周，这周就可以一门心思的在找工作工作上了。时隔好久，再回到职场，虽然现在还没回去，但心里面也是五味翻腾，而且是有点急不可耐的想回去了。本周重点是三管齐下，既海投、定投、已投相结合策略，大量海投，有针对性定投，重点已投并取得联系的那几份，各方面都要下功夫，花心思，多做功课，又备才能无患。
    

    • 

  • 傲娇||这几年我追过五月天的那几场演唱会
进击的嘉欣大小姐

    一直想要认真的去思考这件事情，码字说一下这几年我追过的那几场五月天演唱会，作为入坑手帐的我，做过美食手帐、旅行手帐、电影手帐、日常手帐，唯独一直没有写过我的追星手帐，票根就一直存留着，周边不断买买买，但是依旧没有狠下心去写自己的一路追演唱会的感觉。2012.5.26–南宁自出娘胎的二十多年来第一场演唱会就是五月天诺亚方舟巡回南宁场，最惊心动魄的一场，从此进入五月天的神坑无法自拔，那是毕业出来的工作
    

    • 

  • 倒贴服传奇在什么平台下载 2024最火的倒贴服传奇平台排行榜
诸葛村夫一游戏频道

    2024游戏盒子网站排行榜大全随着数位科技的发展，2024年手游市场持续火爆，各种新开手游持续涌现。本文为广大手游爱好者带来巅峰推荐，总结五个最具实力的手游新服发布网站，为您提供最全面的游戏资讯以及专业的游戏攻略。▶2024最火的倒贴服传奇平台排行榜TOP1：游戏豹官网特点：内部特权游戏类型：多类型推荐日活跃人数：15万网址链接：www.ystt88.cn游戏介绍：游戏豹官网以快速获取新开手游的特
    

    • 

  • “播下种子，亲近梦想”北京研学营日记Day2
贝壳Bella

    到目前为止，没有收到同学们想家的反馈，应该没有孩子哭，从门外听到的也是一片安静，估计一个个都进入了梦想。从6:30至9:00回到酒店，的确有些辛苦。有些孩子坚持得很好，有些在下午五点离开科技馆时已经疲惫不堪，嚷嚷着回酒店。于是，餐后在车上立了一个规矩，明天在长城上喊累不能超过三次，因为这也是会传染的。图片发自App从科技馆步行至鸟巢，在等红绿灯时居然就有同学蹲下了。有些孩子一上车睡觉，养好精神，路
    

    • 

  • “姜子牙”回归神位，告别老艺术家蓝天野
喵十一呀

    根据央视新闻报道，今天下午，2022年6月8日，著名的人民艺术家，“七一勋章”获得者蓝天野，因病在北京离世，享年95岁。蓝老先生，原名王润森，出生于河北省。从上个世纪四十年代就投身于话剧事业，曾在经典话剧《北京人》《茶馆》《蔡文姬》中扮演重要角色。对于我们父母那一辈人来说，这段记忆比较深刻。而对于七八零后的朋友来说，蓝老先生最让人熟悉的角色便是《封神榜》中的姜子牙。在那个年代，剧组人员硬是用五毛钱
    

    • 

  • 上班族适合兼职的副业有哪些？分享五个适合上班族做的副业
高省张导师

    对于许多上班族来说，除了日常工作外，还有大量的空闲时间，因此兼职成为了一项非常普遍的选择。下面将向您介绍五个不错的兼职副业，每个兼职都可以很容易地从家中启动，同时也是一个短期见效的方式，可以让您很快增加收入。大家好，我是高省APP最大团队，【高省】是一个可省钱佣金高，能赚钱有收益的平台，百度有几百万篇报道，也期待你的加入。高省邀请码520888，注册送2皇冠会员，送万元推广大礼包。1、社交导购电商
    

    • 

  • 今日阅读任务
扎西措的简书

    四圣谛是总纲释迦牟尼佛开示的法很多，其中四圣谛是纲要。一般祖师们讲经或讲论时，会先讲“略”的，再讲“广”的，先讲纲要，把方向抓出来，再慢慢慢慢发展;如果一开始就从头讲到尾，可能会让听者东南西北都搞不清。先把大纲抓住，就容易与别的法连结。释尊所讲的所有法当中，包括小乘、大乘、显教、密教的法，总的来说，四圣谛是纲要，不论南传的小乘佛教、或是汉传与藏传的大乘佛教，四圣谛是大家共同承认的、大家共有的基础。
    

    • 

  • 『阅读•思考•灵性新苑‖第九辑/358/1001』《冥想》2作者：[印]斯瓦米·拉玛（Swami Rama） 译者：刘海凝
景熙惟

    部分节选当我们仔细审视生活，就会意识到：从幼年开始，我们接受的教育就仅仅止于观察和了解外部世界。从来没人教导过我们，应当如何向内看、发现和了解内在。因此我们在渴望了解别人的同时，对自己而言却依然是一个陌生人。由于缺乏自我了解，我们的人际关系并不那么称心如意，生活中也常常充满了困惑与失望。事实上，常规教育体系只开发了我们大脑的一小部分。而另外负责做梦、睡眠以及用于存储所有经历的无意识领域，仍不为人知
    

    • 

  • 枚举使用笔记
万变不离其宗_8
项目笔记笔记

    1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
    

    • 

  • Everyday is Mayday | 祝五月天23th成团快乐
不在摇滚区

    997年3月29日，“SoBand”乐队正式改名为“MayDay”。1999年，刘冠佑正式加入五月天。发行了第首张录音室专辑《五月天第一张创作专辑》。深受英国摇滚乐队披头士的影响，五月天相信摇滚乐拥有可以改变世界的力量，通过摇滚可以将爱与希望传递到每一个角落。五月天的五个人，都不算多有天资。阿信小时候很喜欢唱歌，但是没有很好的天赋。（快来看陈信宏）他说，在小学的时候，他想加入合唱队，但是只唱了两个
    

    • 

  • 让孩子幸福的语言
梓沐儿

    #21本育儿书挑战今天阅读的是《让孩子幸福的语言》，全书写的“很日本”。没有多少指导性的步骤，却如同工匠般和你娓娓道来。全书最大的观点就是：让家长享受育儿的过程。孩子们成长过程是很快的，不要因为他们做不到某些事情就去苛责他们，要用鼓励性语言提供帮助，期待成长过程中的每一次收获。孩子们的成长确实转瞬即逝，我们一味地追求快、一味地攀比仅会带来无限焦虑。如果可以把成长的过程看成一次探险的话，我们收获的却
    

    • 

  • 数据管理知识体系指南（第二版）-第五章——数据建模和设计-学习笔记
键盘上的五花肉
数据治理数据库数据仓库数据治理

    目录5.1引言5.1.1业务驱动因素5.1.2目标和原则5.1.3基本概念5.2活动5.2.1规划数据建模5.2.2建立数据模型5.2.3审核数据模型5.2.4维护数据模型5.3工具5.3.1数据建模工具5.3.2数据血缘工具5.3.3数据分析工具5.3.4元数据资料库5.3.5数据模型模式5.3.6行业数据模型5.4方法5.4.1命名约定的最佳实践5.4.2数据库设计中的最佳实践5.5数据建模和
    

    • 

  • 关于旗正规则引擎下载页面需要弹窗保存到本地目录的问题
何必如此
jsp超链接文件下载窗口

    生成下载页面是需要选择“录入提交页面”，生成之后默认的下载页面<a>标签超链接为：<a href="<%=root_stimage%>stimage/image.jsp?filename=<%=strfile234%>&attachname=<%=java.net.URLEncoder.encode(file234filesourc
    

    • 

  • 【Spark九十八】Standalone Cluster Mode下的资源调度源代码分析
bit1129
cluster

    在分析源代码之前，首先对Standalone Cluster Mode的资源调度有一个基本的认识：
首先，运行一个Application需要Driver进程和一组Executor进程。在Standalone Cluster Mode下，Driver和Executor都是在Master的监护下给Worker发消息创建(Driver进程和Executor进程都需要分配内存和CPU，这就需要Maste
    

    • 

  • linux上独立安装部署spark
daizj
linux安装spark1.4部署

    下面讲一下linux上安装spark，以 Standalone Mode 安装
 
1）首先安装JDK
 
下载JDK：jdk-7u79-linux-x64.tar.gz  ，版本是1.7以上都行，解压 tar -zxvf jdk-7u79-linux-x64.tar.gz  
 
然后配置 ~/.bashrc&nb
    

    • 

  • Java 字节码之解析一
周凡杨
java字节码javap

     
 
一： Java 字节代码的组织形式
 
类文件 {
    OxCAFEBABE ，小版本号，大版本号，常量池大小，常量池数组，访问控制标记，当前类信息，父类信息，实现的接口个数，实现的接口信息数组，域个数，域信息数组，方法个数，方法信息数组，属性个数，属性信息数组
}
&nbs
    

    • 

  • java各种小工具代码
g21121
java

    1.数组转换成List
import java.util.Arrays;
Arrays.asList(Object[] obj); 2.判断一个String型是否有值
import org.springframework.util.StringUtils;
if (StringUtils.hasText(str)) 3.判断一个List是否有值
import org.spring
    

    • 

  • 加快FineReport报表设计的几个心得体会
老A不折腾
finereport

    一、从远程服务器大批量取数进行表样设计时，最好按“列顺序”取一个“空的SQL语句”，这样可提高设计速度。否则每次设计时模板均要从远程读取数据，速度相当慢！！
二、找一个富文本编辑软件（如NOTEPAD+）编辑SQL语句，这样会很好地检查语法。有时候带参数较多检查语法复杂时，结合FineReport中生成的日志，再找一个第三方数据库访问软件（如PL/SQL）进行数据检索，可以很快定位语法错误。

    

    • 

  • mysql linux启动与停止
墙头上一根草

    如何启动/停止/重启MySQL一、启动方式1、使用 service 启动：service mysqld start2、使用 mysqld 脚本启动：/etc/inint.d/mysqld start3、使用 safe_mysqld 启动：safe_mysqld&二、停止1、使用 service 启动：service mysqld stop2、使用 mysqld 脚本启动：/etc/inin
    

    • 

  • Spring中事务管理浅谈
aijuans
spring事务管理

    
Spring中事务管理浅谈
By Tony Jiang@2012-1-20 Spring中对事务的声明式管理
拿一个XML举例
[html] 
view plain
copy
print
?
<?xml version="1.0" encoding="UTF-8"?>&nb
    

    • 

  • php中隐形字符65279（utf-8的BOM头）问题
alxw4616

    php中隐形字符65279（utf-8的BOM头）问题
今天遇到一个问题. php输出JSON 前端在解析时发生问题:parsererror.
 
调试:
1.仔细对比字符串发现字符串拼写正确.怀疑是 非打印字符的问题.
2.逐一将字符串还原为unicode编码. 发现在字符串头的位置出现了一个 65279的非打印字符.
 
     
    

    • 

  • 调用对象是否需要传递对象(初学者一定要注意这个问题)
百合不是茶
对象的传递与调用技巧

     
 
类和对象的简单的复习,在做项目的过程中有时候不知道怎样来调用类创建的对象,简单的几个类可以看清楚,一般在项目中创建十几个类往往就不知道怎么来看
 
为了以后能够看清楚,现在来回顾一下类和对象的创建,对象的调用和传递(前面写过一篇)
 
类和对象的基础概念:
 
JAVA中万事万物都是类 类有字段(属性),方法,嵌套类和嵌套接
    

    • 

  • JDK1.5 AtomicLong实例
bijian1013
javathreadjava多线程AtomicLong

    JDK1.5 AtomicLong实例
类 AtomicLong
可以用原子方式更新的 long 值。有关原子变量属性的描述，请参阅 java.util.concurrent.atomic 包规范。AtomicLong 可用在应用程序中（如以原子方式增加的序列号），并且不能用于替换 Long。但是，此类确实扩展了 Number，允许那些处理基于数字类的工具和实用工具进行统一访问。
 
    

    • 

  • 自定义的RPC的Java实现
bijian1013
javarpc

            网上看到纯java实现的RPC，很不错。
        RPC的全名Remote Process Call，即远程过程调用。使用RPC，可以像使用本地的程序一样使用远程服务器上的程序。下面是一个简单的RPC 调用实例，从中可以看到RPC如何
    

    • 

  • 【RPC框架Hessian一】Hessian RPC Hello World
bit1129
Hello world

    什么是Hessian
The Hessian binary web service protocol makes web services usable without requiring a large framework, and without learning yet another alphabet soup of protocols. Because it is a binary p
    

    • 

  • 【Spark九十五】Spark Shell操作Spark SQL
bit1129
shell

    在Spark Shell上，通过创建HiveContext可以直接进行Hive操作
 
1. 操作Hive中已存在的表
 
[hadoop@hadoop bin]$ ./spark-shell
Spark assembly has been built with Hive, including Datanucleus jars on classpath
Welcom
    

    • 

  • F5　往header加入客户端的ip
ronin47

    when HTTP_RESPONSE {if {[HTTP::is_redirect]}{         HTTP::header replace Location [string map {:port/ /} [HTTP::header value Location]]HTTP::header replace Lo
    

    • 

  • java-61-在数组中，数字减去它右边(注意是右边)的数字得到一个数对之差. 求所有数对之差的最大值。例如在数组{2, 4, 1, 16, 7, 5,
bylijinnan
java

    思路来自：
http://zhedahht.blog.163.com/blog/static/2541117420116135376632/
写了个java版的
public class GreatestLeftRightDiff {
/**
* Q61.在数组中，数字减去它右边(注意是右边)的数字得到一个数对之差。
* 求所有数对之差的最大值。例如在数组
    

    • 

  • mongoDB 索引
开窍的石头
mongoDB索引

    在这一节中我们讲讲在mongo中如何创建索引
      得到当前查询的索引信息
     db.user.find(_id:12).explain();
       cursor: basicCoursor 指的是没有索引
 &
    

    • 

  • [硬件和系统]迎峰度夏
comsci
系统

      从这几天的气温来看，今年夏天的高温天气可能会维持在一个比较长的时间内
   所以，从现在开始准备渡过炎热的夏天。。。。
   每间房屋要有一个落地电风扇，一个空调(空调的功率和房间的面积有密切的关系)
   坐的，躺的地方要有凉垫，床上要有凉席
  
   电脑的机箱
    

    • 

  • 基于ThinkPHP开发的公司官网
cuiyadll
行业系统

    后端基于ThinkPHP，前端基于jQuery和BootstrapCo.MZ 企业系统
轻量级企业网站管理系统
运行环境:PHP5.3+, MySQL5.0
系统预览
系统下载：http://www.tecmz.com
预览地址：http://co.tecmz.com
各种设备自适应
响应式的网站设计能够对用户产生友好度，并且对于
    

    • 

  • Transaction and redelivery in JMS (JMS的事务和失败消息重发机制)
darrenzhu
jms事务承认MQacknowledge

    JMS Message Delivery Reliability and Acknowledgement Patterns
http://wso2.com/library/articles/2013/01/jms-message-delivery-reliability-acknowledgement-patterns/
Transaction and redelivery in 
    

    • 

  • Centos添加硬盘完全教程
dcj3sjt126com
linuxcentoshardware

    Linux的硬盘识别:
sda        表示第1块SCSI硬盘
hda       表示第1块IDE硬盘
scd0      表示第1个USB光驱
一般使用“fdisk -l”命
    

    • 

  • yii2 restful web服务路由
dcj3sjt126com
PHPyii2

    路由
随着资源和控制器类准备，您可以使用URL如 http://localhost/index.php?r=user/create访问资源，类似于你可以用正常的Web应用程序做法。
在实践中，你通常要用美观的URL并采取有优势的HTTP动词。 例如，请求POST /users意味着访问user/create动作。 这可以很容易地通过配置urlManager应用程序组件来完成 如下所示
    

    • 

  • MongoDB查询(4)——游标和分页[八]
eksliang
mongodbMongoDB游标MongoDB深分页

    转载请出自出处：http://eksliang.iteye.com/blog/2177567 一、游标
        数据库使用游标返回find的执行结果。客户端对游标的实现通常能够对最终结果进行有效控制，从shell中定义一个游标非常简单，就是将查询结果分配给一个变量（用var声明的变量就是局部变量），便创建了一个游标，如下所示：
> var 
    

    • 

  • Activity的四种启动模式和onNewIntent()
gundumw100
android

    Android中Activity启动模式详解
　　在Android中每个界面都是一个Activity，切换界面操作其实是多个不同Activity之间的实例化操作。在Android中Activity的启动模式决定了Activity的启动运行方式。
　　Android总Activity的启动模式分为四种：
Activity启动模式设置：
<acti
    

    • 

  • 攻城狮送女友的CSS3生日蛋糕
ini
htmlWebhtml5csscss3

    在线预览：http://keleyi.com/keleyi/phtml/html5/29.htm
 
代码如下：
 
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>攻城狮送女友的CSS3生日蛋糕-柯乐义<
    

    • 

  • 读源码学Servlet（1）GenericServlet 源码分析
jzinfo
tomcatWebservlet网络应用网络协议

    Servlet API的核心就是javax.servlet.Servlet接口，所有的Servlet 类（抽象的或者自己写的）都必须实现这个接口。在Servlet接口中定义了5个方法，其中有3个方法是由Servlet 容器在Servlet的生命周期的不同阶段来调用的特定方法。
 
 
先看javax.servlet.servlet接口源码： 
package 
    

    • 

  • JAVA进阶：VO(DTO)与PO(DAO)之间的转换
snoopy7713
javaVOHibernatepo

     
PO即 Persistence Object　　VO即 Value Object
　VO和PO的主要区别在于：　　VO是独立的Java Object。　　PO是由Hibernate纳入其实体容器（Entity Map）的对象，它代表了与数据库中某条记录对应的Hibernate实体，PO的变化在事务提交时将反应到实际数据库中。
　实际上，这个VO被用作Data Transfer 
    

    • 

  • mongodb group by date 聚合查询日期 统计每天数据（信息量）
qiaolevip
每天进步一点点学习永无止境mongodb纵观千象

    /* 1 */
{
"_id" : ObjectId("557ac1e2153c43c320393d9d"),
"msgType" : "text",
"sendTime" : ISODate("2015-06-12T11:26:26.000Z")
    

    • 

  • java之18天 常用的类(一)
Luob.
MathDateSystemRuntimeRundom

    System类
import java.util.Properties;
/**
* System:
* out:标准输出,默认是控制台
* in:标准输入,默认是键盘
*
* 描述系统的一些信息
* 获取系统的属性信息:Properties getProperties();
*
*
*
*/
public class Sy
    

    • 

  • maven
wuai
maven

    1、安装maven：解压缩、添加M2_HOME、添加环境变量path
2、创建maven_home文件夹，创建项目mvn_ch01,在其下面建立src、pom.xml，在src下面简历main、test、main下面建立java文件夹
3、编写类，在java文件夹下面依照类的包逐层创建文件夹，将此类放入最后一级文件夹
4、进入mvn_ch01
4.1、mvn compile ,执行后会在
    

    •