用 synchronized 解决原子性问题

• 前言
• • synchronized 的用法
  • synchronized 的例子
  • synchronized 使用的注意点

原子性问题的源头在于线程切换，所以理论上禁止线程切换就能解决这个问题，在 Java 中已经提供了 synchronized 互斥锁来保证一个时刻只有一个线程可以执行，这边需要特别注意的是，synchronized 之所以叫互斥锁，是因为它不像读写锁可以做到读读并发，读写互斥。而是读是互斥，写也是互斥，只要有对象获取到锁以后，那后面的线程只能阻塞着。

当然，锁是用来保护资源的，为的就是被保护的这个资源不会同时被其他线程修改，那这个资源就是所谓的临界区。

我们常会看到下面这样的代码，其实就是 synchronized 加锁的一种体现，synchronized 加锁和解锁操作是Java 编译器自动加上的。

final Object object = new Object();  
void add() {  
    synchronized (object) {  
        // 临界区  
    }  
}

虽然 synchronized 的加锁和解锁是自动的，但是也要弄清楚，加锁和解锁的对象是谁。包含上面的例子，synchronized 一共有两种规则：

修饰静态方法的时候，相当于锁定整个 Class 对象
修饰非静态方法的时候，相对于锁定一个实例对象

• 修饰静态方法：修饰静态方法相当于给整个类加锁了。

Class A {
	synchronized(X.class) static void add() {  
	    // 临界区   
	}
}

• 修饰非静态方法：可以省略括号中的内容，相当于修饰对象实例。

Class A {
	synchronized(this) void add() {  
	    // 临界区   
	}
}

• 还有一个是修饰对象实例：

final Object object = new Object();  
void add() {  
    synchronized (object) {  
        // 临界区  
    }  
}

这边使用一个例子来讲述 synchronized 的具体用法。下面代码大家都知道，如果使用多线程执行，最后的结果肯定不是我们想要的，因为 add() 方法两个线程可以同时执行，在执行的时候并没有锁来保护这一整个方法是原子性操作的。

public class Test {  
  
    private int i = 0;  
  
    private int get() {  
        return i;  
    }  
  
    private void add() {  
        for (int a = 0; a < 10000; a++) {  
            i += 1;  
        }  
  
        System.out.println(this.get());  
    }  
  
    public static void main(String[] args) {  
        Test test = new Test();  
        Thread thread1 = new Thread(() -> {  
            test.add();  
        });  
  
        Thread thread2 = new Thread(() -> {  
            test.add();  
        });  
  
        thread1.start();  
        thread2.start();  
  
        try {  
            thread1.join();  
            thread2.join();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
}

这时候就需要对 add() 方法进行 synchronized 加锁，保证一个线程在执行 add() 方法的时候，另一个线程不会侵入这个方法，就能保证 add() 方法的原子性操作。

private synchronized void add() {  
    for (int a = 0; a < 10000; a++) {  
        i += 1;  
    }  
  
    System.out.println(this.get());  
}

在上面提到过，synchronized 既可以修饰静态方法，也可以非静态方法。如果现在有两个方法，一个是静态方法，另一个是非静态方法，并且两个方法都用 synchronized 进行加锁，这时候相当于获取了两把不同的锁，分别是 this 和 Test.class，所以 add() 和 addStatic() 两个临界区并没有互斥的关系，最终的结果就并不是目标结果。

public class Test {  
  
    private static int i = 0;  
  
    private int get() {  
        return i;  
    }  
  
    private synchronized static void addStatic() {  
        for (int a = 0; a < 10000; a++) {  
            i += 1;  
        }  
    }  
  
    private synchronized void add() {  
        for (int a = 0; a < 10000; a++) {  
            i += 1;  
        }  
    }  
  
    public static void main(String[] args) {  
        Test test = new Test();  
        Thread thread1 = new Thread(() -> {  
            test.add();  
        });  
  
        Thread thread2 = new Thread(() -> {  
            Test.addStatic();  
        });  
  
        thread1.start();  
        thread2.start();  
  
        try {  
            thread1.join();  
            thread2.join();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
  
        System.out.println(test.get());  
    }  
}

如果想要正确的结果，那只需要 synchronized 加锁的对象是同一个对象，这样就能保证两个方法互斥。

private synchronized void addStatic() {  
	for (int a = 0; a < 10000; a++) {  
		i += 1;  
	}  
}