是的，它将阻塞其他方法，因为synchronized方法应用于指向....的WHOLE类对象但无论如何，它只会在addA或addB方法中执行求和时阻塞其他线程的执行，因为当它完成…一个线程将释放对象，另一个线程将访问另一个方法，以此类推。

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

作为最后的注意，如果有一个'a'和'b'变量，而不仅仅是一个唯一的变量'a'或任何其他名称，没有必要同步这个方法，因为它是完全安全的访问其他var(其他内存位置)。

class X {

private int a;
private int b;

public void addA(){
    a++;
}

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

也会起作用

如果你将方法声明为synchronized(就像你通过输入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();
    }
}

Synchronized在方法声明上是语法糖:

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

在静态方法中，它是这样的语法糖:

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

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

这可能行不通，因为从Integer到int的装箱和自动装箱依赖于JVM，如果两个不同的数字在-128和127之间，很可能会被散列到相同的地址。

从oracle文档链接

使方法同步有两个效果:

First, it is not possible for two invocations of synchronized methods on the same object to interleave. When one thread is executing a synchronized method for an object, all other threads that invoke synchronized methods for the same object block (suspend execution) until the first thread is done with the object. Second, when a synchronized method exits, it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object. This guarantees that changes to the state of the object are visible to all threads

看看这个文档页，了解内在锁和锁的行为。

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

如果你有一些方法没有同步，并且正在访问和改变实例变量。在你的例子中:

 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。