在Java中同步方法的正确方法

Question

我有一个示例课：

public class LocksAndSynchronization {

    private Object lock1 = new Object();
    private Object lock2 = new Object();

    static int count;

    public void methodOne() {

        for (int i = 1; i <= 10000; i++) {
            count++;
        }

    }

    public void methodTwo() {

        for (int i = 1; i <= 10000; i++) {
            count++;
        }

    }

    public synchronized void process() {
        methodOne();
        methodTwo();
    }

    public static void main(String[] args) throws InterruptedException {
        final LocksAndSynchronization l = new LocksAndSynchronization();
        Thread t1 = new Thread() {

            @Override
            public void run() {
                l.process();
            }

        };

        Thread t2 = new Thread() {

            @Override
            public void run() {
                l.process();
            }

        };


        t1.start();
        t2.start();

        t1.join();
        t2.join();


        System.out.println("count: " + count);

    }

}

process（）实际上同时调用了这两种方法。 那么哪种方法更好呢？

1. 同步methodOne和methodTwo或者，
2. 同步process() （如上面的代码所述）？

以上两个选项都可以使用。 但是，哪个更有意义？

Answer 1

count是静态的，因此所有对象都相同。 因此您需要同步处理静态方法。 为此，创建一个静态锁并使用它

static Object staticObject = new Object();
public void process() {
   synchronized( staticObject){
      methodOne();
      methodTwo();
   }
}

或者可以同步methodOne和methodTwo

static Object staticObject = new Object();
public void methodOne() {
    synchronized( staticObject){
      for (int i = 1; i <= 10000; i++) {
          count++;
      }
    }
}

public void methodTwo() {
    synchronized( staticObject){
      for (int i = 1; i <= 10000; i++) {
          count++;
      }
    }
}

此外，在函数声明中使用synchenize关键字，意味着将对象本身用作锁。 因此，如果您有多个对象，则您的块将根据对象进行同步。

Answer 2

我宁愿同步methodOne和methodTwo ，因为他们可以从对象外部调用。 也可以在不将其嵌入process情况下调用它们。 因此，每种方法应以线程安全的方式单独实现。

希望能有所帮助。

Answer 3

您的简化代码使您难以分辨问题的实质。 首先， count是静态的，因此无法在实例级别进行锁定，但这可能只是干扰因素。

更重要的考虑是methodOne和methodTwo ，两个公共方法，这显然需要同步，但没有做自己。 如果选择只同步的process方法，这意味着你都要求的所有其他呼叫者methodOne和methodTwo采取同步的适当的照顾，以及，它看起来像相当不稳定的设计。

而且，如果您不需要整个process都是原子的，并且可以分解为两个单独的原子步骤，那么遵循这些语义进行锁定就再自然不过了。 这取决于你是否将调用methodOne和methodTwo从aynwhere别人在你的程序。

Answer 4

建议尽可能少地同步代码，因为它会产生争用（其他线程正在等待）。 因此，方法1是可取的。

Answer 5

无论您是单独同步process还是单独同步任何方法，方法1和方法2之间仍然没有一致性（即，在这些调用之间不会更改变量count ）。 原因是变量count是静态的，因此即使在synchronized方法中使用它也不是线程安全的。

Answer 6

正如Adem所说，静态“计数”字段需要一个静态锁。 但是，这里存在更大的接口设计问题。 无论methodOne和methodTwo是公开的意思是，他们可以从任何其他类调用。 如果要求它们在同步上下文中执行，则建议它们都使用同步机制。

如果不是，此案methodOne和methodTwo是公开的，我更倾向于将要在更高的水平上进行的syncrhonisation（因为这会更有效和灵活的），即在process方法，然后穿上评论另两种指定必须从同步上下文中调用它们的方法。