以线程安全的方式填充地图并将该地图从后台线程传递给另一个方法？

Question

I have a below class in which add method will be called by multiple threads to populate channelMessageHolder CHM in a thread safe way.

In the same class, I have a backgrond thread which runs every 30 seconds and it calls send method by passing data from the channelMessageHolder .

public class Processor {
  private final ScheduledExecutorService executorService = Executors
      .newSingleThreadScheduledExecutor();
  private final AtomicReference<ConcurrentHashMap<Channel, ConcurrentLinkedQueue<Message>>> channelMessageHolder =
                new AtomicReference<>(new ConcurrentHashMap<Channel, ConcurrentLinkedQueue<Message>>());

  private Processor() {
    executorService.scheduleAtFixedRate(new Runnable() {
      @Override
      public void run() {
        send();
      }
    }, 0, 30, TimeUnit.SECONDS);
  }

  // this will be called by only single background thread
  private void send(ConcurrentHashMap<Channel, ConcurrentLinkedQueue<Message>> messageByChannels) {
    for(Entry<Channel, ConcurrentLinkedQueue<Message>> entry : messageByChannels.entrySet()) {
      Channel channel = entry.getKey();
      ConcurrentLinkedQueue<Message> messageHolder = entry.getValue();

      while (!messageHolder.isEmpty()) {
        Message message = messageHolder.poll();
        ....
        // process this and send to database
      }      
    }
  }

  // called by multiple threads
  public void add(final Channel channel, final Message message) {
    // populate channelMessageHolder in a thread safe way
  }
}

Question

As you can see channelMessageHolder is already present in my Processor class so do I need to explicitly pass data from this map every 30 seconds to send method? Or I can directly use it in my send method?

Confusion is, if I directly use it in my send method, then it will be populated by multiple threads at the same time so that's why I am using getAndSet method of AtomicReference to pass it to send method.

Let me know if what I am doing is wrong and there is any better way to do that?

Answer 1

Or I can directly use it in my send method without passing anything

You should be able to directly use it in the send method by saying channelMessageHolder.getAndSet(new ConcurrentHashMap<Channel, ConcurrentLinkedQueue<Message>>()) at the beginning of the send method without any issues.

That said, Java 8 has added a new method called computeIfAbsent to the ConcurrentHashMap class which means that you don't really need that AtomicReference that you are using.

Answer 2

As you can see channelMessageHolder is already present in my Processor class so do I need to explicitly pass data from this map every 30 seconds to send method? Or I can directly use it in my send method?

You can certainly use it directly in the send() method and you don't need the AtomicReference wrapper since ConcurrentHashMap is already synchronized. What you need to worry about is that your key and value objects in the map are being properly synchronized. I assume the Channel is immutable and the ConcurrentLinkedQueue is concurrent so you should be good.

// no need for AtomicReference
private final ConcurrentHashMap<Channel, ConcurrentLinkedQueue<Message>> channelMessageHolder =
     new ConcurrentHashMap<Channel, ConcurrentLinkedQueue<Message>>();

The ConcurrentHashMap takes care of the synchronization for you so the producer threads can add items into it at the same time that your sender thread is sending items out without clashing. An AtomicReference is only needed if you were trying to share an unsynchronized class between multiple threads.

Confusion is, if I directly use it in my send method, then it will be populated by multiple threads at the same time so that's why I am using getAndSet method of AtomicReference to pass it to send method.

Right but this ok. Multiple threads will be adding messagesto the ConcurrentLinkedQueue . Every 30 seconds your background thread starts up, gets the Channel , dequeues and then sends the messages that are in the queue at that moment. The ConcurrentLinkedQueue protects against race conditions of the producer and consumer.

The problem that you have in your code is that this isn't reentrant since it relies on multiple calls to the queue:

while (!messageHolder.isEmpty()) {
    Message message = messageHolder.poll();

It works in your case because there looks to be only one thread dequeue-ing but the following code is better:

while (true) {
    // only one call to the concurrent queue
    Message message = messageHolder.poll();
    if (message == null) {
        break;
    }
    ...
}