爲什麼這些線程返回錯誤的計算？

Question

我對併發編程還很陌生，到目前爲止我都很享受:)！但是我只是意識到併發編程是多麼棘手。

我有多個線程執行他們自己的計算。每個線程對某個變量進行操作並返回結果，但返回的結果不正確。

該類執行線程計算：

public class SharedDataThread extends Thread { 

private SharedData mySharedData; 
private String myThreadName; 
private static long testVariable = 0; 

// Setup the thread 

SharedDataThread(String name, SharedData sharedstuff) { 
    super(name); 
    mySharedData = sharedstuff; 
    myThreadName = name; 
} 


public void run() { 

    System.out.println(myThreadName + " is running"); 
    Thread me = Thread.currentThread(); // get a ref to the current thread 

    if (me.getName() == "myThread1") { 
     try { 
      sleep(2000); 

      mySharedData.acquireLock(); 
      System.out.println(me.getName() 
        + " is performing computations!"); 

      testVariable = testVariable + 20; 
      testVariable = testVariable * 5; 
      testVariable = testVariable/3; 

      System.out.println(me.getName() + " modified the value to : " 
        + testVariable + "\n"); 

      sleep(2000); 
      mySharedData.releaseLock(); 
     } catch (InterruptedException e) { 
      System.err.println("Failed to get lock when reading:" + e); 
     } 
    } else if (me.getName() == "myThread2") { 
     try { 
      sleep(2000); 

      mySharedData.acquireLock(); 
      System.out.println(myThreadName 
        + " is performing computations!"); 

      testVariable = testVariable - 5; 
      testVariable = testVariable * 10; 
      testVariable = (long) (testVariable/2.5); 

      System.out.println(me.getName() + " modified the value to : " 
        + testVariable + "\n"); 

      sleep(2000); 
      mySharedData.releaseLock(); 
     } catch (InterruptedException e) { 
      System.err.println("Failed to get lock when reading:" + e); 
     } 
    } else if (me.getName() == "myThread3") { 
     try { 
      sleep(2000); 

      mySharedData.acquireLock(); 

      System.out.println(me.getName() 
        + " is performing computations!"); 

      testVariable = testVariable - 50; 
      testVariable = testVariable/2; 
      testVariable = testVariable * 33; 

      System.out.println(me.getName() + " modified the value to : " 
        + testVariable + "\n"); 

      sleep(2000); 
      mySharedData.releaseLock(); 
     } catch (InterruptedException e) { 
      System.err.println("Failed to get lock when reading:" + e); 
     } 
    } else { 
     try { 
      sleep(2000); 

      mySharedData.acquireLock(); 
      System.out.println(me.getName() 
        + " is performing computations!"); 

      testVariable = testVariable * 20; 
      testVariable = testVariable/10; 
      testVariable = testVariable - 1; 

      System.out.println(me.getName() + " modified the value to : " 
        + testVariable + "\n"); 

      sleep(2000); 

      mySharedData.releaseLock(); 
     } catch (InterruptedException e) { 
      System.err.println("Failed to get lock when reading:" + e); 
     } 
    } 
    System.out.println("The final result of the variable is " 
      + testVariable); 
} 

}

線程是在另一個類執行自己的主線程中執行：

public class SharingExample { 

公共靜態無效的主要（ String [] args）{

SharedData mySharedData = new SharedData(); 


SharedDataThread myThread1 = new SharedDataThread("myThread1", mySharedData); 
SharedDataThread myThread2 = new SharedDataThread("myThread2", mySharedData); 
SharedDataThread myThread3 = new SharedDataThread("myThread3", mySharedData); 
SharedDataThread myThread4 = new SharedDataThread("myThread4", mySharedData); 


// Now start the threads executing 

myThread1.start(); 
myThread2.start(); 
myThread3.start(); 
myThread4.start(); 

} }

SharedData類只是一個用於實現鎖等的類。

public class SharedData { 

    private boolean accessing=false; // true a thread has a lock, false otherwise 
    private int threadsWaiting=0; // number of waiting writers 

    // attempt to acquire a lock 
    public synchronized void acquireLock() throws InterruptedException{ 
    Thread me = Thread.currentThread(); // get a ref to the current thread 
    System.out.println(me.getName()+" is attempting to acquire a lock!"); 

    ++threadsWaiting; 
    while (accessing) { // while someone else is accessing or threadsWaiting > 0 
     System.out.println(me.getName()+" waiting to get a lock as someone else is accessing..."); 
     //wait for the lock to be released - see releaseLock() below 
    wait(); 
    } 
    // nobody has got a lock so get one 
    --threadsWaiting; 
    accessing = true; 
    System.out.println(me.getName()+" got a lock!"); 
    } 

    // Releases a lock to when a thread is finished 

    public synchronized void releaseLock() { 
     //release the lock and tell everyone 
     accessing = false; 
     notifyAll(); 
     Thread me = Thread.currentThread(); // get a ref to the current thread 
     System.out.println(me.getName()+" released a lock!"); 
    } 

} 

問題在哪裏？

Answer 1

你的'testVariable'應該被標記爲'volatile'。有關更多信息，請參閱此主題：Volatile Vs Static in java。