Java 如何维护使用者线程的执行顺序

我为一个生产者和多个消费者运行代码。我想优先考虑消费者线程的执行。i、 如果我有constread1，constread2，constread3。我的问题是如何限制constread3在constread1和constread2之前使用

Producer.java

import java.util.concurrent.BlockingQueue;
import org.json.simple.JSONObject;

public class Producer implements Runnable {
    private final BlockingQueue<Message> sharedQueue;

    @SuppressWarnings("unchecked")
    public Producer(BlockingQueue<Message> sharedQueue){
        this.sharedQueue=sharedQueue;
    }

    @Override
    public void run() {
        try{
            for(int i=0;i<4;i++) {
                Message msg=new Message(""+i);
                System.out.println("Producer Produced: " +msg.getMessage());
                sharedQueue.put(msg);
                Thread.sleep(400);
            }
            sharedQueue.put(new Message("exit")); // end of producing
            System.out.println("-------Producer STOPPED------");
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

import java.util.concurrent.BlockingQueue；
导入org.json.simple.JSONObject；
公共类生产者实现Runnable{
私有最终阻塞队列sharedQueue；
@抑制警告（“未选中”）
公共生产者（封锁队列共享队列）{
this.sharedQueue=sharedQueue；
}
@凌驾
公开募捐{
试一试{
对于（inti=0；i如果你想一个接一个地执行，为什么要使用多个线程呢？你应该重构成一个线程

但是，如果要跳过重构，可以将使用线程放入固定线程池。在线程池中，可以设置活动线程的最大数量，因此可以将最大数量设置为1，线程池将逐个执行线程

另一种选择是创建一个循环屏障，其中屏障操作是您的第三个线程（它将在其他线程之后调用）。您可以通过循环屏障执行前两个线程。屏障可以计算完成线程的数量，并在达到阈值时执行第三个线程。这应该满足您希望第三个使用者线程等待事件被消费的目标。
为什么要这样做？因此，您要按顺序创建三个使用者线程能够同时消费3个项目，但实际上你希望它们按顺序消费，而不是同时消费？为什么要启动3个线程？只使用一个消费线程，消费将是按顺序进行的。但是要注意，正如JB指出的，为什么要使用三个线程呢？想想看。按各自的原因启动每一个线程是没有意义的d如果它们按顺序运行。这很有意义：）你仍然没有抓住要点。如果一次只允许一个使用者工作，那么没有理由有多个使用者。一个使用者就足够了。
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import org.json.simple.JSONObject;

public class Consumer implements Runnable{

    private final BlockingQueue<Message> sharedQueue;
    private String threadId;

    public Consumer(BlockingQueue<Message> sharedQueue) {           
        this.sharedQueue=sharedQueue;           
    }

    @SuppressWarnings("unchecked")
    @Override
    public void run() {
        threadId = "Consumer-" + Thread.currentThread().getName();
        try {
            Message msg;
            while (true){
                msg=sharedQueue.poll(5,TimeUnit.SECONDS);
                if(msg.getMessage()=="exit" || msg.getMessage()==null){
                    sharedQueue.put(new Message("exit"));
                    break;
                }
                System.out.println(threadId + ": Consuming Message " + msg.getMessage());
                Thread.sleep(1000);
            }
            System.out.println(threadId + " STOPPED Consuming ");
        }
        catch (InterruptedException ie) {
            ie.printStackTrace();
        }
    }
}

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import org.json.simple.JSONObject;

public class ProducerConsumer {

    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Message> sharedQueue = new LinkedBlockingQueue<>(10);

        //Creating Producer and Consumer Thread
        Thread prodThread = new Thread(new Producer(sharedQueue));
        Thread consThread1 = new Thread(new Consumer(sharedQueue));
        Thread consThread2 = new Thread(new Consumer(sharedQueue));
        Thread consThread3 = new Thread(new Consumer(sharedQueue));
        //Starting producer and Consumer thread
        System.out.println("Producer and consumer threads started \n\n\n---------------------------------------");

        prodThread.start();
        consThread1.start();
        consThread2.start();
        consThread1.join();
        consThread2.join();
        consThread3.start();
    }
}