Java 多线程警告不阻塞，单线程处理警告实现

import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 此类提供的锁机制如下：
 * 多个线程可以发送警告事件，如果警告已经被触发，则直接忽略，不做等待。
 * 守候线程在没有接到警告事件时，一直处于阻塞状态，在被触发以后，执行业务逻辑，直到业务逻辑执行完毕，
 * 才会恢复触发器状态，以便能让触发线程可以再一次的发送触发事件。
 *
 *
 */
public class ProcessLock {

    /**
     * 标识告警是否已经被触发
     */
    private AtomicBoolean isNotify = new AtomicBoolean(false);
    
    /**
     * 实现线程间的同步，利用公平锁的功能，防止守候线程一直不能获取到执行时间
     */
    private ReentrantLock processLock = new ReentrantLock(true);
    
    /**
     * 实现线程阻塞
     */
    private Condition condition = processLock.newCondition();
    
    /**
     * 发送警告信号
     * @return
     */
    public boolean sendSignal(){
        //如果已经被触发，则直接忽略
        final AtomicBoolean isNotify = this.isNotify;
        if(isNotify.get()==true){
            return false;
        }
        final ReentrantLock putLock = this.processLock;
        putLock.lock();
        try {
            if(isNotify.get()==false){
                isNotify.getAndSet(true);
                this.condition.signal();
            }
        } finally {
            putLock.unlock();
        }
        return true;
    }
    
    /**
     * 接到告警后，进行业务处理
     * @throws InterruptedException
     */
    public void process(ProcessCall process) throws InterruptedException{
        while(true){
            final AtomicBoolean isNotify = this.isNotify;
            final ReentrantLock takeLock = this.processLock;
            takeLock.lock();
            try{
                //如果没有发送信号，则让线程一直处于等待状态
                while(isNotify.get()==false){
                    condition.await();
                }
                //在重置标志位之前，处理业务逻辑，业务逻辑处理完成后，恢复标志位
                try {
                    process.process();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                //将提醒信号重置为可以发送信号，此处为单线程逻辑处理，经过修改以后，也可以进行多线程处理
                isNotify.getAndSet(false);
            }finally{
                takeLock.unlock();
            }
        }
    }
    
    /**
     * 启动告警处理线程，选用
     */
    public void startDeamon(final ProcessCall process){
        //初始化以后，立马启动守护进行
        new Thread(new Runnable() {
            public void run() {
                try {
                    process(process);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
    
    /**
     * 用于业务处理的接口回调
     * @author ZhuXinZe
     *
     */
    public interface ProcessCall{
        
        /**
         * 业务处理的实际类
         * @throws Exception
         */
        public void process() throws Exception;
    }
}