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

如果你将方法声明为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();
    }
}

从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()。

你可以像下面这样做。在这种情况下，您使用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++;
      }
   }
}

关于同步方法的“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++;
        }
    }
}

这个例子(虽然不是很漂亮)可以提供更多关于锁定机制的见解。如果incrementA是同步的，而incrementB没有同步，那么incrementB将尽快执行，但如果incrementB也是同步的，那么它必须“等待”incrementA完成，然后incrementB才能完成它的工作。

这两个方法都被调用到单个实例对象上，在这个例子中是:job，而“竞争”线程是aThread和main。

尝试在incrementB中使用'synchronized'和不使用它，你会看到不同的结果。如果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();
    }
}