用java代码实现 hazelcast 队列，要求有3个生产者event,notification,config,分别使用3个消息队列 event queue,notification queue,config queue，分别由3个接收者event receiver, notification receiver,config receiver接收，接收后通过同一个线程分配各自的消费者，分别由3个消费者 event processor, notification processor,config processor进行处理，其中notification processor进行邮件的发送，config processor进行缓存的刷新，event processor有3种不同的处理，分别是存储到mysql数据库，单独发送邮件和批量发送邮件

以下是使用Java代码实现Hazelcast队列的示例代码：

import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.core.IQueue;

public class HazelcastQueueExample {

    public static void main(String[] args) throws InterruptedException {
        HazelcastInstance hazelcastInstance = Hazelcast.newHazelcastInstance();
        
        // 创建3个消息队列
        IQueue<String> eventQueue = hazelcastInstance.getQueue("event-queue");
        IQueue<String> notificationQueue = hazelcastInstance.getQueue("notification-queue");
        IQueue<String> configQueue = hazelcastInstance.getQueue("config-queue");
        
        // 创建3个接收者并分配消费者
        Thread eventReceiver = new Thread(new Receiver(eventQueue, new EventProcessor()));
        Thread notificationReceiver = new Thread(new Receiver(notificationQueue, new NotificationProcessor()));
        Thread configReceiver = new Thread(new Receiver(configQueue, new ConfigProcessor()));
        
        // 启动接收者线程
        eventReceiver.start();
        notificationReceiver.start();
        configReceiver.start();
        
        // 生产者向队列中添加消息
        eventQueue.add("event message");
        notificationQueue.add("notification message");
        configQueue.add("config message");
        
        hazelcastInstance.shutdown();
    }
}

class Receiver implements Runnable {
    private IQueue<String> queue;
    private Processor processor;

    public Receiver(IQueue<String> queue, Processor processor) {
        this.queue = queue;
        this.processor = processor;
    }

    @Override
    public void run() {
        while (true) {
            try {
                String message = queue.take();
                Thread thread = new Thread(() -> processor.process(message));
                thread.start();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

interface Processor {
    void process(String message);
}

class EventProcessor implements Processor {
    @Override
    public void process(String message) {
        // 存储到mysql数据库
        System.out.println("store to mysql: " + message);
        
        // 单独发送邮件
        System.out.println("send email: " + message);
        
        // 批量发送邮件
        System.out.println("batch email: " + message);
    }
}

class NotificationProcessor implements Processor {
    @Override
    public void process(String message) {
        // 发送邮件
        System.out.println("send email: " + message);
    }
}

class ConfigProcessor implements Processor {
    @Override
    public void process(String message) {
        // 刷新缓存
        System.out.println("refresh cache: " + message);
    }
}

在示例代码中，我使用了Hazelcast的队列实现了一个消息队列系统。其中，生产者向3个消息队列中分别添加消息，每个消息队列都有一个接收者线程，接收到消息后通过同一个线程分配各自的消费者进行处理。其中，notification processor进行邮件的发送，config processor进行缓存的刷新，event processor有3种不同的处理，分别是存储到mysql数据库，单独发送邮件和批量发送邮件。