关于同步方法的“Java™教程”:

首先，对同一对象的同步方法的两次调用不可能交织。当一个线程正在为一个对象执行同步方法时，所有为同一对象调用同步方法的其他线程将暂停执行，直到第一个线程处理完该对象。

关于同步块的“Java™教程”:

Synchronized statements are also useful for improving concurrency with fine-grained synchronization. Suppose, for example, class MsLunch has two instance fields, c1 and c2, that are never used together. All updates of these fields must be synchronized, but there's no reason to prevent an update of c1 from being interleaved with an update of c2 — and doing so reduces concurrency by creating unnecessary blocking. Instead of using synchronized methods or otherwise using the lock associated with this, we create two objects solely to provide locks.

(强调我的)

假设你有两个不交叉的变量。所以你想同时从不同的线程访问每一个。你不需要在对象类本身上定义锁，而是在类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++;
        }
    }
}

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

在方法中添加"synchronized"意味着运行代码的线程必须在继续之前获得对象上的锁。添加“static synchronized”意味着运行代码的线程必须在继续之前获取类对象上的锁。或者，你也可以像这样将代码封装在一个块中:

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

这样您就可以指定必须获取其锁的对象。

如果你想避免锁定包含对象，你可以选择:

使用指定不同锁的同步块 使a和b具有原子性(使用java.util.concurrent.atomic)

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

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

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

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

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

在java同步中，如果一个线程想要进入同步方法，它将获得该对象的所有同步方法的锁，而不仅仅是线程正在使用的一个同步方法。 因此，执行addA()的线程将获得对addA()和addB()的锁，因为两者都是同步的。因此具有相同对象的其他线程不能执行addB()。

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

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

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

class X {

private int a;
private int b;

public void addA(){
    a++;
}

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

也会起作用