Java中哪些情况需要同步方法访问？

Question

在什么情况下需要同步对实例成员的访问？ 我知道对类的静态成员的访问总是需要同步 - 因为它们在类的所有对象实例之间共享。

我的问题是，如果我不同步实例成员，我什么时候会出错？

例如，如果我的班级是

public class MyClass {
    private int instanceVar = 0;

    public setInstanceVar()
    {
        instanceVar++;
    }

    public getInstanceVar()
    {
        return instanceVar;
    }
}

在什么情况下（使用 MyClass 类）我需要拥有方法： public synchronized setInstanceVar() 和 public synchronized getInstanceVar()?

提前感谢您的回答。

Answer 1

这取决于你是否希望你的类是线程安全的。大多数类不应该是线程安全的（为简单起见），在这种情况下您不需要同步。如果您需要它是线程安全的，您应该同步访问或使变量可变。 （它避免了其他线程获取“陈旧”数据。）

Answer 2

在 Java 中，对 int 的操作是原子的，所以不，在这种情况下，如果您一次只进行 1 次写入和 1 次读取，则不需要同步。

如果这些是 long 或 double，您确实需要同步，因为可能会更新 long/double 的一部分，然后读取另一个线程，最后更新 long/double 的另一部分。

Answer 3

如果你想让这个类线程安全，我会将instanceVar 声明为volatile，以确保你总是从内存中获得最新的值，而且我会创建setInstanceVar() synchronized，因为在JVM增量不是原子操作。

private volatile int instanceVar =0;

public synchronized setInstanceVar() { instanceVar++;

}

Answer 4

。粗略地说，答案是“视情况而定”。在这里同步你的 setter 和 getter 只会有保证多个线程无法读取彼此之间的变量增量操作的预期目的：

 synchronized increment()
 { 
       i++
 }

 synchronized get()
 {
   return i;
  }

但这在这里根本行不通，因为要确保您的调用者线程获得与它递增的相同的值，您必须保证您是原子递增然后检索，而您在这里没有这样做- 即你必须做类似的事情

  synchronized int {
    increment
    return get()
  }

基本上，同步对于定义需要保证运行线程安全的操作很有用（换句话说，您不能创建一个单独的线程破坏您的操作并使您的类行为不合逻辑或破坏您期望的状态的情况的数据）。这实际上是一个比这里可以解决的更大的话题。

这本书 Java Concurrency in Practice 非常好，而且肯定比我可靠得多。

Answer 5

synchronized 修饰符确实是一个坏的想法，应该不惜一切代价避免。我认为 Sun 尝试让锁定更容易实现是值得称道的，但 synchronized 只会带来更多的麻烦而不值得。

问题在于synchronized 方法实际上只是获取this 上的锁定并在方法执行期间持有它的语法糖。因此，public synchronized void setInstanceVar() 将等同于如下内容：

public void setInstanceVar() {
    synchronized(this) {
        instanceVar++;
    }
}

这很糟糕有两个原因：

• 同一类中的所有 synchronized 方法使用完全相同的锁，这会降低吞吐量
• 任何人都可以访问锁，包括其他类的成员。

没有什么可以阻止我在另一个班级做这样的事情：

MyClass c = new MyClass();
synchronized(c) {
    ...
}

在synchronized 块内，我持有MyClass 中所有synchronized 方法所需的锁。这进一步降低了吞吐量并显着增加了死锁的机会。

更好的方法是拥有一个专用的lock 对象并直接使用synchronized(...) 块：

public class MyClass {
    private int instanceVar;
    private final Object lock = new Object();     // must be final!

    public void setInstanceVar() {
        synchronized(lock) {
            instanceVar++;
        }
    }
}

或者，您可以使用java.util.concurrent.Lock 接口和java.util.concurrent.locks.ReentrantLock 实现来达到基本相同的结果（实际上在Java 6 上也是如此）。

Answer 6

简单地说，当您有多个线程访问同一实例的同一方法时，您使用同步，这将改变对象/或应用程序的状态。

它是一种防止线程之间竞争条件的简单方法，实际上您应该只在计划让并发线程访问同一个实例（例如全局对象）时使用它。

现在，当您使用并发线程读取对象实例的状态时，您可能需要查看 java.util.concurrent.locks.ReentrantReadWriteLock——理论上它允许同时读取多个线程, 但只允许一个线程写入。因此，在每个人似乎都在给出的 getter 和 setting 方法示例中，您可以执行以下操作：

public class MyClass{
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    private int myValue = 0;

    public void setValue(){
        rwl.writeLock().lock();
        myValue++;
       rwl.writeLock().unlock();
    }

    public int getValue(){
       rwl.readLock.lock();
       int result = myValue;
       rwl.readLock.unlock();
       return result;
    }
}