在while循环中轮询阻塞队列时安全线程

Question

Consider the below example where an ItemDeletionManager can enqueue items to delete. A worker thread can call it's createJob() method that will create a compound job to delete all items at once. Assume that the worker thread periodically runs every few minutes or so. But items to delete can get enqueued every few seconds. This is why it's necessary to create a compound job and not have the worker create one job for one item on each iteration.

If we now have two workers that share the same manager like below,

ItemDeletionManager itemManager = new ItemDeletionManager();

DeletionWorker a = new DeletionWorker(itemManager);
DeletionWorker b = new DeletionWorker(itemManager);

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
scheduledExecutorService.scheduleAtFixedRate(a, 0, 10, TimeUnit.MINUTES);
scheduledExecutorService.scheduleAtFixedRate(b, 0, 10, TimeUnit.MINUTES);

I could end up in a situation where there is exactly one item to delete, and both workers have validated that the blocking queue isn't empty. But after one thread polls for the item to delete and creats it's deletion assignment, the second worker gets a null and ends up creating a deletion assignment of null.

The easiest option would be to synchronize ItemDeletionManager 's create job. But is there a better solution?

/**
 * Worker that executes ItemDeletionManager's create job.
 */
class DeletionWorker implements Runnable {

    ItemDeletionManager itemManager;

    public DeletionWorker(ItemDeletionManager itemManager) {
        this.itemManager = itemManager;
    }

    @Override
    public void run() {
        itemManager.createJob();
    }
}

/**
 * Manages deletion of Items.
 */
class ItemDeletionManager {

    private final Queue<Integer> idsOfItemsToDelete;

    public ItemDeletionManager() {
        this.idsOfItemsToDelete = new LinkedBlockingQueue<>();
    }

    public void enqueue(int itemId) {
        this.idsOfItemsToDelete.add(itemId);
    }

    public CompoundJob createJob() {
        CompoundJob job = new CompoundJob();
        while (!idsOfItemsToDelete.isEmpty()) {
            // 2 threads can reach this point at the same time
            Integer itemId = idsOfItemsToDelete.poll();
            job.addSubAssignment(DeletionAssignment.of(itemId));
        }
        return job;
    }
}

/**
 * Implementers of this handle its respective requirement.
 * Eg: DeletionAssignment handles deletion of item, CreationAssignment handles creation of item and so on..
 */
interface Assignment {

    void execute();
}

/**
 * Executes a collection of assignments.
 */
class CompoundJob {

    private final List<Assignment> subAssignments = new ArrayList<>();

    public void addSubAssignment(Assignment assignment) {
        subAssignments.add(assignment);
    }

    public void doJob() {
        for (Assignment assignment : subAssignments) {
            assignment.execute();
        }
    }
}

Answer 1

As you have well identified, calling isEmpty() and then poll() isn't thread safe unless you synchronize, but it's quite sad to do so with a concurrent datastructure.

In fact you shouldn't call isEmpty() beforehand. Whether you call take() and it blocks until there's an item, or you call poll() directly without checking isEmpty() first and know that, if you get null, then it means that the queue was empty. You also have the intermediate option between take() and poll() by specifying a time limit.

I suggest you to use poll() directly and handle null, like so:

while (true) {
  Integer itemId = idsOfItemsToDelete.poll();
  if (itemId==null) break;
  job.addSubAssignment(DeletionAssignment.of(itemId));
}

Even if several threads execute this same code concurrently, you are guaranteed to not get twice the same item. However, retrieval won't be equally distributed, ie it may happen that one of the thread take all items and the other take none.