java - 如何同时工作具有相同优先级的两个不同线程？

Question

我正在使用一个队列，即BlockingQueue。我正在尝试制作一个具有两个具有相同优先级的线程的应用程序。第一个线程将连续地将元素添加到队列中，第二个线程将不断地从同一队列中轮询。

程序:

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class Demo {

    private final BlockingQueue<Integer> list = new ArrayBlockingQueue<Integer>(10000);
    public int count;

    public  void insert() {
        while (true) {
            list.add(count);
            System.out.println(" inserted : "+count);
            count++;
        }
    }

    public  void remove()  {
        while (true) {
            try {
                int pollElement = (int) list.take();
                System.out.println("removed : " + pollElement);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Demo main = new Demo();
        Thread thread1 = new Thread() {
            @Override
            public void run() {
                main.insert();
            }
        };
        thread1.start();
        Thread thread2 = new Thread() {
            @Override
            public void run() {
                main.remove();
            }
        };
        thread2.start();
    }
}

上面的程序会经常产生如下的输出:

removed : 4992
removed : 4993
inserted : 5195
removed : 4994
inserted : 5196
removed : 4995
inserted : 5197
removed : 4996
inserted : 5198
inserted : 5199
inserted : 5200
inserted : 5201
inserted : 5202

实际要求:

我想要这个应用程序的行为，例如，如果一个元素被插入到队列中，然后第二个线程被通知进行特定的插入操作，以便它可以从同一队列中轮询。即我不希望连续插入操作或连续轮询操作。

让我们考虑一下，count变量无非是不断从服务器中提取数据，该数据不断地被插入到队列中。如果队列上正在进行连续的轮询操作，那么我将丢失在轮询操作正常工作的特定时间到达的服务器数据。

Answer 1

如果我对您的理解正确，则可以使用AtomicBoolean对其进行仿真。

private AtomicBoolean aBoolean = new AtomicBoolean(true); // init value - true

然后在insert和remove方法中添加条件

public  void insert() {
    while (true) {
        if(aBoolean.get()) {
            list.add(count);
            System.out.println(" inserted : "+ count);
            count++;
            aBoolean.getAndSet(false);
        }
    }
}



public  void remove()  {
    while (true) {
        if(!aBoolean.get()) {
            try {
                int pollElement = (int) list.take();
                System.out.println("removed : " + pollElement);
                aBoolean.getAndSet(true);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

因此，仅允许您在aBoolean为true时插入元素，而在aBoolean为false时删除元素。 AtomicBoolean是thread-safe. After insert/delete you change the aBoolean，具有相反的值，以便其他线程可以执行它的任务。

这是输出:

inserted : 0
removed : 0
inserted : 1
removed : 1
inserted : 2
removed : 2
inserted : 3
removed : 3
inserted : 4
removed : 4
inserted : 5
removed : 5
inserted : 6
removed : 6
inserted : 7
removed : 7