鎖定對象不會停止對其他線程的更改

Question

i'v試圖鎖定對象但無結果

如何在此情況下處理鎖定？

編輯：根據意見，我決定不發佈的代碼問題了

。這不是要複製和粘貼然後運行並檢查編譯器說什麼。

與其將問題集中在人爲造成的問題上，而不是面對我所面對的問題。

而是synchronized塊也許我應該用寫鎖或重入鎖...

我是否需要「交接手」或「鏈鎖定」？

甚至使用信號量？

EDIT2：

我有什麼：

• 我得到對象的這持有refrence到X，並得到方法的getX（返程X）& 復位 X（X = null）
• 我得到對象X與字段A，B，C

我做什麼：

其他線程T：

• 通過採用參考X _x = A .getX（）
• 做一些東西改變_x.a
• 做一些東西改變_x.c
• /// 在同時，一個決定重設X ///
• 做一些東西改變_x.b ...崩潰！

什麼我想要實現：

• 防止A.resetX（空），而T被modyfiing X（_x）

換言之，以防止物體

= NULL而有修改正在進行到對象

做我需要使用一些標誌指示該X是修改？

什麼，我不想：

@downvoter：護理

• 如果（！X = NULL）

不斷檢查解釋你的投票！請

Answer 1

好的！我已經挖了足夠的信息來獲取解決方案，我的情況：

這裏最好的方法是使用由包提供的java.util.concurrent.locks

接口ReadWriteLock中

連同執行：

ReentrantReadWriteLoc

這裏是 「簡單」 的樣本例如：

/** 
* define modifiable dog 
*/ 
public class Dog { 

    private ReadWriteLock _dogLock; 
    private String _name; 

    public Dog(ReadWriteLock dogLock) { 
     _dogLock = dogLock; 
    } 

    public Lock dogChangesLock() { 
     return _dogLock.writeLock(); 
    } 

    public void setName(String name) { 
     _dogLock.writeLock().lock(); 
     try { 
      _name = name; 
     } finally { 
      _dogLock.writeLock().unlock(); 
     } 
    } 

    public String getName() { 
     _dogLock.readLock().lock(); 
     try { 
      return _name; 
     } finally { 
      _dogLock.readLock().unlock(); 
     } 
    } 
} 

/** 
* holder class for dog handling 
*/ 
public class Holder { 

    private Dog _dog; 

    /** 
    * EURECA! this is what we want to use 
    */ 
    private ReadWriteLock _dogLock = new ReentrantReadWriteLock(); 

    /** 
    * get dog 
    */ 
    public Dog getDog() { 
     _dogLock.readLock().lock(); 
     try { 
      if (_dog == null) { 
       _dog = new Dog(_dogLock); 
      } 
      return _dog; 
     } finally { 
      _dogLock.readLock().unlock(); 
     } 
    } 

    /** 
    * utilize dog :) 
    */ 
    private void resetDog() { 
     _dogLock.readLock().lock(); 
     try { 
      _dog = null; 
     } finally { 
      _dogLock.writeLock().unlock(); 
     } 
    } 
} 

/** 
* test class for simultaneous write/read 
*/ 
public class Concurent { 

    Holder holder = new Holder(); 

    /** 
    * run concurrent threads 
    */ 
    private void test() { 

     /** thread for dog modification */ 
     new Thread(new Runnable() { 

      /** thread to utilize dog :) */ 
      final Thread resetThread = new Thread(new Runnable() { 
       @Override 
       public void run() { 
        holder.resetDog(); 
       } 
      }); 

      /** main method */ 
      @Override 
      public void run() { 

       /** get dog */ 
       Dog dog = holder.getDog(); 

       /** get lock for write */ 
       dog.dogChangesLock().lock(); 

       try { 

        /** modifies dog */ 
        dog.setName("Cat"); 

        /** call to reset dog */ 
        resetThread.start(); 

        /** 
        * SAFE TO CALL SECOND TIME 
        * we don't need to check if dog was altered 
        * as we got write lock 
        * */ 
        dog.setName("Elephant"); 

       } finally { 
        dog.dogChangesLock().unlock(); 
       } 
      } 
     }).start(); 

    } 
}