第三章：synchronized关键字

主要讲解synchronized的应⽤⽅式和内存语义。

前⾔

看这篇⽂章前，建议⼤家先看我前⾯的⽂章《Java并发编程系列1-基础知识》，否则⾥⾯的相关知识看不懂，特别 是并发编程相关的可⻅性、有序性，以及内存模型JMM等。

在Java中，关键字synchronized可以保证在同⼀个时刻，只有⼀个线程可以执⾏某个⽅法或者某个代码块(主要是 对⽅法或者代码块中存在共享数据的操作)，同时我们还应该注意到synchronized另外⼀个重要的作⽤， synchronized可保证⼀个线程的变化(主要是共享数据的变化)被其他线程所看到（保证可⻅性，完全可以替代 Volatile功能）。

一、synchronized的三种应⽤⽅式

synchronized关键字最主要有以下3种应⽤⽅式，下⾯分别介绍：

• 修饰实例⽅法，作⽤于当前实例加锁，进⼊同步代码前要获得当前实例的锁；
• 修饰静态⽅法，作⽤于当前类对象加锁，进⼊同步代码前要获得当前类对象的锁；
• 修饰代码块，指定加锁对象，对给定对象加锁，进⼊同步代码库前要获得给定对象的锁。

1.1 synchronized作⽤于实例⽅法

所谓的实例对象锁就是⽤synchronized修饰实例对象中的实例⽅法，注意是实例⽅法不包括静态⽅法，如下：

public class AccountingSync implements Runnable {
        //共享资源(临界资源)
        static int i = 0;
        // synchronized 修饰实例⽅法
        public synchronized void increase() {
            i ++;
        }
        @Override
        public void run() {
            for(int j=0;j<1000000;j++){
                increase();
            }
        }
        public static void main(String args[]) throws InterruptedException {
            AccountingSync instance = new AccountingSync();
            Thread t1 = new Thread(instance);
            Thread t2 = new Thread(instance);
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println("static, i output:" + i);
        }
    }
 /**
 * 输出结果:
 * static, i output:2000000
 */

如果在函数increase()前不加synchronized，因为i++不具备原⼦性，所以最终结果会⼩于2000000，具体分析可以 参考⽂章《Java并发编程系列2-volatile》。下⾯这点⾮常重要：

⼀个对象只有⼀把锁，当⼀个线程获取了该对象的锁之后，其他线程⽆法获取该对象的锁，所以⽆法访问该 对象的其他synchronized实例⽅法，但是其他线程还是可以访问该实例对象的其他⾮synchronized⽅法。

但是⼀个线程 A 需要访问实例对象 obj1 的 synchronized ⽅法 f1(当前对象锁是obj1)，另⼀个线程 B 需要访问实 例对象 obj2 的 synchronized ⽅法 f2(当前对象锁是obj2)，这样是允许的：

 public class AccountingSyncBad implements Runnable {
        //共享资源(临界资源)
        static int i = 0;
        // synchronized 修饰实例⽅法
        public synchronized void increase() {
            i ++;
        }
        @Override
        public void run() {
            for(int j=0;j<1000000;j++){
                increase();
            }
        }
        public static void main(String args[]) throws InterruptedException {
            // new 两个AccountingSync新实例
            Thread t1 = new Thread(new AccountingSyncBad());
            Thread t2 = new Thread(new AccountingSyncBad());
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println("static, i output:" + i);
        }
    }
/**
 * 输出结果:
 * static, i output:1224617
 */

上述代码与前⾯不同的是我们同时创建了两个新实例AccountingSyncBad，然后启动两个不同的线程对共享变量i 进⾏操作，但很遗憾操作结果是1224617⽽不是期望结果2000000，因为上述代码犯了严重的错误，虽然我们使⽤ synchronized修饰了increase⽅法，但却new了两个不同的实例对象，这也就意味着存在着两个不同的实例对象 锁，因此t1和t2都会进⼊各⾃的对象锁，也就是说t1和t2线程使⽤的是不同的锁，因此线程安全是⽆法保证的。

每个对象都有⼀个对象锁，不同的对象，他们的锁不会互相影响。

解决这种困境的的⽅式是将synchronized作⽤于静态的increase⽅法，这样的话，对象锁就当前类对象，由于⽆论 创建多少个实例对象，但对于的类对象拥有只有⼀个，所有在这样的情况下对象锁就是唯⼀的。下⾯我们看看如何 使⽤将synchronized作⽤于静态的increase⽅法。

1.2 synchronized作⽤于静态⽅法

当synchronized作⽤于静态⽅法时，其锁就是当前类的class锁，不属于某个对象。

当前类class锁被获取，不影响对象锁的获取，两者互不影响。

由于静态成员不专属于任何⼀个实例对象，是类成员，因此通过class对象锁可以控制静态成员的并发操作。需要注 意的是如果⼀个线程A调⽤⼀个实例对象的⾮static synchronized⽅法，⽽线程B需要调⽤这个实例对象所属类的静 态synchronized⽅法，不会发⽣互斥现象，因为访问静态synchronized⽅法占⽤的锁是当前类的class对象，⽽访 问⾮静态synchronized⽅法占⽤的锁是当前实例对象锁，看如下代码：

public class AccountingSyncClass implements Runnable {
        static int i = 0;
        /**
         * 作⽤于静态⽅法,锁是当前class对象,也就是
         * AccountingSyncClass类对应的class对象
         */
        public static synchronized void increase() {
            i++;
        }
        // ⾮静态,访问时锁不⼀样不会发⽣互斥
        public synchronized void increase4Obj() {
            i++;
        }
        @Override
        public void run() {
            for(int j=0;j<1000000;j++){
                increase();
            }
        }
        public static void main(String[] args) throws InterruptedException {
            //new新实例
            Thread t1=new Thread(new AccountingSyncClass());
            //new新实例
            Thread t2=new Thread(new AccountingSyncClass());
            //启动线程
            t1.start();t2.start();
            t1.join();t2.join();
            System.out.println(i);
        }
    }
/**
 * 输出结果:
 * 2000000
 */

由于synchronized关键字修饰的是静态increase⽅法，与修饰实例⽅法不同的是，其锁对象是当前类的class对 象。注意代码中的increase4Obj⽅法是实例⽅法，其对象锁是当前实例对象，如果别的线程调⽤该⽅法，将不会产 ⽣互斥现象，毕竟锁对象不同，但我们应该意识到这种情况下可能会发现线程安全问题(操作了共享静态变量i)。

1.3 synchronized同步代码块

在某些情况下，我们编写的⽅法体可能⽐较⼤，同时存在⼀些⽐较耗时的操作，⽽需要同步的代码⼜只有⼀⼩部 分，如果直接对整个⽅法进⾏同步操作，可能会得不偿失，此时我们可以使⽤同步代码块的⽅式对需要同步的代码 进⾏包裹，这样就⽆需对整个⽅法进⾏同步操作了，同步代码块的使⽤示例如下：

public class AccountingSync2 implements Runnable {
        static AccountingSync2 instance = new AccountingSync2(); // 饿汉单例模式
        static int i=0;
        @Override
        public void run() {
            //省略其他耗时操作....
            //使⽤同步代码块对变量i进⾏同步操作,锁对象为instance
            synchronized(instance){
                for(int j=0;j<1000000;j++){
                    i++;
                }
            }
        }
        public static void main(String[] args) throws InterruptedException {
            Thread t1=new Thread(instance);
            Thread t2=new Thread(instance);
            t1.start();t2.start();
            t1.join();t2.join();
            System.out.println(i);
        }
    }
/**
 * 输出结果:
 * 2000000
 */

从代码看出，将synchronized作⽤于⼀个给定的实例对象instance，即当前实例对象就是锁对象，每次当线程进⼊ synchronized包裹的代码块时就会要求当前线程持有instance实例对象锁，如果当前有其他线程正持有该对象锁， 那么新到的线程就必须等待，这样也就保证了每次只有⼀个线程执⾏i++;操作。当然除了instance作为对象外，我 们还可以使⽤this对象(代表当前实例)或者当前类的class对象作为锁，如下代码：

 //this,当前实例对象锁
    synchronized(this){
        for(int j=0;j<1000000;j++){
            i++;
        }
    }
//class对象锁
    synchronized(AccountingSync.class){
        for(int j=0;j<1000000;j++){
            i++;
        }
    }

二、synchronized禁⽌指令重排分析

指令重排的情况，可以参考⽂章《Java并发编程系列1-基础知识》

我们先看如下代码：

 class MonitorExample {
        int a = 0;
        public synchronized void writer() { //1
            a++; //2
        } //3
        public synchronized void reader() { //4
            int i = a; //5
            //……
        } //6
    }

假设线程A执⾏writer()⽅法，随后线程B执⾏reader()⽅法。根据happens before规则，这个过程包含的happens before关系可以分为两类：

• 根据程序次序规则，1 happens before 2, 2 happens before 3; 4 happens before 5, 5 happens before 6。
• 根据监视器锁规则，3 happens before 4。
• 根据happens before的传递性，2 happens before 5。

上述happens before 关系的图形化表现形式如下：

在上图中，每⼀个箭头链接的两个节点，代表了⼀个happens before 关系。⿊⾊箭头表示程序顺序规则；橙 ⾊箭头表示监视器锁规则；蓝⾊箭头表示组合这些规则后提供的happens before保证。

上图表示在线程A释放了锁之后，随后线程B获取同⼀个锁。在上图中，2 happens before 5。因此，线程A在释放 锁之前所有可⻅的共享变量，在线程B获取同⼀个锁之后，将⽴刻变得对B线程可⻅。

三、synchronized的可重⼊性

从互斥锁的设计上来说，当⼀个线程试图操作⼀个由其他线程持有的对象锁的临界资源时，将会处于阻塞状态，但 当⼀个线程再次请求⾃⼰持有对象锁的临界资源时，这种情况属于重⼊锁，请求将会成功。

synchronized就是可重⼊锁，因此⼀个线程调⽤synchronized⽅法的同时，在其⽅法体内部调⽤该对象另⼀个 synchronized⽅法是允许的，如下：

public class AccountingSync implements Runnable{
        static AccountingSync instance=new AccountingSync();
        static int i=0;
        static int j=0;
        @Override
        public void run() {
            for(int j=0;j<1000000;j++){
                //this,当前实例对象锁
                synchronized(this){
                    i++;
                    increase();//synchronized的可重⼊性
                }
            }
        }
        public synchronized void increase(){
            j++;
        }
        public static void main(String[] args) throws InterruptedException {
            Thread t1=new Thread(instance);
            Thread t2=new Thread(instance);
            t1.start();t2.start();
            t1.join();t2.join();
            System.out.println(i);
        }
    }

当前实例对象锁后进⼊synchronized代码块执⾏同步代码，并在代码块中调⽤了当前实例对象的另外⼀个 synchronized⽅法，再次请求当前实例锁时，将被允许。需要特别注意另外⼀种情况，当⼦类继承⽗类时，⼦类也 是可以通过可重⼊锁调⽤⽗类的同步⽅法。注意由于synchronized是基于monitor实现的，因此每次重⼊， monitor中的计数器仍会加1。

四、总结

该⽂章给⼤家讲解了synchronized的三种应⽤⽅式，指令重排情况分析，以及synchronized的可重⼊性，通过该 ⽂章，基本可以掌握synchronized的使⽤姿势，以及可能会遇到的坑。关于“线程中断与synchronized”的相关知 识，因为篇幅原因就不写了，⼤家可以到⽹上查⼀下相关资料，进⼀步学习。