定时任务下的多线程任务

1、Spring的ServletContextListenerServletContext > webApplicationContext ServletContext 是java中的Servlet工程的上下文对象 webApplicationContext是Spring框架中定义的继承了ServletContext上下文对象的web上下文对象Spring框架定义了一个ContextLoaderListener继承了ServletContextListener,在监听整个Spring的IOC容器(通过DI将创建对象的工作交给Spring框架)的创建与销毁。2、在ServletContextListener中监听上下文初始化的事件

public void contextInitialized(ServletContextEvent arg0) {

}
在Servlet容器初始化完成后，开启一个定时任务。3、使用Java中的定时器Timer(true:后台线程跑)

Timer timer = new Timer(true);

timer.schedule(new AlarmTask(),5*1000,10*1000);

4、自定义TimerTask类

public class AlarmTask extends TimerTask {

@Override

public void run() {}

}

TimerTask源码：实现了多线程

package java.util;

public abstract class TimerTask implements Runnable {

protected TimerTask() {

throw new RuntimeException("Stub!");

}

public boolean cancel() {

throw new RuntimeException("Stub!");

}

public long scheduledExecutionTime() {

throw new RuntimeException("Stub!");

}

public abstract void run();

}

5、在自定义Task类里面使用AtomicBoolean实现定时任务的原子性

boolean compareAndSet(expectedValue, updateValue);

我们看到了上面提到的一个在java并发中非常重要的一类算法 -- CAS: Compare And Set 比较并设置； 什么意思呢，我们以 

boolean compareAndSet(expectedValue, updateValue);

方法为例来解释CAS的思想， 内存中可见的值如果和期望值(expectedValue)一致， 则将内存中的值修改为新值(updateValue)，并且返回true； 否则返回false；该操作是原子性的，意思是线程安全的。当多个线程同时访问某个对象时，如果其中一个线程通过CAS操作获得了访问权限，则其他线程只能在该线程处理完之后才能访问。这类似于同步字 synchronized 但是效率更高因为并没有锁的机制demo代码：

/**

*

*/

package byron4j.dlzd.curr.atomic;

import java.time.LocalDate;

import java.time.LocalTime;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicBoolean;

public class AtomicDemo {

private static volatile AtomicBoolean canExecutingFlag = new AtomicBoolean(true);

/**

*

* 业务逻辑处理:

* <ol>

*   <li>Step 1</li>

*   <li>Step 2</li>

* </ol>

*/

public void executeBusiLogic(){

if( canExecutingFlag.compareAndSet(true, false) ){

try{

System.out.println(LocalDate.now() + " " + LocalTime.now() + "--" + Thread.currentThread().getName() + "--处理业务逻辑开始...");

Thread.sleep(5000);

System.out.println(LocalDate.now() + " " + LocalTime.now() + "--" + Thread.currentThread().getName() + "--处理业务逻辑完毕.");

}catch(Exception e){

System.out.println(LocalDate.now() + " " + LocalTime.now() + "--" + Thread.currentThread().getName() + "--处理业务逻辑失败!!!");

}finally{

canExecutingFlag.set(true);

}

}else{

System.out.println(LocalDate.now() + " " + LocalTime.now() + "--" + Thread.currentThread().getName() + "--已经存在处理中的业务，请稍后再试!");

}

}

public static void main(String[] args) {

ExecutorService es = Executors.newFixedThreadPool(10);

AtomicDemo demo = new AtomicDemo();

for(int i = 0; i < 10; i++){

es.execute(new Runnable() {

@Override

public void run() {

demo.executeBusiLogic();

}

});

}

es.shutdown();

}

}

运行结果如下：

2017-09-13 22:13:45.081--pool-1-thread-3--已经存在处理中的业务，请稍后再试!

2017-09-13 22:13:45.082--pool-1-thread-2--已经存在处理中的业务，请稍后再试!

2017-09-13 22:13:45.082--pool-1-thread-6--已经存在处理中的业务，请稍后再试!

2017-09-13 22:13:45.081--pool-1-thread-1--处理业务逻辑开始...

2017-09-13 22:13:45.081--pool-1-thread-10--已经存在处理中的业务，请稍后再试!

2017-09-13 22:13:45.081--pool-1-thread-9--已经存在处理中的业务，请稍后再试!

2017-09-13 22:13:45.082--pool-1-thread-4--已经存在处理中的业务，请稍后再试!

2017-09-13 22:13:45.081--pool-1-thread-7--已经存在处理中的业务，请稍后再试!

2017-09-13 22:13:45.082--pool-1-thread-5--已经存在处理中的业务，请稍后再试!

2017-09-13 22:13:45.083--pool-1-thread-8--已经存在处理中的业务，请稍后再试!

2017-09-13 22:13:50.082--pool-1-thread-1--处理业务逻辑完毕.

我们看到thread-1首先获得操作权限canExecutingFlag 值为true，CAS验证通过并且将canExecutingFlag 值置为false，所以其他线程均未获得进入资格，因为处理业务逻辑花了5秒钟，其他线程得到了"已经在处理中"的提示。 为了模拟耗时操作，我们在 executeBusiLogic 方法中通过sleep使执行线程睡眠。6、通过Queue实现多线程队列执行并结合CountDownLatch计数器实现业务场景：在定时任务中我们需要创建对个线程，同时进行上报告警的操作，但是又需要保证当前的多线程报警操作在当前定时任务主线程内。也就是说：多线程的报警需要在一次定时任务内执行完毕后，再执行下一次定时任务。6.1 创建多线程队列：

ConcurrentLinkedQueue<Runnable> tasksQueue = new ConcurrentLinkedQueue<>();

6.2 创建计数器（构造方法中声明计数器大小）

CountDownLatch cdl = new CountDownLatch(tasksQueue.size());

6.3 获取线程并实现计数

public static void main(String args[]) {

while(true) {

Runnable task = tasksQueue.poll();//弹出队列中第一个

while(task == null) {

break;

}

new Thread(task).start();

cdl.countDown();

}

cdl.await();

}

主线程必须在启动其他线程后立即调用await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。
第五部分摘抄自：作者：东陆之滇
链接：https://www.jianshu.com/p/eabecdbc6bd9关于CountDownLatch的更多详细了解：https://www.cnblogs.com/catkins/p/6021992.html