用 synchronized 解决原子性问题
前言
原子性问题的源头在于线程切换,所以理论上禁止线程切换就能解决这个问题,在 Java 中已经提供了 synchronized 互斥锁来保证一个时刻只有一个线程可以执行,这边需要特别注意的是,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 的例子
这边使用一个例子来讲述 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 既可以修饰静态方法,也可以非静态方法。如果现在有两个方法,一个是静态方法,另一个是非静态方法,并且两个方法都用 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;
}
}