为什么我的线程不同步？

Question

我想了解同步线程，但我不明白我遇到的问题。

有人可以帮助我诊断这个，或者甚至更好的解释我如何诊断这个自己？

import java.util.ArrayList; 
import java.util.List; 
import java.util.concurrent.CyclicBarrier; 

public class Controller { 

public static void main(String[] args) {   
    int numThreads = 0; 
    List<Thread> threads = new ArrayList<>(); 

    if (args.length > 0) { 
     numThreads = Integer.parseInt(args[0]); 
    } 
    else { 
     System.out.println("No arguments"); 
     System.exit(1); 
    } 

    CyclicBarrier barrier = new CyclicBarrier(numThreads); 
    int arr[][] = new int[10][10]; 

    for (int i = 0; i < numThreads; i++) { 
     Thread newThread = new Thread(new ThreadableClass(barrier, arr)); 
     threads.add(newThread); 
    } 

    for (Thread thread : threads) { 
     thread.start(); 
    } 
    } 
} 

有一个主要方法（上面）接受我希望作为命令行参数的线程数。而且还有一个工作流程（如下图）这我的目标有增量在二维阵列中的所有元素，并打印数组的下一个线程都有机会做同样的面前：

import java.util.concurrent.BrokenBarrierException; 
import java.util.concurrent.CyclicBarrier; 

public class ThreadableClass implements Runnable { 

private CyclicBarrier barrier; 
private int arr[][]; 

public ThreadableClass(CyclicBarrier barrier, int[][] arr) { 
    this.barrier = barrier; 
    this.arr = arr; 
} 

@Override 
public void run() { 
    long threadId = Thread.currentThread().getId(); 
    System.out.println(threadId + " Starting"); 

    for (int i = 0; i < 10; i++) { 
     changeArray(); 
     try { 
      barrier.await(); 
     } catch (InterruptedException | BrokenBarrierException e) { 
      e.printStackTrace(); 
     } 
    } 
} 

private synchronized void changeArray() { 
    for (int i = 0; i < arr.length; i++) { 
     for (int j = 0; j < arr.length; j++) { 
      arr[i][j]++; 
     } 
    } 
    printArray(); 
} 

private synchronized void printArray() { 
    System.out.println(Thread.currentThread().getId() + " is printing: "); 
    for (int i = 0; i < arr.length; i++) { 
     for (int j = 0; j < arr.length; j++) { 
      System.out.print(arr[i][j] + " "); 
     } 
     System.out.println(); 
    } 
} 
} 

想象的大小该阵列是2×2，预期产量会是这个样子：

1 1 
1 1 
2 2 
2 2 
3 3 
3 3 
4 4 
4 4 
... 
... 
(10 * numThreads)-1 (10 * numThreads)-1 
(10 * numThreads)-1 (10 * numThreads)-1 
(10 * numThreads) (10 * numThreads) 
(10 * numThreads) (10 * numThreads) 

相反，所有线程递增排列，并开始印刷了彼此。

Answer 1

有没有令人惊讶的结果。您创建n线程。你告诉所有线程开始。每个线程运行（）开始于：

long threadId = Thread.currentThread().getId(); 
System.out.println(threadId + " Starting"); 
...changeArray(); 

要去改变共享数组。 写入数组后，您尝试同步（在该屏障上）。那太晚了！

重点是：你有10 不同 ThreadableClass实例。每个人都在拥有！​​关键词...在这里根本不提供任何保护！

因为：同步防止不同线程调用相同物体上的相同的方法。但是当你有多个对象，并且你的线程正在调用那些不同的对象上的那个方法时，比起有没有锁！你的代码做下来归结到：

threadA to call changeArray() .. on itself 
threadB to call changeArray() .. on itself 
threadC to call changeArray() .. on itself 

...

换句话说：你给ň线程访问该共享的阵列。但是，你允许那些线程同时输入changeArray（）。

一个简单的修复;改变

private synchronized void changeArray() { 

到

换句话说：确保n个线程必须锁定相同监视器上;在那种情况下共享数组。

或者：而不是使changeArray()一个方法在该ThreadableClass ...创建一个类

ArrayUpdater { 
    int arr[] to update 

    synchronized changeArray() ... 

然后创建该类的一个实例;并为每个线程分配相同的实例。现在，sync'ed方法将阻止多个线程进入！

Answer 2

由于您使用new ThreadableClass(barrier, arr)每个theard提供new情况下，基本上所有theadrs使用不同ThreadableClass对象，所以你的代码同步方法平行运行，所以你需要使用一个ThreadableClass对象，如下图所示：

ThreadableClass threadableClass= new ThreadableClass(barrier, arr); 
for (int i = 0; i < numThreads; i++) { 
    Thread newThread = new Thread(threadableClass); 
    threads.add(newThread); 
} 

重要的一点是同步是所有关于在时间提供访问（即，键），以用于一个单一的线程中的对象。如果您为每个线程使用不同的对象，则线程不会等待该密钥，因为每个线程都有自己的密钥（如您的示例中所示）。