使用BlockingQueue

最近公司里有个同事，发现自己写的接口中返回数据很慢，最后排查后发现，有一个写日志的操作很费时间。

由于接口的返回和写日志操作没有耦合，因此可以在完成接口的操作处理后，新启一个线程去写日志，然后返回结果即可，从而可以降低接口返回数据的延时。

使用BlockingQueue作为中间件，生产者线程（service层）将不需要返回结果值的任务直接放在BlockingQueue中，然后消费者线程不断从BlockingQueue获取任务并执行。

代码示例如下：

首先是ConsumeTask类，是一个Runnable，不断从BlockingQueue中获取任务并处理

package com.xsy.MultiThread;

import java.util.concurrent.BlockingQueue;


public class ConsumeTask implements Runnable{


    private BlockingQueue<String> queue;

    public ConsumeTask(BlockingQueue<String> queue){
        this.queue=queue;
    }


    public void run() {
        String name=Thread.currentThread().getName();
        System.out.println(name+"线程已经开启");
        while(true){
            String o= null;
            try {
                o = queue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(o!=null){
                //这里只是一个示例，可以在这里做耗时操作
                System.out.println(name+"线程操作的结果"+o);
            }
        }
    }
}

 Consume类，用线程池的方式去开启消费者线程

package com.xsy.MultiThread;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;

public class Consume {

    private ExecutorService service;
    private int nThread;
    private BlockingQueue<String> queue;

    public Consume(ExecutorService service, int nThread, BlockingQueue<String> queue){
        this.nThread=nThread;
        this.service=service;
        this.queue=queue;
    }

    public void execute(){
        for(int i=0;i<nThread;i++){
            ConsumeTask task=new ConsumeTask(queue);
            service.execute(task);
        }
    }

}

ProduceTask类，作为一个生产者线程的示例。这里从控制台读取数据作为生产出来的数据。

package com.xsy.MultiThread;

import java.io.InputStream;
import java.util.Scanner;
import java.util.concurrent.BlockingQueue;

public class ProduceTask implements Runnable{

    private BlockingQueue<String> queue;
    private Scanner scan;

    public ProduceTask(BlockingQueue<String> queue, InputStream in) {
        this.queue = queue;
        scan=new Scanner(in);
    }

    public void run() {
        while(true){
            String line=scan.nextLine();
            String[]lines=line.split(",");
            for(String var:lines){
                try {
                    queue.put(var);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

最后使用Test类作为测试

package com.xsy.MultiThread;

import java.util.concurrent.*;

public class Test {

    public static void main(String[]args){
        ExecutorService service = Executors.newFixedThreadPool(6);
        BlockingQueue<String> queue=new LinkedBlockingQueue<String>(100);
        Consume consume=new Consume(service,5,queue);
        consume.execute();
        ProduceTask task=new ProduceTask(queue,System.in);
        service.execute(task);
    }
}

效果如下所示：

pool-1-thread-1线程已经开启
pool-1-thread-2线程已经开启
pool-1-thread-4线程已经开启
pool-1-thread-3线程已经开启
pool-1-thread-5线程已经开启
dsa,3r,dsf,435354,fdsaf,435rfda,fds,3ds3e,fdsf,3ed,grg,yu,768,j,ds,asd,21,3rewf,uyht,ujyh,54er,was,fds
pool-1-thread-1线程操作的结果dsa
pool-1-thread-1线程操作的结果dsf
pool-1-thread-1线程操作的结果435354
pool-1-thread-1线程操作的结果fdsaf
pool-1-thread-1线程操作的结果435rfda
pool-1-thread-1线程操作的结果fds
pool-1-thread-1线程操作的结果3ds3e
pool-1-thread-2线程操作的结果3r
pool-1-thread-2线程操作的结果grg
pool-1-thread-2线程操作的结果yu
pool-1-thread-2线程操作的结果768
pool-1-thread-2线程操作的结果j
pool-1-thread-2线程操作的结果ds
pool-1-thread-2线程操作的结果asd
pool-1-thread-2线程操作的结果21
pool-1-thread-3线程操作的结果3rewf
pool-1-thread-3线程操作的结果ujyh
pool-1-thread-3线程操作的结果54er
pool-1-thread-3线程操作的结果was
pool-1-thread-3线程操作的结果fds
pool-1-thread-4线程操作的结果3ed
pool-1-thread-1线程操作的结果fdsf
pool-1-thread-2线程操作的结果uyht

这里只是一个示例，可以通过修改并扩展功能使得其更加完善！