锁定对象不会停止对其他线程的更改

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(); 

    } 
}