在线程之间传递一组对象

Question

我正在从事的当前项目要求我实现一种方法，以将一组对象从一个连续运行的线程有效地传递到主线程。 当前设置类似于以下内容。

我有一个创建新线程的主线程。 这个新线程连续运行并调用基于计时器的方法。 此方法从在线来源获取一组消息，并将它们组织在TreeSet中。

然后需要将此TreeSet传递回主线程，以便可以独立于重复计时器来处理其中包含的消息。

为了更好地参考，我的代码如下所示

// Called by the main thread on start.  
void StartProcesses()
{
    if(this.IsWindowing)
    {
        return;
    }

    this._windowTimer = Executors.newSingleThreadScheduledExecutor();

    Runnable task = new Runnable() {
        public void run() {
            WindowCallback();
        }
    };

    this.CancellationToken = false; 
    _windowTimer.scheduleAtFixedRate(task,
            0, this.SQSWindow, TimeUnit.MILLISECONDS);

    this.IsWindowing = true;
}

/////////////////////////////////////////////////////////////////////////////////

private void WindowCallback()
{
    ArrayList<Message> messages = new ArrayList<Message>();

    //TODO create Monitor
    if((!CancellationToken))
    {
        try
        {
            //TODO fix epochWindowTime
            long epochWindowTime = 0;
            int numberOfMessages = 0;
            Map<String, String> attributes;

            // Setup the SQS client
            AmazonSQS client = new AmazonSQSClient(new 
                    ClasspathPropertiesFileCredentialsProvider());

            client.setEndpoint(this.AWSSQSServiceUrl);

            // get the NumberOfMessages to optimize how to 
            // Receive all of the messages from the queue

            GetQueueAttributesRequest attributesRequest = 
                    new GetQueueAttributesRequest();
            attributesRequest.setQueueUrl(this.QueueUrl);
            attributesRequest.withAttributeNames(
                    "ApproximateNumberOfMessages");
            attributes = client.getQueueAttributes(attributesRequest).
                    getAttributes();

            numberOfMessages = Integer.valueOf(attributes.get(
                    "ApproximateNumberOfMessages")).intValue();

            // determine if we need to Receive messages from the Queue
            if (numberOfMessages > 0)
            {

                if (numberOfMessages < 10)
                {
                    // just do it inline it's less expensive than 
                    //spinning threads
                    ReceiveTask(numberOfMessages);
                }
                else
                {
                    //TODO Create a multithreading version for this
                    ReceiveTask(numberOfMessages);
                }
            }

            if (!CancellationToken)
            {

                //TODO testing
                _setLock.lock();

                Iterator<Message> _setIter = _set.iterator();
                //TODO
                while(_setIter.hasNext())
                {
                    Message temp = _setIter.next();

                    Long value = Long.valueOf(temp.getAttributes().
                            get("Timestamp"));
                    if(value.longValue() < epochWindowTime)
                    {
                        messages.add(temp);
                        _set.remove(temp);
                    }
                }

                _setLock.unlock();

                // TODO deduplicate the messages

                // TODO reorder the messages

                // TODO raise new Event with the results
            }

            if ((!CancellationToken) && (messages.size() > 0))
            {
                if (messages.size() < 10)
                {
                    Pair<Integer, Integer> range = 
                            new Pair<Integer, Integer>(Integer.valueOf(0), 
                                    Integer.valueOf(messages.size()));
                    DeleteTask(messages, range);
                }
                else
                {
                    //TODO Create a way to divide this work among 
                    //several threads
                    Pair<Integer, Integer> range = 
                            new Pair<Integer, Integer>(Integer.valueOf(0), 
                                    Integer.valueOf(messages.size()));
                    DeleteTask(messages, range);
                }
            }
        }catch (AmazonServiceException ase){
            ase.printStackTrace();
        }catch (AmazonClientException ace) {
            ace.printStackTrace();
        }
    }
}

可以从一些评论中看出，我当前处理此问题的首选方法是，如果有消息，则在计时器线程中创建一个事件。 然后，主线程将监听此事件并适当地处理它。

目前，我不熟悉Java如何处理事件或如何为事件创建/监听。 我也不知道是否可以创建事件并使其中包含的信息在线程之间传递。

有人可以给我一些关于我的方法是否可行的建议/见解吗？ 如果是这样，由于目前的搜索尝试没有取得成果，因此我可以在哪里找到有关如何实现它们的信息。

如果没有，请问我能如何解决这个问题，请记住我想尽可能避免管理套接字。

编辑1：

主线程还将负责根据其接收到的消息来发布命令，或发布命令以获取所需的信息。 因此，主线程不能等待接收消息，而应以基于事件的方式处理它们。

Answer 1

生产者－消费者模式：

一个线程（生产者）将对象（消息）连续地堆叠在队列中。 另一个线程（消费者）读取队列中的对象并将其删除。

如果您的问题适合此，请尝试“ BlockingQueue”。 http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/BlockingQueue.html

简单有效。

如果队列为空，则消费者将被“阻止”，这意味着线程将等待（因此，不使用cpu时间），直到生产者放置一些对象为止。 否则，消费者将持续消耗对象。 如果队列已满，则生产者将被阻止，直到消费者消耗一些对象在队列中腾出空间，反之亦然。

这是一个示例：（队列在生产者和使用者中都应该是相同的对象）

---

（生产线程）

Message message = createMessage();
queue.put(message);

（消费者线程）

Message message = queue.take();
handleMessage(message);