非最终字段的同步

Question 1

每次我在非最终类别字段上进行同步时，都会显示警告。这是代码：

public class X  
{  
   private Object o;  

   public void setO(Object o)  
   {  
     this.o = o;  
   }  

   public void x()  
   {  
     synchronized (o) // synchronization on a non-final field  
     {  
     }  
   }  
 }

所以我通过以下方式更改了编码：

 public class X  
 {  

   private final Object o;       
   public X()
   {  
     o = new Object();  
   }  

   public void x()  
   {  
     synchronized (o)
     {  
     }  
   }  
 }

我不确定上面的代码是否是在非最终类字段上同步的正确方法。如何同步非最终字段？

Question 2

首先，我鼓励您真正尝试在更高的抽象级别上处理并发问题，即使用java.util.concurrent中的类（例如ExecutorServices，Callables，Futures等）来解决它。

话虽如此，在非最终字段上进行同步本身没有任何问题。您只需要记住，如果对象引用发生更改，则可以并行运行同一部分代码。即，如果一个线程在同步块中运行代码并且有人调用setO(...)，则另一个线程可以在同一实例上同时运行同一同步块。

同步需要独占访问的对象（或者更好的是，专用于保护它的对象）。

Question 3

这实际上不是一个好主意-因为您的同步块不再真正以一致的方式进行同步。

假设同步块旨在确保一次只有一个线程访问某些共享数据，请考虑：

线程1进入同步块。是的-它具有对共享数据的独占访问权...
线程2调用setO（）
线程3（或仍然是2 ...）进入同步块。ek！它认为它具有对共享数据的独占访问权，但是线程1仍在使用它...

您为什么要发生这种情况？也许在某些非常特殊的情况下这是有道理的……但是，在我满意之前，您必须向我展示一个特定的用例（以及减轻我上面给出的那种情况的方法）它。

Question 4

我同意John的评论之一：在访问非最终变量时，必须始终使用最终锁伪变量，以防止在变量的引用更改的情况下出现不一致。因此，在任何情况下，作为第一个经验法则：

规则1：如果字段为非最终字段，请始终使用（私有）最终锁定虚拟对象。

原因1：您持有锁并自己更改了变量的引用。在同步锁之外等待的另一个线程将能够进入受保护的块。

原因2：您持有锁，而另一个线程更改了变量的引用。结果是相同的：另一个线程可以进入受保护的块。

但是，当使用最终锁定虚拟对象时，还有另一个问题：您可能会得到错误的数据，因为非最终对象仅在调用sync（ize）对象时才与RAM同步。因此，作为第二个经验法则：

规则2：锁定非最终对象时，您始终需要执行以下两项操作：使用最终锁定伪对象和非最终对象的锁定以实现RAM同步。（唯一的选择是将对象的所有字段都声明为volatile！）

这些锁也称为“嵌套锁”。请注意，您必须始终以相同的顺序调用它们，否则将获得死锁：

public class X {
    private final LOCK;
    private Object o;

    public void setO(Object o){
        this.o = o;  
    }  

    public void x() {
        synchronized (LOCK) {
        synchronized(o){
            //do something with o...
        }
        }  
    }  
}

如您所见，我将两个锁直接写在同一行上，因为它们始终属于同一组。这样，您甚至可以做10个嵌套锁：

synchronized (LOCK1) {
synchronized (LOCK2) {
synchronized (LOCK3) {
synchronized (LOCK4) {
    //entering the locked space
}
}
}
}

请注意，如果您仅像synchronized (LOCK3)其他线程一样获得内部锁，则此代码不会中断。但是，如果您在另一个线程中调用如下代码，它将导致中断：

synchronized (LOCK4) {
synchronized (LOCK1) {  //dead lock!
synchronized (LOCK3) {
synchronized (LOCK2) {
    //will never enter here...
}
}
}
}

在处理非最终字段时，只有一种解决此类嵌套锁的方法：

规则2-替代：将对象的所有字段声明为volatile。（我不会在这里谈论这样做的缺点，例如，即使对于读取，也禁止在x级缓存中进行任何存储，例如aso。）

因此，aioobe是完全正确的：只需使用java.util.concurrent。或者开始了解有关同步的一切，并使用嵌套锁自己完成。;）

有关为什么非最终字段上的同步中断的更多详细信息，请查看我的测试用例：https : //stackoverflow.com/a/21460055/2012947

有关更多详细信息，为什么由于RAM和缓存而需要完全同步的原因，请在此处查看：https : //stackoverflow.com/a/21409975/2012947

Question 5

我在这里看不到正确的答案，也就是说，这样做是完全可以的。

我什至不知道为什么要警告，它没有错。JVM确保在读取值时获得一些有效的对象（或null），并且可以在任何对象上进行同步。

如果计划在使用锁时实际更改锁（而不是例如在开始使用锁之前从init方法更改锁），则必须制作要更改的变量volatile。然后，所有你需要做的是在同步两个旧的和新的对象，你可以放心地更改值

public volatile Object lock;

...

synchronized (lock) {
    synchronized (newObject) {
        lock = newObject;
    }
}

那里。这并不复杂，实际上，使用锁（互斥锁）编写代码非常容易。在没有它们的情况下编写代码（无锁代码）是很难的。

Question 6

编辑：因此，该解决方案（由乔恩·斯凯特（Jon Skeet）提出）可能会在对象引用更改时实现“ synchronized（object）{}”实现的原子性问题。我另外询问，根据埃里克森先生的说法，这不是线程安全的-请参阅：输入同步块是原子的吗？。因此，以它为例，如何不做-用链接为什么;）

查看代码，如果syncnised（）是原子的，它将如何工作：

public class Main {
    static class Config{
        char a='0';
        char b='0';
        public void log(){
            synchronized(this){
                System.out.println(""+a+","+b);
            }
        }
    }

    static Config cfg = new Config();

    static class Doer extends Thread {
        char id;

        Doer(char id) {
            this.id = id;
        }

        public void mySleep(long ms){
            try{Thread.sleep(ms);}catch(Exception ex){ex.printStackTrace();}
        }

        public void run() {
            System.out.println("Doer "+id+" beg");
            if(id == 'X'){
                synchronized (cfg){
                    cfg.a=id;
                    mySleep(1000);
                    // do not forget to put synchronize(cfg) over setting new cfg - otherwise following will happend
                    // here it would be modifying different cfg (cos Y will change it).
                    // Another problem would be that new cfg would be in parallel modified by Z cos synchronized is applied on new object
                    cfg.b=id;
                }
            }
            if(id == 'Y'){
                mySleep(333);
                synchronized(cfg) // comment this and you will see inconsistency in log - if you keep it I think all is ok
                {
                    cfg = new Config();  // introduce new configuration
                    // be aware - don't expect here to be synchronized on new cfg!
                    // Z might already get a lock
                }
            }
            if(id == 'Z'){
                mySleep(666);
                synchronized (cfg){
                    cfg.a=id;
                    mySleep(100);
                    cfg.b=id;
                }
            }
            System.out.println("Doer "+id+" end");
            cfg.log();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Doer X = new Doer('X');
        Doer Y = new Doer('Y');
        Doer Z = new Doer('Z');
        X.start();
        Y.start();
        Z.start();
    }

}

Question 7

AtomicReference适合您的要求。

从有关原子包的Java文档中：

一个小的类工具包，支持对单个变量进行无锁线程安全编程。本质上，此程序包中的类将易失值，字段和数组元素的概念扩展到也提供以下形式的原子条件更新操作的那些元素：

boolean compareAndSet(expectedValue, updateValue);

样例代码：

String initialReference = "value 1";

AtomicReference<String> someRef =
    new AtomicReference<String>(initialReference);

String newReference = "value 2";
boolean exchanged = someRef.compareAndSet(initialReference, newReference);
System.out.println("exchanged: " + exchanged);

在上面的示例中，您String用自己的替换Object