引言
线程安全是并发编程中的重要关注点，而造成线程安全问题的主要原因有两点：
- 存在共享数据（临界资源）；
- 存在多个线程共同操作共享数据；
因此为了解决这个问题，我们需要这样的一个方案，当存在多个线程操作共享数据时，需要确保同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理数据完后再进行操作，这就是我们所说的互斥锁，即能达到互斥访问目的的锁。也就是说当一个共享数据被当前正访问的线程加上互斥锁后，在同一时刻，其他线程只能处于等待的状态，直到当前线程处理完毕释放该锁。
在Java中，关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块。
synchronized的三种使用方式
- 修饰实例方法 - 作用于当前实例加锁，进入同步代码要获得当前实例的锁；
- 修饰静态方法 - 作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁；
- 修饰代码块 - 指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁；
synchronized作用于实例方法
所谓的实例对象锁，指的是用synchronized修饰实例对象中的实例方法，注意这里实例方法不包括静态方法。代码如下：
public class InstanceSync implements Runnable {
static int count = 0;
// synchronized修饰实例方法
private synchronized void inc() {
count++;
}
@Override
public void run() {
int i = 0;
while (i++ < 1000) {
inc();
}
}
public static void main(String[] args) throws InterruptedException {
InstanceSync instanceSync = new InstanceSync();
Thread t1 = new Thread(instanceSync);
Thread t2 = new Thread(instanceSync);
t1.start();
t2.start();
t1.join(); // 等待线程结束
t2.join(); // 等待线程结束
System.out.println(instanceSync.count);
}
}
运行结果为：
2000
Process finished with exit code 0
在上述代码中，我们开启了二个线程操作同一个共享的资源（变量count，由于count++不具备原子性（先读值，后写回一个新值，分二步），因此，我们对inc方法使用synchronized进行修饰，以便保证线程安全。
我们注意到synchronized修饰的是实例方法inc，在这种情况下，当前线程的锁便是实例对象instanceSync，（Java中的线程同步锁可以是任意对象）。
如果我们将代码改成如下：
public class InstanceSync implements Runnable {
static int count = 0;
// synchronized修饰实例方法
private synchronized void inc() {
count++;
}
@Override
public void run() {
int i = 0;
while (i++ < 1000) {
inc();
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new InstanceSync()); // 重新new一个实例
Thread t2 = new Thread(new InstanceSync()); // 重新new一个实例
t1.start();
t2.start();
t1.join(); // 等待线程结束
t2.join(); // 等待线程结束
System.out.println(count);
}
}
运行结果发现是一个小于2000的值，上述代码我们犯了一个错误，虽然我们使用了synchronized修饰了inc方法，但却new了两个不同的实例对象，这就意味着存在两个不同的实例对象锁，因此t1和t2都会进入各自的对象锁，即t1和t2使用了不同的锁，所以线程安全无法保证。
解决这种困境的方法是：将synchronized作用于静态的inc方法，这样的话，对象锁就是当前类对象，由于无论创建多少个实例对象，但对于类的对象拥有只有一个，所以这样的情况下对象锁就是唯一的。
下面我们看看如何使用将synchronized作用于静态的inc方法上。
synchronized作用于静态方法
当synchronized作用于静态方法时，其锁就是当前类的class对象锁。由于静态成员不专属于任何一个实例对象，是类成员，因此通过class对象锁可以控制静态成员的并发操作。
注意： 如果线程A调用一个实例对象的非 static synchronized方法，而线程B需要调用这个实例对象所属类的静态synchronized方法是被允许的，这不会发生互斥现象。原因是访问静态synchronized方法所占用的锁是当前类的class对象，而访问非静态synchronized方法占用的锁是当前实例对象锁，是两个不同的锁。代码如下:
public class InstanceSync implements Runnable {
static int count = 0;
// 作用于静态方法 synchronized修饰实例方法
private static synchronized void inc() {
count++;
}
@Override
public void run() {
int i = 0;
while (i++ < 1000) {
inc();
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new InstanceSync()); // 重新new一个实例
Thread t2 = new Thread(new InstanceSync()); // 重新new一个实例
t1.start();
t2.start();
t1.join(); // 等待线程结束
t2.join(); // 等待线程结束
System.out.println(count);
}
}
我们只是在inc方法前加了static，标识其为静态成员方法。运行结果，我们得到了一个2000的值，这个是我们预想到的。
synchronized同步代码块
我们除了使用关键字synchronized修饰实例方法和静态方法之外，还可以使用在同步代码块上。
在某些情况下，我们编写的方法体可能比较大，执行耗时比较长，而需要同步的代码又只有一小部分；如果直接对整个方法进行同步操作会发现得不偿失，此时我们可以使用同步代码块的方式对需要同步的代码进行包裹，同步代码块使用如下：
public class InstanceSync implements Runnable {
private String lockFlag = "lockFlag"; // 定义一个对象所
static int count = 0;
@Override
public void run() {
// 我这里是一个大的耗时操作,不需要同步,无线程安全
// ...
synchronized (lockFlag) {
int i = 0;
while (i++ < 1000) {
count++;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new InstanceSync()); // 重新new一个实例
Thread t2 = new Thread(new InstanceSync()); // 重新new一个实例
t1.start();
t2.start();
t1.join(); // 等待线程结束
t2.join(); // 等待线程结束
System.out.println(count);
}
}
从上面的代码看到，我们定义了一个锁对象lockFlag，如果你觉得单独再定义一个锁对象麻烦，你也可以这样:
// this，当前实例对象锁
synchronized(this) {
// ... 实现部分
}
或者
// class对象锁
synchronized(InstanceSync.class) {
// ... 实现部分
}
每次当线程进入synchronized包裹的代码块时，就会要求持有指定的对象锁，如果当前有其他线程正持有该对象锁，那么新到的线程就必须等待，这样就确保了每次只有一个线程执行count++操作。
扩展：synchronized锁重入
关键字synchronized拥有锁重入的功能，即在使用synchronized时，当一个线程得到一个对象锁后，再次请求此对象锁时是可以再次得到该对象锁的。
这也证明了在一个synchronized方法/块的内部调用本类的其他synchronized方法/块时，是永远可以得到锁的。
我们定义如下三个类：
Service.java
public class Service {
public synchronized void service1() {
System.out.println("--->service1");
service2();
}
public synchronized void service2() {
System.out.println("--->service2");
service3();
}
public synchronized void service3() {
System.out.println("--->service3");
service4();
}
public synchronized void service4() {
System.out.println("--->service4");
}
}
MyThread.java
public class MyThread extends Thread {
@Override
public void run() {
super.run();
Service service = new Service();
service.service1();
}
}
Run.java
public class Run {
public static void main(String[] args) {
MyThread t = new MyThread();
t.start();
}
}
执行代码，结果如下：
--->service1
--->service2
--->service3
--->service4
Process finished with exit code 0
可重入锁 - 即自己可以再次获取自己的内部锁。比如有一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。
可重入锁也支持在父子类继承的环境中
总结
对于synchronized的作用，关键看其持有的锁对象，只要你抓住了这个，你就不会有困扰。
网友评论