java阻塞队列思考

生产者

public class FaceProv implements Runnable{
    BlockingQueue<FaceProv> queue;
    String img, path;
    public String getImg() {
        return img;
    }
    public String getPath() {
        return path;
    }
    public FaceProv(String img,String path,BlockingQueue<FaceProv> queue) {
        this.img=img;
        this.path=path;
        this.queue=queue;
    }
    @Override
    public void run() {
        try {
            queue.put(this);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

带返回值的消费者

public class FaceCus implements Callable<String>{
    BlockingQueue<FaceProv> queue;
    public FaceCus(BlockingQueue<FaceProv> queue) {
        this.queue=queue;
    }
    
    @Override
    public String call() throws Exception {
        FaceProv pro=queue.take();
        System.out.println(pro.getImg());
        System.out.println(pro.getPath());
        Face face=new Face();
        String result=face.detectOne(pro.getImg(), pro.getPath());
        return result;
    }
    
}
单一消费者；线程池执行，但是没有阻塞队列好

public class FaceCall implements Callable<String>{
    String img, path;
    public FaceCall(String img,String path) {
        this.img=img;
        this.path=path;
    }
    /* 
     *我感觉是可以的，但是9-28不行
     * @Autowired//好像要扫描
     Face face;*/
     
/*    这种方式需要上下
 *  public void setFace(Face face) {
        this.face = face;
    }*/
     
    @Override
    public String call() throws Exception {
        Face face=new Face();
        System.out.println(img);
        System.out.println(path);
        String result=face.detectOne(img, path);
        return result;
    }
}
不需要的队列类

public class FaceQue {
//    BlockingQueue<Object> blockQue =new LinkedBlockingQueue<Object>(2);
    private BlockingQueue<Object> blockQue;
    public FaceQue(BlockingQueue<Object> block) {
        blockQue=block;
    }
    
    public void put(Object e){
        try {
            blockQue.put(e);
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
    }
    
    public Object getObj(){
        Object object=null;
        try {
            object = blockQue.take();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return object;
    }
}
调用

static BlockingQueue<FaceProv> queue=new LinkedBlockingQueue<>(4);

执行器执行，接收返回值

感觉是阻塞队列可以处理多个问题，比线程池好，不会丢失任务