0

我的情况与此问题中描述的情况类似：

Java 电子邮件发送队列 - 固定数量的线程发送尽可能多的可用消息

在那里我有一个阻塞队列，它接收命令（ICommandTask 扩展 Callable{Object}），线程池从中起飞并运行。阻塞队列在调用线程和执行线程之间提供线程同步和隔离。整个程序中的不同对象可以将 ICommandTasks 提交到命令队列，这就是我将 AddTask() 设为静态的原因。

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import com.mypackage.tasks.ICommandTask;


public enum CommandQueue
{
    INSTANCE;

    private final BlockingQueue<ICommandTask> commandQueue;
    private final ExecutorService executor;

    private CommandQueue()
    {
        commandQueue = new LinkedBlockingQueue<ICommandTask>();
        executor = Executors.newCachedThreadPool();
    }

    public static void start()
    {
        new Thread(INSTANCE.new WaitForProducers()).start();
    }

    public static void addTask(ICommandTask command)
    {
        INSTANCE.commandQueue.add(command);
    }

    private class WaitForProducers implements Runnable
    {

        @Override
        public void run()
        {
            ICommandTask command;

            while(true)
            {
                try
                {
                    command = INSTANCE.commandQueue.take();
                    executor.submit(task);

                }
                catch (InterruptedException e)
                {
                    // logging etc.
                }
            }   
        }
    }
}

在启动期间的主程序中，使用以下命令启动命令队列，该命令创建一个新的命令队列对象并在单独的线程中启动 WaitForProducers。

CommandQueue.Start();

我想问这种方法是否使用单例枚举将多个生产者设置为单个执行器（以便程序的不同部分可以访问），并且使用单独的线程从队列中取出任务并提交到 ThreadPool是做我想要实现的目标的推荐方式。特别是在非常多线程的环境中。

到目前为止，它似乎工作正常，但我计划创建与 CommandQueue 类似的对象来处理不同类型的任务。它们将存储在自己的队列中。例如 OrderQueue、EventQueue、NegotiationQueue 等。因此它需要具有一定的可扩展性和线程安全性。

提前致谢。

4

0 回答 0