Java同步方法锁定对象或方法？

Question

如果我在同一个类中有 2 个同步方法，但每个方法访问不同的变量，那么 2 个线程可以同时访问这 2 个方法吗？锁定发生在对象上，还是与同步方法内的变量一样具体？

示例：

class X {

    private int a;
    private int b;

    public synchronized void addA(){
        a++;
    }

    public synchronized void addB(){
        b++;
    }

}

2 个线程可以访问类 X 的同一个实例，同时执行 x.addA() 和 x.addB() 吗？

Answer 1

如果您将该方法声明为同步（正如您通过键入public synchronized void addA()所做的那样），您将在整个对象上进行同步，因此，从同一对象访问不同变量的两个线程无论如何都会互相阻塞。

如果您只想一次只同步一个变量，这样两个线程在访问不同变量时就不会互相阻塞，那么您可以在 synchronized() 块中分别对它们进行同步。如果 a 和 b 是您将使用的对象引用：

public void addA() {
    synchronized( a ) {
        a++;
    }
}

public void addB() {
    synchronized( b ) {
        b++;
    }
}

但由于它们是基元，您不能这样做。

我建议您使用 AtomicInteger 代替：

import java.util.concurrent.atomic.AtomicInteger;

class X {

    AtomicInteger a;
    AtomicInteger b;

    public void addA(){
        a.incrementAndGet();
    }

    public void addB(){ 
        b.incrementAndGet();
    }
}

Answer 2

Synchronized 在方法声明上是这样的语法糖：

 public void addA() {
     synchronized (this) {
          a++;
     }
  }

在静态方法上，它是这样的语法糖：

 ClassA {
     public static void addA() {
          synchronized(ClassA.class) {
              a++;
          }
 }

我认为如果 Java 设计者知道现在对同步的理解，他们就不会添加语法糖，因为它更常见而不是导致并发的糟糕实现。

Answer 3

来自“Java™ 教程”中的同步方法：

首先，同一对象上的同步方法的两次调用不可能交错。当一个线程正在执行对象的同步方法时，调用同一对象的同步方法的所有其他线程都会阻塞（挂起执行），直到第一个线程完成该对象。

来自同步块的“Java™教程”：

同步语句对于通过细粒度同步提高并发性也很有用。例如，假设类 MsLunch 有两个实例字段 c1 和 c2，它们从不一起使用。这些字段的所有更新都必须同步，但是没有理由阻止 c1 的更新与 c2 的更新交错 - 这样做会通过创建不必要的阻塞来减少并发性。 我们不使用同步方法或以其他方式使用与此相关的锁，而是创建两个对象来提供锁。

（强调我的）

假设您有 2 个非交错变量。因此，您希望同时从不同的线程访问每一个。您需要不在对象类本身上定义锁，而是在Object类上定义锁，如下所示（来自第二个Oracle链接的示例）：

public class MsLunch {

    private long c1 = 0;
    private long c2 = 0;

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

    public void inc1() {
        synchronized(lock1) {
            c1++;
        }
    }

    public void inc2() {
        synchronized(lock2) {
            c2++;
        }
    }
}

Answer 4

访问的锁位于对象上，而不是方法上。在方法内访问哪些变量是无关紧要的。

在方法中添加“同步”意味着运行代码的线程必须先获取对象的锁，然后才能继续。添加“静态同步”意味着运行代码的线程必须获取类对象上的锁才能继续。或者，您可以将代码包装在如下所示的块中：

public void addA() {
    synchronized(this) {
        a++;
    }
}

以便您可以指定必须获取其锁的对象。

您可以选择：

• 使用指定不同锁的同步块
• 如果您想避免锁定包含的对象， 原子（使用 java.util.concurrent.atomic）

Answer 5

来自oracle文档链接

使方法同步有两个效果：

首先，同一对象上的同步方法的两次调用不可能交错。当一个线程正在执行对象的同步方法时，调用同一对象的同步方法的所有其他线程都会阻塞（挂起执行），直到第一个线程完成该对象。

其次，当同步方法退出时，它会自动与同一对象的同步方法的任何后续调用建立发生之前关系。这保证了对象状态的更改对所有线程都可见

请查看此文档 页面了解内在锁和锁行为。

这将回答您的问题：在同一个对象 x 上，当其中一个同步方法执行正在进行时，您不能同时调用 x.addA() 和 x.addB() 。

Answer 6

如果您有一些未同步的方法并且正在访问和更改实例变量。在您的示例中：

 private int a;
 private int b;

当其他线程处于同一对象的同步方法中并且可以更改实例变量时，任意数量的线程都可以同时访问这些非同步方法。
例如：-

 public void changeState() {
      a++;
      b++;
    }

您需要避免非同步方法访问实例变量并更改它的情况，否则没有必要使用同步方法。

在下面的场景中：-

class X {

        private int a;
        private int b;

        public synchronized void addA(){
            a++;
        }

        public synchronized void addB(){
            b++;
        }
     public void changeState() {
          a++;
          b++;
        }
    }

只有一个线程可以进入 addA 或 addB 方法，但同时任意数量的线程可以进入 changeState 方法。没有两个线程可以同时进入 addA 和 addB （因为对象级锁定），但同时任意数量的线程可以进入changeState。

Answer 7

这个例子（虽然不是很好）可以让我们更深入地了解锁定机制。如果incrementA已同步，而incrementB未同步，则incrementB将为尽快执行，但如果 incrementB 也同步，那么它必须在 incrementB 之前“等待”incrementA 完成> 可以完成其工作。

这两种方法都被调用到单个实例 - 对象，在本例中它是：job，“竞争”线程是aThread和main。

尝试在 incrementB 中使用“同步”，如果不使用它，您将看到不同的结果。如果 incrementB 是“同步” ' 那么它也必须等待 incrementA() 完成。每个变体运行几次。

class LockTest implements Runnable {
    int a = 0;
    int b = 0;

    public synchronized void incrementA() {
        for (int i = 0; i < 100; i++) {
            this.a++;
            System.out.println("Thread: " + Thread.currentThread().getName() + "; a: " + this.a);
        }
    }

    // Try with 'synchronized' and without it and you will see different results
    // if incrementB is 'synchronized' as well then it has to wait for incrementA() to finish

    // public void incrementB() {
    public synchronized void incrementB() {
        this.b++;
        System.out.println("*************** incrementB ********************");
        System.out.println("Thread: " + Thread.currentThread().getName() + "; b: " + this.b);
        System.out.println("*************** incrementB ********************");
    }

    @Override
    public void run() {
        incrementA();
        System.out.println("************ incrementA completed *************");
    }
}

class LockTestMain {
    public static void main(String[] args) throws InterruptedException {
        LockTest job = new LockTest();
        Thread aThread = new Thread(job);
        aThread.setName("aThread");
        aThread.start();
        Thread.sleep(1);
        System.out.println("*************** 'main' calling metod: incrementB **********************");
        job.incrementB();
    }
}

Answer 8

您可以执行以下操作。在这种情况下，您使用 a 和 b 上的锁来同步，而不是“this”上的锁。我们不能使用 int，因为原始值没有锁，所以我们使用 Integer。

class x{
   private Integer a;
   private Integer b;
   public void addA(){
      synchronized(a) {
         a++;
      }
   }
   public synchronized void addB(){
      synchronized(b) {
         b++;
      }
   }
}

Answer 9

是的，它会阻止其他方法，因为同步方法适用于所指出的整个类对象......但无论如何，它只会在执行以下操作时仅阻止其他线程执行sum 在它进入的任何方法 addA 或 addB 中，因为当它完成时......一个线程将释放对象，另一个线程将访问另一个方法，依此类推，完美工作。

我的意思是“同步”正是为了阻止另一个线程在特定代码执行中访问另一个线程。所以最后这段代码可以正常工作了。

最后一点，如果存在“a”和“b”变量，而不仅仅是唯一变量“a”或任何其他名称，则无需同步此方法，因为访问其他 var（其他内存）是完全安全的地点）。

class X {

private int a;
private int b;

public void addA(){
    a++;
}

public void addB(){
    b++;
}}

也会发挥作用

Answer 10

在Java同步中，如果一个线程想要进入synchronized方法/块，它将获取以下锁：

• 此对象<的所有同步非静态方法。 /strong>
  不仅在一个同步方法上，线程还使用
• 此类的所有同步静态方法，

因此线程将调用同步方法addA() 将获取 addA() 和 addB() 上的锁，因为两者都是同步的。
因此具有相同对象的其他线程无法执行addB()。

Answer 11

这可能不起作用，因为从 Integer 到 int 的装箱和自动装箱（反之亦然）取决于 JVM，并且如果两个不同的数字在 -128 到 127 之间，则它们很可能会被散列到相同的地址。