我们是否同步最终的实例变量？如果是的话有什么用？

Question

我想知道我们是否同步最终的实例变量。由于变量是最终变量，因此值不能更改。 有人能解释一下吗？

Answer 1

我们是否同步最终的实例变量？

是的。你还是要同步可变对象

final != immutable

 public class Something {
     private final List list = new ArrayList();

     public void add( String value ) {
         this.list.add( value );
     }
     public int count() {
          return this.list.size();
     }
 }

稍后

 Something s = new Something();

 Thread a = new Thread() {
    public void run(){
       s.add( "s" );
       s.add( "s" );
       s.add( "s" );
     }
 };
 Thread b = new Thread(){
     public void run() {
         s.count();
         s.count();
     }
 };

 a.start();
 b.start();

如果是的话有什么用？

您声明，给定的属性在对象生命周期内不能更改。

这提高了安全性（您的对象属性不能被恶意子类替换）
允许编译器优化（因为它知道只会使用引用）
防止子类更改它等等。

既是最终属性又是不可变属性（如字符串、整数等）不需要同步。

class X {
    private final String name = "Oscar";

    public int nameCount(){
        return this.name.length(); //<-- Will return 5 ALWAYS ( actually the compiler might inline it 
    }
 }

Answer 2

一个重要的例外：final 字段在对象构造后无法修改，但一旦对象构造完毕，就可以通过非同步方法安全地读取

取自 同步方法

Answer 3

如果访问器方法返回最终变量的值，您通常不会将其标记为“同步”；例如，

private final String message = "Hello, World";

// No need to mark as synchronized as message can never change.
public String getMessage() {
  return message;
}

但是，您可能希望同步最终变量，例如，如果您将其用作锁；例如

private final Object lock;

...

synchronized(lock) {
  // Do something in critical section.
}

Answer 4

如果实例变量不是不可变的，那么即使该变量是最终变量，其状态仍然可以更改。举个例子：

private final List<Foo> foos = new ArrayList<Foo>();


public void addFoo(Foo newFoo){
      foos.add(newFoo);
}

public Foo popFoo(){
     return foos.remove(0);
}

在这种情况下，即使 foos 是最终的，当线程 A 尝试删除元素时，线程 B 也可以添加 Foo，这可能会导致一致状态。

其他示例中提到的同步方法教程是正确的，因为读取最终变量不需要同步。但是，如果变量是可变的（如 List 那样），则必须同步对该变量的写入，以保证“发生之前”关系。但是，如果变量是不可变的，那么当然不允许对该变量进行写入，因此不需要同步。

Answer 5

嗯，是的。当您使用引用类型声明最终实例变量时，该引用是不可变的，但它引用的对象通常是可变的。如果可能有多个线程访问和更新可变对象的状态，则需要同步对最终实例的操作。

例如：

public class Thing {
   private final List l1 = 
   private final List l2 = 
   private final List l3 = 

   ...

   public void l1ToL2() {
       l2.add(l1.removeFirst());
   }

   public void l2ToL3() {
       l3.add(l2.removeFirst());
   }
}

如果我们不采取措施来同步这些方法对 l1、l2 和 l3 的使用，那么它们就不是线程安全的，并且来自不同线程的并发操作可能会损坏列表。

另一方面，由于 @Anthony Forloney 的回答中所述的原因，这是线程安全的。

public class Thing {
   private final int i = ... ;

   public int getI() {
       return i;
   }
}

Answer 6

无需同步对最终实例变量的访问。

请参阅 http://java.sun.com/docs/books /tutorial/essential/concurrency/syncmeth.html

同步方法启用了一种防止线程干扰和内存一致性错误的简单策略：如果一个对象对多个线程可见，则对该对象变量的所有读取或写入都会完成通过同步方法。 （一个重要的例外：final 字段在对象构造后无法修改，一旦构造了对象，就可以通过非同步方法安全地读取）这种策略是有效的，但可能会带来活性问题，因为我们将请参阅本课稍后内容。