我有这段代码：
private ConcurrentLinkedQueue<Interval> intervals = new ConcurrentLinkedQueue();
@Override
public void run(){
while(!intervals.isEmpty()){
//remove one interval
//do calculations
//add some intervals
}
}
此代码由特定数量的线程同时执行。如您所见，循环应该继续，直到集合中没有剩余的间隔，但是存在问题。在每次迭代开始时，会从集合中删除一个间隔，最后可能会将一些间隔添加回同一集合中。
问题是，当一个线程在循环内部时，集合可能变为空，因此尝试进入循环的其他线程将无法执行此操作并过早地完成其工作，即使集合
这意味着当前没有线程在循环中工作，并且集合中没有剩余元素。有哪些可能的方法来实现这一目标？任何想法都受到欢迎。
在我的特定情况下解决此问题的一种方法是为每个线程提供原始集合的不同部分。但是在一个线程完成它的工作之后它将不再被程序使用，即使它可以帮助其他线程进行计算，所以我不喜欢这个解决方案，因为利用机器的所有内核很重要我的问题。
这是我能想到的最简单的最小工作示例。这可能是冗长的。
public class Test{
private ConcurrentLinkedQueue<Interval> intervals = new ConcurrentLinkedQueue();
private int threadNumber;
private Thread[] threads;
private double result;
public Test(int threadNumber){
intervals.add(new Interval(0, 1));
this.threadNumber = threadNumber;
threads = new Thread[threadNumber];
}
public double find(){
for(int i = 0; i < threadNumber; i++){
threads[i] = new Thread(new Finder());
threads[i].start();
}
try{
for(int i = 0; i < threadNumber; i++){
threads[i].join();
}
}
catch(InterruptedException e){
System.err.println(e);
}
return result;
}
private class Finder implements Runnable{
@Override
public void run(){
while(!intervals.isEmpty()){
Interval interval = intervals.poll();
if(interval.high - interval.low > 1e-6){
double middle = (interval.high + interval.low) / 2;
boolean something = true;
if(something){
intervals.add(new Interval(interval.low + 0.1, middle - 0.1));
intervals.add(new Interval(middle + 0.1, interval.high - 0.1));
}
else{
intervals.add(new Interval(interval.low + 0.1, interval.high - 0.1));
}
}
}
}
}
private class Interval{
double low;
double high;
public Interval(double low, double high){
this.low = low;
this.high = high;
}
}
}
您可能需要了解的程序：每次迭代间隔应该消失（因为它太小），变小或分成两个较小的间隔。没有间隔后，工作完成。此外，我应该能够限制使用某些数字n执行此工作的线程数。实际程序通过划分间隔并使用某些规则丢弃那些不能包含最大值的区间的部分来查找某个函数的最大值，但这不应该与我的问题真正相关。
答案 0 :(得分：2)
您可以使用原子标记，即：
private ConcurrentLinkedQueue<Interval> intervals = new ConcurrentLinkedQueue<>();
private AtomicBoolean inUse = new AtomicBoolean();
@Override
public void run() {
while (!intervals.isEmpty() && inUse.compareAndSet(false, true)) {
// work
inUse.set(false);
}
}
UPD
问题已更新，所以我会给你更好的解决方案。它更经典＆＃34;使用阻塞队列的解决方案;
private BlockingQueue<Interval> intervals = new ArrayBlockingQueue<Object>();
private volatile boolean finished = false;
@Override
public void run() {
try {
while (!finished) {
Interval next = intervals.take();
// put work there
// after you decide work is finished just set finished = true
intervals.put(interval); // anyway, return interval to queue
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
UPD2
现在最好重新编写解决方案并将范围划分为每个线程的子范围。
答案 1 :(得分：1)
您的问题看似递归 - 处理一个任务（间隔）可能会产生一些子任务（子间隔）。
为此，我会使用RecursiveTask和class Interval {
...
}
class IntervalAction extends RecursiveAction {
private Interval interval;
private IntervalAction(Interval interval) {
this.interval = interval;
}
@Override
protected void compute() {
if (...) {
// we need two sub-tasks
IntervalAction sub1 = new IntervalAction(new Interval(...));
IntervalAction sub2 = new IntervalAction(new Interval(...));
sub1.fork();
sub2.fork();
sub1.join();
sub2.join();
} else if (...) {
// we need just one sub-task
IntervalAction sub3 = new IntervalAction(new Interval(...));
sub3.fork();
sub3.join();
} else {
// current task doesn't need any sub-tasks, just return
}
}
}
public static void compute(Interval initial) {
ForkJoinPool pool = new ForkJoinPool();
pool.invoke(new IntervalAction(initial));
// invoke will return when all the processing is completed
}
：
{{1}}
答案 2 :(得分：1)
我遇到了同样的问题，我测试了以下解决方案。
在我的测试示例中，我有一个填充整数的队列（相当于你的间隔）。对于测试，在每次迭代时，如果新值低于7（任意），则从队列中取出一个数字，递增并放回队列中。这与机制上的间隔生成具有相同的影响。
这是一个示例工作代码（请注意，我在java 1.8中开发并使用Executor framework来处理我的线程池。）：
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
public class Test {
final int numberOfThreads;
final BlockingQueue<Integer> queue;
final BlockingQueue<Integer> availableThreadsTokens;
final BlockingQueue<Integer> sleepingThreadsTokens;
final ThreadPoolExecutor executor;
public static void main(String[] args) {
final Test test = new Test(2); // arbitrary number of thread => 2
test.launch();
}
private Test(int numberOfThreads){
this.numberOfThreads = numberOfThreads;
this.queue = new PriorityBlockingQueue<Integer>();
this.availableThreadsTokens = new LinkedBlockingQueue<Integer>(numberOfThreads);
this.sleepingThreadsTokens = new LinkedBlockingQueue<Integer>(numberOfThreads);
this.executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(numberOfThreads);
}
public void launch() {
// put some elements in queue at the beginning
queue.add(1);
queue.add(2);
queue.add(3);
for(int i = 0; i < numberOfThreads; i++){
availableThreadsTokens.add(1);
}
System.out.println("Start");
boolean algorithmIsFinished = false;
while(!algorithmIsFinished){
if(sleepingThreadsTokens.size() != numberOfThreads){
try {
availableThreadsTokens.take();
} catch (final InterruptedException e) {
e.printStackTrace();
// some treatment should be put there in case of failure
break;
}
if(!queue.isEmpty()){ // Continuation condition
sleepingThreadsTokens.drainTo(availableThreadsTokens);
executor.submit(new Loop(queue.poll(), queue, availableThreadsTokens));
}
else{
sleepingThreadsTokens.add(1);
}
}
else{
algorithmIsFinished = true;
}
}
executor.shutdown();
System.out.println("Finished");
}
public static class Loop implements Runnable{
int element;
final BlockingQueue<Integer> queue;
final BlockingQueue<Integer> availableThreadsTokens;
public Loop(Integer element, BlockingQueue<Integer> queue, BlockingQueue<Integer> availableThreadsTokens){
this.element = element;
this.queue = queue;
this.availableThreadsTokens = availableThreadsTokens;
}
@Override
public void run(){
System.out.println("taking element "+element);
for(Long l = (long) 0; l < 500000000L; l++){
}
for(Long l = (long) 0; l < 500000000L; l++){
}
for(Long l = (long) 0; l < 500000000L; l++){
}
if(element < 7){
this.queue.add(element+1);
System.out.println("Inserted element"+(element + 1));
}
else{
System.out.println("no insertion");
}
this.availableThreadsTokens.offer(1);
}
}
}
我运行此代码进行检查，它似乎正常工作。然而，肯定会有一些改进：
这个想法是主线程检查终止，为此它必须知道当前有多少线程正在工作（因此它不会过早地停止算法，因为队列是空的）。为此，将创建两个特定队列：availableThreadsTokens和sleepingThreadsTokens。 availableThreadsTokens中的每个元素都表示已完成迭代的线程，并等待另一个线程。 sleepingThreadsTokens中的每个元素都表示可用于进行新迭代的线程，但队列为空，因此它没有工作并且进入“休眠”状态。所以在每个时刻availableThreadsTokens.size（）+ sleepingThreadsTokens.size（）= numberOfThreads - threadExcecutingIteration。
请注意，availableThreadsTokens和sleepingThreadsTokens上的元素仅表示线程活动，它们不是线程，也不是设计特定线程。
终止案例：假设我们有N个线程（aribtrary，固定号码）。 N个线程正在等待工作（在availableThreadsTokens中有N个令牌），队列中只剩下1个元素，并且此元素的处理不会生成任何其他元素。 Main获取第一个标记，发现队列不为空，轮询元素并发送线程工作。 N-1个下一个令牌逐个被消耗，并且由于队列为空，令牌被逐个移动到sleepingThreadsTokens中。 Main知道循环中有1个线程工作，因为availableThreadsTokens中没有令牌，sleepThreadsTokens中只有N-1，所以它等待（.take（））。当线程完成并释放令牌Main消耗它时，发现队列现在为空并将最后一个令牌放在sleepingThreadsTokens中。由于所有令牌现在处于sleepingThreadsTokens Main知道1）所有线程都处于非活动状态2）队列为空（否则最后一个令牌不会被转移到sleepingThreadsTokens，因为线程会接受这个工作）。
请注意，如果工作线程在所有availableThreadsTokens移动到sleepingThreadsTokens之前完成处理，则没有任何区别。
现在，如果我们假设最后一个元素的处理会在队列中生成M个新元素，那么Main会将所有来自sleepingThreadsTokens的标记放回到availableThreadsTokens，并开始再次为它们分配处理。即使M＆lt;＆lt; N因为我们不知道将来会插入多少元素，所以我们必须保持所有线程可用。
答案 3 :(得分：0)
我会建议一个主人/工人的方法。
主进程遍历时间间隔并将该时间间隔的计算分配给不同的进程。它还根据需要删除/添加。这样，所有核心都被利用，并且只有当所有间隔都完成时，才完成该过程。这也称为动态工作分配。
一个可能的例子：
public void run(){
while(!intervals.isEmpty()){
//remove one interval
Thread t = new Thread(new Runnable()
{
//do calculations
});
t.run();
//add some intervals
}
}
您提供的可能解决方案称为静态分配，并且您将更正，它将以最慢处理器的速度完成，但动态方法将利用所有内存。
答案 4 :(得分：0)
我也遇到过这个问题。我解决它的方法是使用AtomicInteger来了解队列中的内容。在每个offer（）之前递增整数。每次poll（）后递减整数。 CLQ没有真正的isEmpty（），因为它必须查看头/尾节点，这可以原子地改变（CAS）。
这并不保证100％某个线程可能会在另一个线程递减后递增，因此您需要在结束线程之前再次检查。它比依赖while（... isEmpty（））
更好除此之外，您可能需要同步。