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

Question

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

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

例如，如果我的类

public class MyClass {
    private int instanceVar = 0;

    public setInstanceVar()
    {
        instanceVar++;
    }

    public getInstanceVar()
    {
        return instanceVar;
    }
}

在什么情况下（使用类MyClass）我需要有方法： 公共同步setInstanceVar()和 公共同步 getInstanceVar() ？

预先感谢您的回答。

Answer 1

synchronized 修饰符确实是一个坏主意，应该不惜一切代价避免。 我认为值得赞扬的是，Sun 试图使锁定更容易实现，但同步只会带来更多的麻烦，而不是其价值。

问题在于，synchronized 方法实际上只是用于获取 this 锁定并在方法执行期间保持锁定的语法糖。 因此，公共同步无效 setInstanceVar() 相当于这样：

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

这很糟糕，原因有两个：

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

没有什么可以阻止我在另一个类中执行类似的操作：

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

在该 synchronized 块中，我持有 中所有 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 2

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

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并发实践非常好，而且肯定比我可靠得多。

Answer 5

简而言之，当多个线程访问同一实例的同一方法（这将改变对象/或应用程序的状态）时，您可以使用同步。

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

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

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;
    }
}

Answer 6

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

如果这些是长整型或双精度型，则确实需要同步，因为长整型/双精度型的一部分可能会被更新，然后有另一个线程读取，最后长整型/双精度型的另一部分会被更新。