synchronized的三种应用方式（实例讲解）

前言

    上一节（Java内存模型-volatile的应用（实例讲解)）讲了i++并不是线程安全的，我们需要用synchronized来保证其线程安全。

    这里我就介绍下synchronized的基本用法和简单原理。

    便于说明，我写了个i++的例子：

public class AddI {
    public static volatile int i = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> add(1000000));
        Thread t2 = new Thread(() -> add(1000000));

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(i);
    }

    public static void add(int n) {
        for (int m = 0; m < n; m++) {
            i++;
        }
    }
}

---

1、什么时候加锁呢？

    没有共享就没有伤害，比如上面的i++被2个线程同时修改，出现了并发问题。此时我们就需要进行加锁。

    如果一个变量没有共享，且没有并发问题，那加锁只会降低程序的性能。

    线程安全是并发编程中的重要关注点，应该注意到的是，造成线程安全问题的主要诱因有两点，一是存在共享数据(也称临界资源)，二是存在多条线程共同操作共享数据。
    因此为了解决这个问题，我们可能需要这样一个方案，当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行，这种方式有个高尚的名称叫互斥锁，即能达到互斥访问目的的锁，也就是说当一个共享数据被当前正在访问的线程加上互斥锁后，在同一个时刻，其他线程只能处于等待的状态，直到当前线程处理完毕释放该锁。
    在 Java 中，关键字 synchronized可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作)，同时我们还应该注意到synchronized另外一个重要的作用，synchronized可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到（保证可见性，完全可以替代Volatile功能），这点确实也是很重要的。

---

2、Synchronized三种应用方式

常见的用法：

class X {
    // 方式一：修饰非静态方法
    synchronized void foo() {
        // 临界区
    }
    // 方式二：修饰静态方法
    synchronized static void bar() {
        // 临界区
    }
    // 方式三：修饰代码块
    Object obj = new Object()；
    void baz() {
        synchronized(obj) {
            // 临界区
        }
    }
} 

    在java里面使用synchronized，加锁lock和解锁unlock这2个操作是Java默认加上的，Java 编译器会在 synchronized 修饰的方法或代码块前后自动加上加锁 lock() 和解锁 unlock()，这样做的好处就是加锁 lock() 和解锁 unlock() 一定是成对出现的，毕竟忘记解锁 unlock() 可是个致命的 Bug。

    那 synchronized 里的加锁 lock() 和解锁 unlock() 锁定的对象在哪里呢？上面的代码我们看到只有修饰代码块的时候，锁定了一个 obj 对象，那修饰方法的时候锁定的是什么呢？这个也是 Java 的一条隐式规则：

• 当修饰静态方法的时候，锁定的是当前类的 Class 对象，在上面的例子中就是 Class X；
• 当修饰非静态方法的时候，锁定的是当前实例对象 this。

对于上面的例子，synchronized 修饰静态方法相当于:

class X {
    // 修饰静态方法
    synchronized(X.class) static void bar() {
        // 临界区
    }
}

修饰非静态方法，相当于：

class X {
    // 修饰非静态方法
    synchronized(this) void foo() {
        // 临界区
    }
}

这里把i++的例子改下就没有并发问题了：

public class AddI {
    public static volatile int i = 0;
    Object object = new Object();// 单独new一个对象 用于加锁

    public static void main(String[] args) throws InterruptedException {
        // 方式一：修饰静态方法
        Thread t1 = new Thread(() -> add(1000000));
        Thread t2 = new Thread(() -> add(1000000));

        // 方式二：修饰普通方法
        /*AddI addI = new AddI();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                addI.add2(1000000);
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                addI.add2(1000000);
            }
        });*/

        // 方式三
        /*AddI addI = new AddI();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                addI.add3(1000000);
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                addI.add3(1000000);
            }
        });*/

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(i);
    }

    // 修饰静态方法
    public static synchronized void add1(int n) {
        for (int m = 0; m < n; m++) {
            i++;
        }
    }

    // 修饰普通方法
    public synchronized void add2(int n) {
        for (int m = 0; m < n; m++) {
            i++;
        }
    }

    // 代码块加锁
    public void add3(int n) {
        synchronized (object) {
            for (int m = 0; m < n; m++) {
                i++;
            }
        }
    }
}

synchronized 是 Java 在语言层面提供的互斥原语，其实 Java 里面还有很多其他类型的锁，但作为互斥锁，原理都是相通的：锁，一定有一个要锁定的对象，至于这个锁定的对象要保护的资源以及在哪里加锁 / 解锁，就属于设计层面的事情了。

加锁本质就是在锁的对象的对象头中写入当前线程id(这涉及到底层的东西，后面我也整理一篇）。

推荐阅读（系列文章按顺序阅读哦）:
Java内存模型-volatile的应用（实例讲解)
大彻大悟synchronized原理，锁的升级
一文弄懂Java的线程池