Question

在我的应用程序中，我有一个接收器，它应该处理具有许多线程的消息。发送器模块将消息放在堆栈上，接收器模块从该堆栈中取出它。一切都适用于两个线程（一个用于发送，一个用于接收）。现在我想接收包含许多线程的消息。

消息有某种组号。我需要在一个线程中处理一组消息（将有比线程更多的消息组）。我怎么处理这个？

我想做这样的事情：

public class ReceiverExample {
    @Autowired
    Receiver receiver; 

    @Autowired 
    TaskExecutor executor;

    public void receive(){
        Msg msg = receiver.receive(); 
        int index = msg.getIndex();

        executor.execute(
                //put index ? ,
                msg
        );
    }
}

我正在使用Spring Framework。我知道我必须使用某种执行器，但我找不到任何显示我的问题的好例子。

Answer 1

因此，您需要确保具有相同“消息组ID”的两个Runnable永远不会并行运行。

“executor”接口没有“messageGroupId”的概念，所以你可能需要编写另一个类来协调这个（不确定第三方库中是否存在这样的东西，也许有人可以发布一个建议??）

下面的类为每个线程维护一个队列，并确保具有相同消息组ID的任务始终位于同一队列中。为每个队列创建一个单独的线程来处理任务......（这不是完美的，但它可能是一个很好的起点）

package stack;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MessageGroupTaskExecutor {

    private static final Logger LOG = LoggerFactory.getLogger(MessageGroupTaskExecutor.class);
    private static final long POLL_TIME = 10;

    private BlockingQueue<Runnable>[] queues;
    private Thread[] workerThreads;
    private volatile boolean stopped;
    private ThreadFactory threadFactory;

    public MessageGroupTaskExecutor(int numberOfThreads, ThreadFactory threadFactory) {
        this.threadFactory = threadFactory;
        this.queues = new BlockingQueue[numberOfThreads];
        this.workerThreads = new Thread[numberOfThreads];
    }

    public void init() {
        for (int k = 0; k < workerThreads.length; k++) {
            queues[k] = new LinkedBlockingQueue<Runnable>();
            workerThreads[k] = threadFactory.newThread(new WorkerThread(queues[k]));
            workerThreads[k].start();
        }
    }

    /**
     * Not a great impl - no way to "shutdown after all tasks finished" (at the moment...)
     */
    public void shutdown() {
        stopped = true;
        for (Thread thread : workerThreads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                LOG.warn("Interrupted waiting for thread to finish", e);
            }
        }
    }

    public void execute(int messageGroup, Runnable command) {
        queues[messageGroup % queues.length].add(command);
        LOG.debug("Submitted {} for message group {}", command, messageGroup);
    }

    private class WorkerThread implements Runnable {

        private BlockingQueue<Runnable> queue;

        public WorkerThread(BlockingQueue<Runnable> queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            while (!stopped) {
                Runnable nextJob = null;
                try {
                    nextJob = queue.poll(POLL_TIME, TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    LOG.debug("Interrupted when polling queue", e);
                }

                if (nextJob != null) {
                    try {
                        LOG.debug("Got job " + nextJob);
                        nextJob.run();
                        LOG.debug("Completed " + nextJob);
                    } catch (Exception ex) {
                        LOG.debug("Exception thrown by " + nextJob, ex);
                    }
                }
            }
        }
    }
}

如您所见，当通过execute方法提交作业时，消息组ID用于选择将作业放入哪个队列。

工作线程将处理这些队列。

这是一个使用它的基础类...

package stack;

import java.util.concurrent.Executors;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class TestIt {
    private static final Logger LOG = LoggerFactory.getLogger(TestIt.class);

    public static void main(String[] args) {
        MessageGroupTaskExecutor exe = new MessageGroupTaskExecutor(5, Executors.defaultThreadFactory());

        exe.init();

        for (int k = 0; k < 100; k++) {
            int messageGroup = (int) (Math.random() * 15.0);
            exe.execute(messageGroup, new MyTask(messageGroup, k));
        }
    }

    private static class MyTask implements Runnable {
        private int mg;
        private int taskNumber;

        public MyTask(int mg, int taskNumber) {
            this.mg = mg;
            this.taskNumber = taskNumber;
        }

        @Override
        public void run() {
            LOG.info("Doing task {} for message group {}", taskNumber, mg);
            try {
                Thread.sleep((long) (Math.random() * 500));
            } catch (InterruptedException e) {
            }
            LOG.info("Done task {} for message group {}", taskNumber, mg);
        }

    }
}

希望这有帮助

Spring Executors - 在具有特定索引的线程中执行方法

1 个答案: