Java在Runnable线程中实现动态FIFO式永久迭代列表需求

Alright, let's break down how to solve this problem properly. You need a thread-safe, FIFO-style structure that lets you iterate permanently in a Runnable while supporting external adds and internal removes—plus handling empty states without wasting CPU cycles. Here's a practical, production-ready approach:

First, forget about using a plain ArrayList or non-thread-safe list: they'll throw ConcurrentModificationException when modified during iteration, and won't guarantee data consistency across threads. Instead, use a thread-safe queue—it's designed exactly for this FIFO, multi-threaded scenario.

1. Choose the Right Container #

The best options are:

• LinkedBlockingQueue: A blocking queue that automatically blocks the thread when empty (no CPU-wasting empty loops) and is fully thread-safe for adds/removes. Perfect for your "never-stop" requirement.
• ConcurrentLinkedQueue: A non-blocking thread-safe queue (good if you don't want blocking behavior, but you'll need to handle empty states manually).

We'll focus on LinkedBlockingQueue first—it's the most straightforward solution.

2. Implement the Runnable Task #

This task will run a permanent loop, block when the queue is empty, process elements, and support graceful shutdown (since "never stop" doesn't mean you can't shut it down cleanly later).

import java.util.concurrent.LinkedBlockingQueue;

public class ContinuousProcessor implements Runnable {
    private final LinkedBlockingQueue<Object> taskQueue;
    private volatile boolean isRunning = true;

    // Inject the queue so we can add elements from outside the thread
    public ContinuousProcessor(LinkedBlockingQueue<Object> taskQueue) {
        this.taskQueue = taskQueue;
    }

    @Override
    public void run() {
        while (isRunning) {
            try {
                // Block until an element is available (no empty loops!)
                Object element = taskQueue.take();
                
                // Process the element (replace this with your actual logic)
                processElement(element);
                
                // No need to manually remove—take() already removes the head element
            } catch (InterruptedException e) {
                // Handle thread interruption for graceful shutdown
                Thread.currentThread().interrupt();
                isRunning = false;
                System.out.println("Processor thread interrupted, shutting down...");
            }
        }
    }

    private void processElement(Object element) {
        // Example processing logic: print and simulate work
        System.out.println("Processing element: " + element);
        try {
            Thread.sleep(1000); // Simulate work time
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    // Method to trigger graceful shutdown from outside the thread
    public void stopProcessing() {
        isRunning = false;
        Thread.currentThread().interrupt();
    }
}

3. Use the Processor from External Threads #

You can safely add elements to the queue from any other thread—no extra synchronization needed:

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Initialize the thread-safe queue
        LinkedBlockingQueue<Object> taskQueue = new LinkedBlockingQueue<>();
        
        // Create and start the processor thread
        ContinuousProcessor processor = new ContinuousProcessor(taskQueue);
        Thread processorThread = new Thread(processor);
        processorThread.start();

        // Add elements from the main thread (or any other thread)
        taskQueue.add("User Request 1");
        taskQueue.add("Data Batch A");
        Thread.sleep(3000); // Wait for some processing
        taskQueue.add("User Request 2");
        taskQueue.add("Data Batch B");

        // Simulate shutting down after some time (optional)
        Thread.sleep(5000);
        processor.stopProcessing();
    }
}

What If You Don't Want Blocking Behavior? #

If you need to avoid blocking the thread when the queue is empty (e.g., you want to run other logic during idle time), use ConcurrentLinkedQueue with a short sleep to prevent CPU spamming:

import java.util.concurrent.ConcurrentLinkedQueue;

public class NonBlockingProcessor implements Runnable {
    private final ConcurrentLinkedQueue<Object> taskQueue;
    private volatile boolean isRunning = true;

    public NonBlockingProcessor(ConcurrentLinkedQueue<Object> taskQueue) {
        this.taskQueue = taskQueue;
    }

    @Override
    public void run() {
        while (isRunning) {
            Object element = taskQueue.poll(); // Returns null if empty
            if (element != null) {
                processElement(element);
            } else {
                // Short sleep to avoid wasting CPU cycles
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    isRunning = false;
                }
            }
        }
    }

    // ... processElement() and stopProcessing() methods same as above
}

• Thread safety first: Always use a container designed for multi-threaded access—don't roll your own synchronization unless you have to.
• Avoid empty loops: Blocking queues like LinkedBlockingQueue eliminate CPU waste by suspending the thread until elements are available.
• Graceful shutdown: Use a volatile flag and handle InterruptedException to stop the thread cleanly without corrupting data.

内容的提问来源于stack exchange，提问作者MindCode