线程调度 - 共享数组

Question

我需要两个线程来写入一个共享的整数数组。两个线程都需要写入该数组的所有元素。每个线程将写入1或7，结果应该像171717171（或71717171）。为此，我在位置0处写入第一个Thread1，然后等待。线程2现在写入位置0和1，通知线程1，并等待。 Thread1在位置1和2处写入，通知Thread2并等待等等。使用下面的代码，我可以得到正确的输出，但是当与JPF一起运行时，它会发现死锁。它变得非常令人沮丧，因为我找不到它有什么问题。任何意见，将不胜感激。

import java.util.logging.Level; 
import java.util.logging.Logger; 


public class WriterThreadManager { 

    private int[] array = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; 
    private Thread thread7; 
    private Thread thread1; 

    public static void main(String[] args) { 
     WriterThreadManager mng = new WriterThreadManager(); 
     mng.exec(); 

    } 

    public WriterThreadManager() { 
     thread7 = new Thread(new WriterRunnable(this, 7)); 
     thread1 = new Thread(new WriterRunnable(this, 1)); 
    } 

    public void overwriteArray(int pos, int num) { 
     array[pos] = num; 
     printArray(); 
    } 

    private void printArray() { 
     for (int i = 0; i < array.length; i++) { 
      System.out.print(array[i]); 
     } 
     System.out.println(""); 
    } 

    public synchronized void stopThread() { 
     try { 
      this.wait(); 
     } catch (InterruptedException ex) { 
      Logger.getLogger(WriterThreadManager.class.getName()).log(Level.SEVERE, null, ex); 
     } 
    } 

    public synchronized void wakeUpThread() { 
     notifyAll(); 
    } 

    private void exec() { 
     thread7.start(); 
     thread1.start(); 
    } 

    public int length() { 
     return array.length; 
    } 
} 



public class WriterRunnable implements Runnable { 

    private WriterThreadManager mng; 
    private int numberToWrite; 
    private static boolean flag = true; 

    @Override 
    public void run() { 
     int counter = 0; 
     int j = 0; 

     //first thread to get in should write only at 
     //position 0 and then wait. 
     synchronized (mng) { 
      if (flag) { 
       flag = false; 
       mng.overwriteArray(0, numberToWrite); 
       j = 1; 
       waitForOtherThread(); 
      } 
     } 
     for (int i = j; i < mng.length(); i++) { 
      mng.overwriteArray(i, numberToWrite); 
      counter++; 
      if (i == mng.length() - 1) { 
       mng.wakeUpThread(); 
       break; 
      } 
      if (counter == 2) { 
       waitForOtherThread(); 
       counter = 0; 
      } 
     } 
    } 

    private void waitForOtherThread() { 
     mng.wakeUpThread(); 
     mng.stopThread(); 
    } 

    public WriterRunnable(WriterThreadManager ar, int num) { 
     mng = ar; 
     numberToWrite = num; 
    } 
} 

PS：在执行的例子：

1000000000 
7000000000 
7700000000 
7100000000 
7110000000 
7170000000 
7177000000 
7171000000 
7171100000 
7171700000 
7171770000 
7171710000 
7171711000 
7171717000 
7171717700 
7171717100 
7171717110 
7171717170 
7171717177 
7171717171 

从JPF错误快照如下：

thread java.lang.Thread:{id:1,name:Thread-1,status:WAITING,priority:5,lockCount:1,suspendCount:0} 
    waiting on: WriterThreadManager@152 
    call stack: 
    at java.lang.Object.wait(Object.java) 
    at WriterThreadManager.stopThread(WriterThreadManager.java:43) 
    at WriterRunnable.waitForOtherThread(WriterRunnable.java:53) 
    at WriterRunnable.run(WriterRunnable.java:45) 

thread java.lang.Thread:{id:2,name:Thread-2,status:WAITING,priority:5,lockCount:1,suspendCount:0} 
    waiting on: WriterThreadManager@152 
    call stack: 
    at java.lang.Object.wait(Object.java) 
    at WriterThreadManager.stopThread(WriterThreadManager.java:43) 
    at WriterRunnable.waitForOtherThread(WriterRunnable.java:53) 
    at WriterRunnable.run(WriterRunnable.java:45) 

Answer 1

我相信比赛是由于这种方法：

private void waitForOtherThread() { 
    mng.wakeUpThread(); 
    mng.stopThread(); 
} 

虽然个别wakeUpThread()和stopThread()方法是同步的，你有这些调用之间意想不到的线程调度的机会。

考虑：

thread7 - notify thread1 to wakup 
thread1 - wake up 
thread1 - work to completion 
thread1 - notify thread7 to wakeup 
thread1 - wait to be notified to wakeup 
thread7 - wait to be notified to wakeup 

在这种情况下，你已经陷入僵局，因为线程1 thread7之前发送其notifyAll的（）有机会等待（）它。

在不同的环境中运行可能会混淆您的时间并导致出现这些类型的行为。

为了避免这种情况我建议这样做：

private void waitForOtherThread() { 
    synchronized(mng) { 
     mng.wakeUpThread(); 
     mng.stopThread(); 
    } 
} 

或者更好的是，使用一个信号量，@KumarVivekMitra建议。信号量将通知系统和计数器结合起来，以便通知和等待的顺序无关紧要。

Answer 2

-我认为更好的方法在这里是java.util.Semaphores ，这将帮助您一次确定通过特定数量的线程访问对象资源。

-那么你也可以使用SingleThreadExecutor来解决这个问题，其启动并在移动到第二个任务之前完成任务，所以会有没有从你身边需要在这里需要同步。

Answer 3

我不认为你需要任何协调在这里。只需要一个线程写入偶数位置，另一个线程写入奇数位置。让他们都尽可能快地走。完成！