为什么同步块比同步方法更好？

Question

我已经开始学习线程同步了。

同步方式：

public class Counter {

   private static int count = 0;

   public static synchronized int getCount() {
      return count;
   }

   public synchronized setCount(int count) {
      this.count = count;
   }

}

同步块：

public class Singleton {

   private static volatile Singleton _instance;

   public static Singleton getInstance() {
      if (_instance == null) {
         synchronized(Singleton.class) {
            if (_instance == null)
               _instance = new Singleton();
         }
      }
      return _instance;
   }
}

什么时候应该使用synchronized 方法和synchronized 块？

为什么synchronized 块比synchronized 方法更好？

Answer 1

同步块和同步方法之间的一个典型区别是同步方法锁定整个对象。同步块只是将代码锁定在块内。

同步方法：基本上这两种同步方法禁用多线程。所以一个线程完成method1()，另一个线程等待Thread1完成。

类 SyncExerciseWithSyncMethod {

public synchronized void method1() {
    try {
        System.out.println("In Method 1");
        Thread.sleep(5000);
    } catch (Exception e) {
        System.out.println("Catch of method 1");
    } finally {
        System.out.println("Finally of method 1");
    }

}

public synchronized void method2() {
    try {
        for (int i = 1; i < 10; i++) {
            System.out.println("Method 2 " + i);
            Thread.sleep(1000);
        }
    } catch (Exception e) {
        System.out.println("Catch of method 2");
    } finally {
        System.out.println("Finally of method 2");
    }
}

}

输出

在方法一中

方法一的最后

方法2 1

方法2 2

方法2 3

方法2 4

方法2 5

方法2 6

方法2 7

方法2 8

方法2 9

方法二的最后

---

同步块：允许多个线程同时访问同一个对象[启用多线程]。

类 SyncExerciseWithSyncBlock {

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

public void method1() {
    synchronized (lock1) {
        try {
            System.out.println("In Method 1");
            Thread.sleep(5000);
        } catch (Exception e) {
            System.out.println("Catch of method 1");
        } finally {
            System.out.println("Finally of method 1");
        }
    }

}

public void method2() {

    synchronized (lock2) {
        try {
            for (int i = 1; i < 10; i++) {
                System.out.println("Method 2 " + i);
                Thread.sleep(1000);
            }
        } catch (Exception e) {
            System.out.println("Catch of method 2");
        } finally {
            System.out.println("Finally of method 2");
        }
    }
}

}

输出

在方法一中

方法2 1

方法2 2

方法2 3

方法2 4

方法2 5

方法一的最后

方法2 6

方法2 7

方法2 8

方法2 9

方法二的最后

Answer 2

区别在于获取的是哪个锁：

• 同步方法获取整个对象的锁。这意味着当方法由一个线程运行时，没有其他线程可以使用整个对象中的任何同步方法。

• 同步块在同步关键字之后的括号之间的对象中获取锁。这意味着在同步块退出之前，没有其他线程可以获取锁定对象上的锁。

因此，如果您想锁定整个对象，请使用同步方法。如果您想保持对象的其他部分可供其他线程访问，请使用同步块。

如果你仔细选择锁定的对象，同步块将导致更少的争用，因为整个对象/类没有被阻塞。

这同样适用于静态方法：同步的静态方法将在整个类对象中获取锁，而静态方法中的同步块将在括号之间的对象中获取锁。

Answer 3

同步块和同步方法的区别如下：

1. 同步块减少了锁的范围，但是同步方法的锁范围是整个方法。
2. 同步块具有更好的性能，因为只有关键部分被锁定但是同步方法的性能比块差。
3. 同步块提供对锁的精细控制但同步方法锁在此表示的当前对象或类级别锁上。
4. 同步块可以抛出 NullPointerException 但同步方法不会抛出。

5. 同步块： synchronized(this){}

   同步方法： public synchronized void fun(){}

Answer 4

这不应该被认为是最适合使用的问题，但它确实取决于用例或场景。

同步方法

可以将整个方法标记为同步，从而对 this 引用（实例方法）或类（静态方法）产生隐式锁定。这是实现同步的非常方便的机制。

步骤 线程访问同步方法。它隐式获取锁并执行代码。 如果其他线程想要访问上述方法，它必须等待。线程无法获得锁，将被阻塞，必须等待锁被释放。

同步块

要为一组特定的代码块获取对象锁定，同步块是最合适的。由于一个块就足够了，使用同步方法将是一种浪费。

更具体地说，使用同步块，可以定义要获取锁的对象引用。

Answer 5

虽然通常不是问题，但从安全角度来看，最好在私有对象上使用同步，而不是将其放在方法上。

将它放在方法上意味着您正在使用对象本身的锁来提供线程安全。使用这种机制，您的代码的恶意用户也有可能获得您对象的锁定，并永久持有它，从而有效地阻塞其他线程。非恶意用户可以在不经意间有效地做同样的事情。

如果您使用私有数据成员的锁，则可以防止这种情况发生，因为恶意用户不可能获得您私有对象的锁。

private final Object lockObject = new Object();

public void getCount() {
    synchronized( lockObject ) {
        ...
    }
}

在 Bloch 的 Effective Java (2nd Ed)，Item #70 中提到了这种技术

Answer 6

因为锁很昂贵，所以当你使用同步块时，只有在_instance == null 时才会锁定，而在_instance 最终初始化之后，你将永远不会锁定。但是，当您在方法上同步时，您会无条件锁定，即使在 _instance 初始化之后也是如此。这就是双重检查锁定优化模式http://en.wikipedia.org/wiki/Double-checked_locking 背后的思想。

Answer 7

同步的应该只在你希望你的类是线程安全的时候使用。事实上，大多数类无论如何都不应该使用同步。 同步方法只会在这个对象上提供一个锁，并且只在其执行期间。如果你真的想让你的类线程安全，你应该考虑让你的变量 volatile 或 synchronize 访问。

使用同步方法的一个问题是类的所有成员都会使用相同的锁，这会使你的程序变慢。在您的情况下，同步方法和块将执行没有什么不同。我会建议使用专用的锁并使用类似的同步块。

public class AClass {
private int x;
private final Object lock = new Object();     //it must be final!

 public void setX() {
    synchronized(lock) {
        x++;
    }
 }
}

Answer 8

定义“更好”。同步块更好，因为它允许您：

1. 在不同的对象上同步
2. 限制同步范围

现在您的具体示例是一个可疑的 double-checked locking 模式示例（在较旧的 Java 版本中它被破坏了，而且很容易出错）。

如果您的初始化成本较低，最好立即使用 final 字段进行初始化，而不是在第一次请求时进行初始化，这样也无需同步。

Answer 9

在你的情况下两者是等价的！​​strong>

同步一个静态方法相当于在对应的Class对象上同步一个块。

其实当你声明一个同步的静态方法时，锁是在类对象对应的监视器上获得的。

public static synchronized int getCount() {
    // ...
}

与

相同

public int getCount() {
    synchronized (ClassName.class) {
        // ...
    }
}

Answer 10

不是更好，只是不同。

当你同步一个方法时，你实际上是在同步到对象本身。在静态方法的情况下，您正在同步到对象的类。所以下面两段代码的执行方式相同：

public synchronized int getCount() {
    // ...
}

这就像你写的一样。

public int getCount() {
    synchronized (this) {
        // ...
    }
}

如果您想控制与特定对象的同步，或者您只想将方法的部分同步到该对象，则指定synchronized 块。如果在方法声明中使用synchronized关键字，它会将整个方法同步到对象或类。