使用執行緒執行框架的一次經歷

效果：這種方案導致的現象是接收到的訊息會迅速堆積，我們從訊息佇列（或者其他地方）取出了大量訊息，但是處理執行緒的速度又跟不上，所以導致的問題是大量的Task會堆積線上程池底層維護的一個阻塞佇列中，這會極大的耗費儲存空間，影響系統的效能。

分析：當execute()一個任務的時候，如果有空閒的worker執行緒，那麼投入執行，否則看設定的最大執行緒個數，沒有達到執行緒個數限制就建立新執行緒，接新任務，否則就把任務緩衝到一個阻塞佇列中，問題就是這個佇列，預設的大小是沒有限制的，所以就會大量的堆積任務，必然耗費heap空間。

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE); // capacity
    }

計數限制

面對上述問題，想到了要限制訊息接收的速度，自然就想到了各種執行緒同步的原語，不過在這裡最簡單的就是使用一個Volatile的計數器。

訊息接收者：

public class Receiver {
    private static volatile boolean inited = false;
    private static volatile boolean shutdown = false;
    private static volatile int cnt = 0;
    private MessageHandler messageHandler;
    public void start(){
        Executors.newSingleThreadExecutor().execute(new Runnable() {
            @Override
            public void run() {
                while(!shutdown){
                    init();
                    recv();
                }
            }
        });
    }

    /**
     * 模擬訊息接收
     */
    public void recv(){
            Message msg = new Message("Msg" + System.currentTimeMillis());
            System.out.println(String.format("接收到訊息(%d): %s", ++cnt, msg));
            messageHandler.handle(msg);
    }

    public void init(){
        if(!inited){
            messageHandler = new MessageHandler();
            inited = true;
        }
    }

    public static void main(String[] args) {
        new Receiver().start();
    }
}

訊息處理：

public class MessageHandler {
    private static final int THREAD_POOL_SIZE = 1;
    private ExecutorService service = Executors.newFixedThreadPool(THREAD_POOL_SIZE);

    public void handle(Message msg){
        try {
            service.execute(new Runnable() {

                @Override
                public void run() {
                    parseMsg(msg);
                }
            });
        } catch (Throwable e) {
            System.out.println("訊息處理異常" + e);
        }
    }

    /**
     * 比較耗時的訊息處理流程
     */
    public void parseMsg(Message message){
        try {
            Thread.sleep(10000);
            System.out.println("解析訊息：" + message);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            Receiver.limit --;
        }

    }
}

public class MessageHandler {
    private static final int THREAD_POOL_SIZE = 4;

    ThreadPoolExecutor service = new ThreadPoolExecutor(THREAD_POOL_SIZE, THREAD_POOL_SIZE, 0L, TimeUnit.MILLISECONDS,
            new SynchronousQueue<Runnable>(), new RejectedExecutionHandler() {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            System.out.println("自定義拒絕策略");
            try {
                executor.getQueue().put(r);
                System.out.println("重新放任務回佇列");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });

    public void handle(Message msg) {
        try {
            System.out.println(service.getTaskCount());
            System.out.println(service.getQueue().size());
            System.out.println(service.getCompletedTaskCount());
            service.execute(new Runnable() {
                @Override
                public void run() {
                    parseMsg(msg);
                }
            });
        } catch (Throwable e) {
            System.out.println("訊息處理異常" + e);
        }
    }

    /**
     * 比較耗時的訊息處理流程
     */
    public void parseMsg(Message message) {
        while (true) {
            try {
                System.out.println("執行緒名:" + Thread.currentThread().getName());
                System.out.println("解析訊息：" + message);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class MessageHandler {
    private static final int THREAD_POOL_SIZE = 4;
    private static final int BLOCK_QUEUE_CAP = 500;
    ThreadPoolExecutor service = new ThreadPoolExecutor(THREAD_POOL_SIZE, THREAD_POOL_SIZE, 0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>(BLOCK_QUEUE_CAP), new SimpleThreadFactory(), new RejectedExecutionHandler() {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            System.out.println("自定義拒絕策略");
            try {
                executor.getQueue().put(r);
                System.out.println("重新放任務回佇列");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });

    public void handle(Message msg) {
        try {
            service.execute(new Runnable() {
                @Override
                public void run() {
                    parseMsg(msg);
                }
            });
        } catch (Throwable e) {
            System.out.println("訊息處理異常" + e);
        }
    }

    /**
     * 比較耗時的訊息處理流程
     */
    public void parseMsg(Message message) {
        try {
            Thread.sleep(5000);
            System.out.println("執行緒名:" + Thread.currentThread().getName());
            System.out.println("解析訊息：" + message);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static class SimpleThreadFactory implements ThreadFactory {

        @Override
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r);
            thread.setName("Thread-" + System.currentTimeMillis());
            return thread;
        }
    }
}