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

Question

我尝试锁定对象但没有结果

在这种情况下如何处理锁？

编辑：

基于 cmets，我决定不再使用代码发布问题。它不是要复制和粘贴然后运行并检查编译器所说的内容。

您不是专注于问题，而是人为地制造了一个问题，而不是面对我所面临的这个问题。

也许我应该使用写锁或重入锁来代替同步块...

我需要“手拉手”还是“链锁”？

甚至使用信号量？

EDIT2：

我有什么：

• 我得到了 object A，它对 X 保持引用，并得到了 getX 方法（返回 X）和 reset X(X=null)
• 我得到了 object X 和 字段 a,b,c

我做什么：

其他线程T：

• 通过 _x = A.getX() 引用 X
• 做一些改变_x.a
• 做一些改变_x.c
• /// 同时A决定重置X ///
• 做一些改变_x.b ...崩溃！

我想要达到的目标：

• 在 T 修改 X(_x) 时防止 A.resetX(null)

换句话说，当正在修改对象时，防止 object = null

我是否需要使用一些标志表明X是修改中？

我不想要的：

• 不断检查 if(X!=null)

与：

@downvoter：请注意解释您的投票！请

Answer 1

好的！我已经挖掘了足够的信息来为我的案例找到解决方案：

这里最好的方法是使用

接口ReadWriteLock由包java.util.concurrent.locks

提供

连同实施：

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

    }
}