Synchronized的那些事

在上一篇博客中，我“蜻蜓点水”般的介绍了下Java内存模型，在这一篇博客，我将带着大家看下Synchronized关键字的那些事，其实把Synchronized关键字放到上一篇博客中去介绍，也是符合 “Java内存模型”这个标题的，因为Synchronized关键字和Java内存模型有着密不可分的关系。但是这样，上一节的内容就太多了。同样的，这一节的内容也相当多。

好了，废话不多说，让我们开始吧，

Synchronized基本使用

首先从一个最简单的例子开始看：

public class Main {
    private int num = 0;
    private void test() {
        for (int i = 0; i < 50; i++) {
            try {
                TimeUnit.MILLISECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num++;
        }
    }
    public static void main(String[] args) {
        Main main = new Main();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                main.test();
            }).start();
        }
        try {
            TimeUnit.SECONDS.sleep(5);
            System.out.println(main.num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Main方法中开启了20个线程，每个线程执行50次的累加操作，最后打印出来的应该是50*20，也就是1000，但是每次打印出来的都不是1000，而是比1000小的数字。相信这个例子，大家早就烂熟于心了，对解决方案也是手到擒来：

public class Main {
    private int num = 0;

    private synchronized void test() {
        for (int i = 0; i < 50; i++) {
            try {
                TimeUnit.MILLISECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num++;
        }
    }

    public static void main(String[] args) {
        Main main = new Main();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                main.test();
            }).start();
        }
        try {
            TimeUnit.SECONDS.sleep(5);
            System.out.println(main.num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

只要在test方法上加一个synchronized关键字，就OK了。

Synchronized与原子性

为什么会出现这样的问题呢，可能就有一小部分人不知道其中的原因了。

这和Java的内存模型有关系：在Java的内存模型中，保证并发安全的三大特性是 原子性，可见性，有序性。导致这问题出现的原因 便是 num++ 不是原子性操作，它至少有三个操作：

1.把i读取出来

2.做自增计算

3.把值写回i

让我们设想有这样的一个场景：

当num=5

1. A线程执行到num++这一步，读到了num的值为5（因为还没进行自增操作）。

2. B线程也执行到了num++这一步，读到了num的值还是为5（因为A线程中的num还没有来得及进行自增操作）。

3. A线程中的num终于进行了自增操作，num为6。

4. B线程的num也进行了自增操作，num也为6。

可能光用文字描述，还是有点懵，所以我画了一张图来帮助大家理解：

结合文字和图片，应该就可以理解了。

可以看出来，虽然执行了两次自增操作，但是实际的效果只是自增了一次。

所以在第一段代码中，运行的结果并不是1000，而是比1000小的数字。

对于在多线程环境中，出现奇怪的结果或者情况，我们也称为“线程不安全”。

而第二段代码，就是通过Synchronized关键字，把test方法串行化执行了，也就是 A线程执行完test方法，B线程才可以执行test方法。两个线程是互斥的。这样就保证了线程的安全性，最后的结果就是1000。如果从Java内存模型的角度来说，就是保证了操作的“原子性”。

Synchronized几种使用方法

上面的例子是Synchronized关键字的使用方式之一，此时，synchronized标记的是类的实例方法，锁对象是类的实例对象。当然还有其他使用方式：

 private static synchronized void test() {
        for (int i = 0; i < 10; i++) {
            try {
                TimeUnit.MILLISECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(num++);
        }
    }

此时，synchronized标记的是类的静态方法，锁对象是类。

以上两种，是直接标记在方法上。

还可以包裹代码块：

    private void test() {
        synchronized (Main.class) {
            for (int i = 0; i < 10; i++) {
                try {
                    TimeUnit.MILLISECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(num++);
            }
        }
    }

此时锁的对象是 类。

    private void test() {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                try {
                    TimeUnit.MILLISECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(num++);
            }
        }
    }

此时锁的对象是类的实例对象。

    private Object object = new Object();

    private void test() {
        synchronized (object) {
            for (int i = 0; i < 10; i++) {
                try {
                    TimeUnit.MILLISECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(num++);
            }
        }
    }

此时，锁对象是Object的对象。

JConsole探究Synchronized关键字

我们需要用到JDK自带的一个工具：JConsole，它位于JDK的bin目录下。

为了让观察更加方便，我们需要给线程起一个名字，每个线程内sleep的时间稍微长一点：

public class Main {
    private synchronized void test() {
        try {
            TimeUnit.SECONDS.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Main main = new Main();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                main.test();
            }, "Hello,Thread " + i).start();
        }
    }
}

我们先启动项目，然后打开JConsole，找到你项目的进程，就可以连接上去了。

可以看到，5个线程已经显示在JConsole里面了：

点击某个线程，可以看到关于线程的一些信息：

其中四个线程都处于BLOCKED，只有一个处于TIME_WAITING，说明只有一个线程获得了锁，并在TIME_WAITING，其余的线程都没有获得锁，没有进入到方法，说明了Synchronized的互斥性。关于线程的状态，这篇不会深入，以后可能会介绍这方面的知识。

因为我是一边写博客，一边执行各种操作的，所以速度上有些跟不上，导致截图和描述不同，大家可以自己去试试。

javap探究Synchronized关键字

为了把问题简单化，让大家看的清楚，我只保留synchronized相关的代码：

public class Main {
    public static void main(String[] args) {
        synchronized (Main.class) {
        }
    }
}

编译后，用javap命令查看字节码文件：

javap -v Main.class

用红圈圈出来的就是添加synchronized后带来的命令了。执行同步代码块，先是调用monitorenter命令，执行完毕后，再调用monitorexit命令，为什么会有两个monitorexit呢，一个是正常执行办法后的monitorexit，一个是发生异常后的monitorexit。

synchronized标记方法会是什么情况呢？

public class Main {
    public synchronized void Hello(){
        System.out.println("Hellol");
    }
    public static void main(String[] args) {
    }
}

锁与Monitor

JVM为每个对象都分配了一个monitor，syncrhoized就是利用monitor来实现加锁，解锁。同一时刻，只有一个线程可以获得monitor，并且执行被包裹的代码块或者方法，其他线程只能等待monitor释放，整个过程是互斥的。monitor拥有一个计数器，当线程获取monitor后，计数器便会+1，释放monitor后，计数器便会-1。那么为什么会是+1，-1 的操作，而不是“获得monitor，计数器=1，释放monitor后，计数器=0”呢？这就涉及到 锁的重入性了。我们还是通过一段简单的代码来看：

public static void main(String[] args) {
	    synchronized (Main.class){
	        System.out.println("第一个synchronized");
	        synchronized (Main.class){
                System.out.println("第二个synchronized");
            }
        }
    }

结果：

主线程获取了类锁，打印出 “第一个synchronized”，紧接着主线程又获取了类锁，打印出“第二个synchronized”。

问题来了，第一个类锁明明还没有释放，下面又获取了这个类锁。如果没有“锁的重入性”，这里应该只会打印出 “第一个synchronized”，然后程序就死锁了，因为它会一直等待释放第一个类锁，但是却永远等不到那一刻。

这也就是解释了为什么会是“当线程获取monitor后，计数器便会+1，释放monitor后，计数器便会-1“这样的设计。只有当计数器=0，才代表monitor已经被释放。第二个线程才能再次获取monitor。

当然，锁的重入性是针对于同一个线程来说。

Synchronized与有序性，可见性

在上一篇中，我们简单的介绍了指令重排，知道了三大特性之一的有序性，但是介绍的太简单。这一次，我们把上一次的内容补充下。

其实，指令重排分为两种：

1. 编译器重排
2. 运行时CPU指令排序

为什么编译器和CPU会做“指令重排”这个“吃力不讨好”的事情呢?当然是为了效率。

指令重排会遵守两个规则：即 self-if-serial 和 happens-before。

我们来举一个例子：

int a=1;//1
int b=5;//2
int c=a+b;//3

这结果显而易见：c=6。

但是这段代码真正交给CPU去执行是按照什么顺序呢，大部分人会认为 ”从上到下"。是的，从大家开始学编程第一天就被灌输了这个思想，但是这仅仅是一个幻觉，真正交给CPU执行，可能是 先执行第二行，然后再执行第一行，最后是第三行。因为第一行和第二行，哪一行先运行，并不影响最终的结果，但是第三行的执行顺序就不能改变了，因为数据存在依懒性。如果改变了第三行的执行顺序，那不乱套了。

编译器，CPU会在不影响单线程程序最终执行的结果的情况下进行“指令重排”。

这就是“ self-if-serial”规则。

这个规则就给程序员造给一种假象，在单线程中，代码都是从上到下执行的，殊不知，编译器和CPU其实在背后偷偷的做了很多事情，而做这些事情的目的只有一个“提高执行的速度”。

在单线程中，我们可能并不需要关心指令重排，因为无论背后进行了多么翻天覆地的“指令重排”都不会影响到最终的执行结果，但是self-if-serial是针对于单线程的，对于多线程，会有第二个规则：happens-before。

happens-before用来表述两个操作之间的关系。如果A happens-before B，也就代表A发生在B之前。

由于两个操作可能处于不同的线程，happens-before规定，如果一个线程A happens-before另外一个线程B，那么A对B可见，正是由于这个规定，我们说Synchronized保证了线程的“可见性”。Synchronized具体是怎么做的呢？当我们获得锁的时候，执行同步代码，线程会被强制从主内存中读取数据，先把主内存的数据复制到本地内存，然后在本地内存进行修改，在释放锁的时候，会把数据写回主内存。

而Synchronized的同步特性，显而易见的保证了“有序性”。

总结一下，Synchronized既可以保证“原子性”，又可以保证“可见性”，还可以保证“有序性”。

Synchronized与单例模式

Synchronized最经典的应用之一就是 懒汉式单例模式 了，如下：

public class Main {
    private static Main main;

    private Main() {
    }

    public static Main getInstance() {
        if (main == null) {
            synchronized (Main.class) {
                if (main == null) {
                    main = new Main();
                }
            }
        }
        return main;
    }
}

相信这代码，大家已经熟悉的不能再熟悉了，但是在极端情况下，可能会产生意想不到的情况，这个时候，Synchronized的好基友Volatile就出现了，这是我们下一节中要讲的内容。

Synchronized可以说是每次面试必定会出现的问题，平时在多线程开发的时候也会用到，但是真正要理解透彻，还是有不小难度。虽说Synchronized的互斥性，很影响性能，Java也提供了不少更好用的的并发工具，但是Synchronized是并发开发的基础，所以值得花点时间去好好研究。

好了，本节的内容到这里结束了，文章已经相当长了，但是还有一大块东西没有讲：JDK1.6对Synchronized进行的优化，有机会，会再抽出一节的内容来讲讲这个。