java连接RabbitMQ--工作队列-02

java连接RabbitMQ--简单队列-01https://blog.csdn.net/kxj19980524/article/details/88991013

work queues 工作队列

为什么会出现工作队列

simple队列是一 一对应的,而且我们实际开发,生产者消息是毫不费力的,而消费者一般是要跟业务相结合的,消费者接收到消息之后就需要处理,可能要花费时间,这时候队列就会积压了很多消息.

生产者--Round-robin （轮询分发）

package com.buba.work;

import com.buba.utils.ConnectionUtils;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Send {
    private static final String QUEUE_NAME="test_work_queue";
    public static void main(String[] args)throws Exception {
        //获取连接
        Connection connection = ConnectionUtils.getConnection();
        //获取通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        for(int i=0;i<50;i++){
            String msg = "hello "+i;
            System.out.println(msg);
            channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
            Thread.sleep(i*20);
        }
        channel.close();
        connection.close();
    }
}

下面是消费者1和消费者2,代码相同,只是里面睡眠时间一个长一个短 

package com.buba.work;

import com.buba.utils.ConnectionUtils;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Recv1 {
    private static final String QUEUE_NAME="test_work_queue";
    public static void main(String[] args)throws Exception {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String str = new String(body,"utf-8");
                System.out.println("[1]:"+str);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[1] done");
                }
            }
        };
        channel.basicConsume(QUEUE_NAME,true,consumer);


    }
}

package com.buba.work;

import com.buba.utils.ConnectionUtils;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Recv2 {
    private static final String QUEUE_NAME="test_work_queue";
    public static void main(String[] args)throws Exception {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String str = new String(body,"utf-8");
                System.out.println("[2]:"+str);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[2] done");
                }
            }
        };
        channel.basicConsume(QUEUE_NAME,true,consumer);


    }
}

测试结果每个消费者都消费了25个,一个基数一个偶数,结果就是不管谁忙或清闲，都不会给谁多一个任务或少一个任务，任务总是你一个我一个的分,这种方式叫做 轮询分发,虽然减少了一些压力,但是不够完美.而我们想要的结果是根据空闲时间来分发任务. 

生产者  Fair dispatch（公平分发）

package com.buba.workfair;

import com.buba.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Send {
    private static final String QUEUE_NAME="test_work_queue";
    public static void main(String[] args)throws Exception {
        //获取连接
        Connection connection = ConnectionUtils.getConnection();
        //获取通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        /**
         *         每个消费者发送确认消息之前,消息队列不发送下一个消息到消费者,一次只处理一个消息
         *         限制发送给同一个消费者不得超过一条消息.
         */
        channel.basicQos(1);


        for(int i=0;i<50;i++){
            String msg = "hello "+i;
            System.out.println(msg);
            channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
            Thread.sleep(i*20);
        }
        channel.close();
        connection.close();
    }
}

消费者1和2改的地方相同 

package com.buba.workfair;

import com.buba.utils.ConnectionUtils;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Recv1 {
    private static final String QUEUE_NAME="test_work_queue";
    public static void main(String[] args)throws Exception {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //保证一次只发一个
       channel.basicQos(1);



        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String str = new String(body,"utf-8");
                System.out.println("[1]:"+str);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[1] done");
                    //给消息队列反馈一个消息,表示执行完成了可以发送下一条了
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };

        boolean autoAck=false;//自动应答是true,手动应答为false
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);


    }
}

测试完后,明显一边处理的消息多一边处理的消息少.