Java 多线程 : threads shall access list

Question

我正在使用五个线程运行，并且我有一个对象列表(我独立于线程进行初始化)。
列表中的对象使用 boolean 值作为标志，所以我知道它们是否已经由另一个线程处理。此外，我的线程的“ID”有一个整数(所以你知道哪个线程当前正在工作)。
问题:处理 for 循环的第一个线程将处理列表中的所有对象，但我希望线程交替进行。我究竟做错了什么？
run() 方法与此类似:

void run() {
    for (int i = 0; i < list.size(); i++) {
        ListObject currentObject = list.get(i);
        synchronized (currentObject) {
            if (currentObject.getHandled == false) {
                currentObject.setHandled(true);
                System.out.println("Object is handled by " + this.getID());
            } else {
                continue;
            }
        }
    }
}

Answer 1

TL;DR 在线程之间显式或隐式地划分列表；如果确实需要，还可以同步；

The problem: The first thread that gets a hand on the for-loop willhandle all objects in the list, but i want the threads to alternate.What am I doing wrong?

这整个代码块是可以预料的

  for (int i = 0; i < list.size(); i++) {
        ListObject currentObject = list.get(i);
        synchronized (currentObject) {
            ....
        }
    }

基本上是按顺序执行的，因为每个线程在每次迭代中都使用对象 currentObject 进行同步隐式锁。所有五个线程都进入 run方法，但是其中一个首先进入 synchronized (currentObject)所有其他线程将依次等待第一个线程释放 currentObject隐式锁定。当线程完成时，将继续进行下一次迭代，而其余线程仍在前一次迭代中。因此，第一个线程进入 synchronized (currentObject)将有一个领先的开始，并将成为先前线程的步骤，并且可能会计算所有剩余迭代。最后:

The first thread that gets a hand on the for-loop will handle allobjects in the list,

实际上，您最好在性能方面和可读性方面按顺序执行代码。
假设
我假设

存储在列表中的对象在这些线程遍历列表的同时没有被其他地方访问；

该列表不包含对同一对象的多个引用；

我建议不是每个线程都遍历整个列表并在每次迭代中同步——这是非常不执行的并且实际上破坏了并行性的点——每个线程都将计算列表的不同 block (例如，划分迭代线程之间的for循环)。例如:
方法一:使用并行流
如果您不必显式并行化代码，请考虑使用 ParallelStream:

list.parallelStream().forEach(this::setHandled);
   
private void setHandled(ListObject currentObject) {
    if (!currentObject.getHandled) {
        currentObject.setHandled(true);
        System.out.println("Object is handled by " + this.getID());
    }
}

方法 2:如果您必须使用执行器显式并行化代码

I'm running five threads,

(最初由 ernest_k 说明)

 ExecutorService ex = Executors.newFixedThreadPool(5);
 for (ListObject l : list)
     ex.submit(() -> setHandled(l));
 ...

private void setHandled(ListObject currentObject) {
    if (!currentObject.getHandled) {
        currentObject.setHandled(true);
        System.out.println("Object is handled by " + this.getID());
    }
}

方法 3:如果您必须明确使用线程

void run() {
    for (int i = threadID; i < list.size(); i += total_threads) {
        ListObject currentObject = list.get(i);
        if (currentObject.getHandled == false) {
           currentObject.setHandled(true);
           System.out.println("Object is handled by " + this.getID());
       }
    }
}

在这种方法中，我以循环方式在线程之间拆分 for 循环的迭代，假设 total_threads是计算 run 的线程数方法，并且每个线程将有一个唯一的 threadID范围从 0至 total_threads - 1 .在线程之间分配迭代的其他方法也将是可见的，例如在线程之间动态分配迭代:

void run() {
    for (int i = task.getAndIncrement(); i < list.size(); i = task.getAndIncrement();) {
        ListObject currentObject = list.get(i);
        if (currentObject.getHandled == false) {
           currentObject.setHandled(true);
           System.out.println("Object is handled by " + this.getID());
       }
    }
}

在哪里 task将是一个原子整数(即 AtomicInteger task = new AtomicInteger(); )。
在所有方法中，想法都是相同的 将列表的不同 block 分配给线程，以便这些线程可以彼此独立地执行这些 block 。

如果假设 1. 和 2. 无法做出，那么您仍然可以应用上述在线程之间拆分迭代的逻辑，但您需要添加同步，在我的示例中添加到以下代码块中:

  private void setHandled(ListObject currentObject) {
        if (!currentObject.getHandled) {
            currentObject.setHandled(true);
            System.out.println("Object is handled by " + this.getID());
        }
    }

照原样，您只需转动 currentObject字段转换为 AtomicBoolean如下:

private void setHandled(ListObject currentObject) {
    if (currentObject.getHandled.compareAndSet(false, true)) {
        System.out.println("Object is handled by " + this.getID());
    }
}

否则使用同步子句:

private void setHandled(ListObject currentObject) {
        synchronized (currentObject) {
            if (!currentObject.getHandled) {
                currentObject.setHandled(true);
                System.out.println("Object is handled by " + this.getID());
            }
       }
 }