Java 并发：内置锁 Synchronized

Posted 2020-10-02 yfceshi

摘要：
　　在多线程编程中，线程安全问题是一个最为关键的问题，其核心概念就在于正确性，即当多个线程訪问某一共享、可变数据时，始终都不会导致数据破坏以及其它不该出现的结果。

而全部的并发模式在解决问题时，採用的方案都是序列化訪问临界资源 。

在 Java 中，提供了两种方式来实现同步相互排斥訪问：synchronized 和 Lock。本文针对 synchronized 内置锁 具体讨论了其在 Java 并发 中的应用，包括它的具体使用场景（同步方法、同步代码块、实例对象锁 和 Class 对象锁）、可重入性 和 注意事项。

---

一. 线程安全问题

　　在单线程中不会出现线程安全问题，而在多线程编程中。有可能会出现同一时候訪问同一个 共享、可变资源 的情况，这样的资源能够是：一个变量、一个对象、一个文件等。特别注意两点，

• 共享： 意味着该资源能够由多个线程同一时候訪问；

• 可变： 意味着该资源能够在其生命周期内被改动。

  　所以。当多个线程同一时候訪问这样的资源的时候，就会存在一个问题：

  　　　由于每一个线程运行的过程是不可控的。所以须要採用同步机制来协同对对象可变状态的訪问。
  　　

举个 数据脏读 的样例：

//资源类
class PublicVar {

    public String username = "A";
    public String password = "AA";

    //同步实例方法
    public synchronized void setValue(String username, String password) {
        try {
            this.username = username;
            Thread.sleep(5000);
            this.password = password;

            System.out.println("method=setValue " +"\\t" + "threadName="
                    + Thread.currentThread().getName() + "\\t" + "username="
                    + username + ", password=" + password);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //非同步实例方法
    public void getValue() {
        System.out.println("method=getValue " + "\\t" +  "threadName="
                + Thread.currentThread().getName()+ "\\t" + " username=" + username
                + ", password=" + password);
    }
}


//线程类
class ThreadA extends Thread {

    private PublicVar publicVar;

    public ThreadA(PublicVar publicVar) {
        super();
        this.publicVar = publicVar;
    }

    @Override
    public void run() {
        super.run();
        publicVar.setValue("B", "BB");
    }
}


//測试类
public class Test {

    public static void main(String[] args) {
        try {
            //临界资源
            PublicVar publicVarRef = new PublicVar();

            //创建并启动线程
            ThreadA thread = new ThreadA(publicVarRef);
            thread.start();

            Thread.sleep(200);// 打印结果受此值大小影响

            //在主线程中调用
            publicVarRef.getValue();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}/* Output ( 数据交叉 ): 
        method=getValue     threadName=main         username=B, password=AA
        method=setValue     threadName=Thread-0     username=B, password=BB
 *///:~

　　由程序输出可知，尽管在写操作进行了同步，但在读操作上仍然有可能出现一些意想不到的情况。比如上面所看到的的 脏读。发生 脏读 的情况是在运行读操作时，对应的数据已被其它线程 部分改动 过。导致 数据交叉 的现象产生。

　　这事实上就是一个线程安全问题，即多个线程同一时候訪问一个资源时。会导致程序运行结果并非想看到的结果。这里面，这个资源被称为：临界资源。也就是说，当多个线程同一时候訪问临界资源（一个对象，对象中的属性。一个文件。一个数据库等）时。就可能会产生线程安全问题。

　　只是，当多个线程运行一个方法时，该方法内部的局部变量并非临界资源，由于这些局部变量是在每一个线程的私有栈中，因此不具有共享性，不会导致线程安全问题。

---

二. 怎样解决线程安全问题

　　实际上，全部的并发模式在解决线程安全问题时，採用的方案都是 序列化訪问临界资源 。

即在同一时刻，仅仅能有一个线程訪问临界资源，也称作 同步相互排斥訪问。

换句话说，就是在訪问临界资源的代码前面加上一个锁。当訪问完临界资源后释放锁，让其它线程继续訪问。

　　在 Java 中，提供了两种方式来实现同步相互排斥訪问：synchronized 和 Lock。本文主要讲述 synchronized 的用法。Lock 的用法我的还有一篇博文《Java 并发：Lock 框架具体解释》中阐述。

---

三. synchronized 同步方法或者同步块

　　在了解 synchronized 关键字的用法之前。我们先来看一个概念：相互排斥锁。即 能到达到相互排斥訪问目的的锁。举个简单的样例，假设对临界资源加上相互排斥锁，当一个线程在訪问该临界资源时。其它线程便仅仅能等待。

　　在 Java 中。能够使用 synchronized 关键字来标记一个方法或者代码块。当某个线程调用该对象的synchronized方法或者訪问synchronized代码块时，这个线程便获得了该对象的锁，其它线程临时无法訪问这种方法，仅仅有等待这种方法运行完成或者代码块运行完成。这个线程才会释放该对象的锁，其它线程才干运行这种方法或者代码块。

---

　　以下这段代码中两个线程分别调用insertData对象插入数据：

1) synchronized方法

public class Test {

    public static void main(String[] args)  {
        final InsertData insertData = new InsertData();
        // 启动线程 1  
        new Thread() {
            public void run() {
                insertData.insert(Thread.currentThread());
            };
        }.start();

        // 启动线程 2
        new Thread() {
            public void run() {
                insertData.insert(Thread.currentThread());
            };
        }.start();
    }  
}

class InsertData {

    // 共享、可变资源
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();

    //对共享可变资源的訪问
    public void insert(Thread thread){
        for(int i=0;i<5;i++){
            System.out.println(thread.getName()+"在插入数据"+i);
            arrayList.add(i);
        }
    }
}/* Output: 
        Thread-0在插入数据0
        Thread-1在插入数据0
        Thread-0在插入数据1
        Thread-0在插入数据2
        Thread-1在插入数据1
        Thread-1在插入数据2
 *///:~

　　依据运行结果就能够看出，这两个线程在同一时候运行insert()方法。而假设在insert()方法前面加上关键字synchronized 的话，运行结果为：

class InsertData {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();

    public synchronized void insert(Thread thread){
        for(int i=0;i<5;i++){
            System.out.println(thread.getName()+"在插入数据"+i);
            arrayList.add(i);
        }
    }
}/* Output: 
        Thread-0在插入数据0
        Thread-0在插入数据1
        Thread-0在插入数据2
        Thread-1在插入数据0
        Thread-1在插入数据1
        Thread-1在插入数据2
 *///:~

　　从以上输出结果能够看出。Thread-1 插入数据是等 Thread-0 插入完数据之后才进行的。

说明 Thread-0 和 Thread-1 是顺序运行 insert() 方法的。

这就是 synchronized 关键字对方法的作用。

　　只是须要注意以下三点：

　　1）当一个线程正在訪问一个对象的 synchronized 方法，那么其它线程不能訪问该对象的其它 synchronized 方法。这个原因非常easy，由于一个对象仅仅有一把锁。当一个线程获取了该对象的锁之后。其它线程无法获取该对象的锁，所以无法訪问该对象的其它synchronized方法。

　　2）当一个线程正在訪问一个对象的 synchronized 方法，那么其它线程能訪问该对象的非 synchronized 方法。这个原因非常easy，訪问非 synchronized 方法不须要获得该对象的锁，假如一个方法没用 synchronized 关键字修饰，说明它不会使用到临界资源，那么其它线程是能够訪问这种方法的，

　　3）假设一个线程 A 须要訪问对象 object1 的 synchronized 方法 fun1，另外一个线程 B 须要訪问对象 object2 的 synchronized 方法 fun1。即使 object1 和 object2 是同一类型），也不会产生线程安全问题，由于他们訪问的是不同的对象。所以不存在相互排斥问题。

---

2) synchronized 同步块

　　synchronized 代码块相似于以下这样的形式：

synchronized (lock){
    //訪问共享可变资源
    ...
}

　　当在某个线程中运行这段代码块。该线程会获取对象lock的锁，从而使得其它线程无法同一时候訪问该代码块。当中，lock 能够是 this。代表获取当前对象的锁，也能够是类中的一个属性。代表获取该属性的锁。

特别地， 实例同步方法 与 synchronized(this)同步块 是相互排斥的，由于它们锁的是同一个对象。但与 synchronized(非this)同步块 是异步的。由于它们锁的是不同对象。

　　比方上面的insert()方法能够改成以下两种形式：

// this 监视器
class InsertData {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();

    public void insert(Thread thread){
        synchronized (this) {
            for(int i=0;i<100;i++){
                System.out.println(thread.getName()+"在插入数据"+i);
                arrayList.add(i);
            }
        }
    }
}

// 对象监视器
class InsertData {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    private Object object = new Object();

    public void insert(Thread thread){
        synchronized (object) {
            for(int i=0;i<100;i++){
                System.out.println(thread.getName()+"在插入数据"+i);
                arrayList.add(i);
            }
        }
    }
}

　　从上面代码能够看出。synchronized代码块 比 synchronized方法 的粒度更细一些，使用起来也灵活得多。

由于或许一个方法中仅仅有一部分代码仅仅须要同步，假设此时对整个方法用synchronized进行同步，会影响程序运行效率。

而使用synchronized代码块就能够避免这个问题。synchronized代码块能够实现仅仅对须要同步的地方进行同步。

---

3) class 对象锁

　　特别地。每一个类也会有一个锁，静态的 synchronized方法 就是以Class对象作为锁。另外。它能够用来控制对 static 数据成员 （static 数据成员不专属于不论什么一个对象，是类成员） 的并发訪问。

而且，假设一个线程运行一个对象的非static synchronized 方法，另外一个线程须要运行这个对象所属类的 static synchronized 方法，也不会发生相互排斥现象。

由于訪问 static synchronized 方法占用的是类锁，而訪问非 static synchronized 方法占用的是对象锁，所以不存在相互排斥现象。比如，

public class Test {

    public static void main(String[] args)  {
        final InsertData insertData = new InsertData();
        new Thread(){
            @Override
            public void run() {
                insertData.insert();
            }
        }.start(); 
        new Thread(){
            @Override
            public void run() {
                insertData.insert1();
            }
        }.start();
    }  
}

class InsertData { 

    // 非 static synchronized 方法
    public synchronized void insert(){
        System.out.println("运行insert");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("运行insert完成");
    }

    // static synchronized 方法
    public synchronized static void insert1() {
        System.out.println("运行insert1");
        System.out.println("运行insert1完成");
    }
}/* Output: 
        运行insert
        运行insert1
        运行insert1完成
        运行insert完成
 *///:~

　　依据运行结果。我们能够看到第一个线程里面运行的是insert方法。不会导致第二个线程运行insert1方法发生堵塞现象。以下，我们看一下 synchronized 关键字究竟做了什么事情。我们来反编译它的字节码看一下，以下这段代码反编译后的字节码为：

public class InsertData {
    private Object object = new Object();

    public void insert(Thread thread){
        synchronized (object) {}
    }

    public synchronized void insert1(Thread thread){}

    public void insert2(Thread thread){}
}

　　　　　　　　　　　　
　　　　　　　　　　　
　　从反编译获得的字节码能够看出。synchronized 代码块实际上多了 monitorenter 和 monitorexit 两条指令。 monitorenter指令运行时会让对象的锁计数加1。而monitorexit指令运行时会让对象的锁计数减1。事实上这个与操作系统里面的PV操作非常像，操作系统里面的PV操作就是用来控制多个进程对临界资源的訪问。

对于synchronized方法。运行中的线程识别该方法的 method_info 结构是否有 ACC_SYNCHRONIZED 标记设置，然后它自己主动获取对象的锁。调用方法。最后释放锁。假设有异常发生，线程自己主动释放锁。

　　有一点要注意：对于 synchronized方法 或者 synchronized代码块。当出现异常时，JVM会自己主动释放当前线程占用的锁，因此不会由于异常导致出现死锁现象。

　　

---

四. 可重入性

　　一般地，当某个线程请求一个由其它线程持有的锁时，发出请求的线程就会堵塞。然而，由于 Java 的内置锁是可重入的，因此假设某个线程试图获得一个已经由它自己持有的锁时，那么这个请求就会成功。可重入锁最大的作用是避免死锁。

比如：

public class Test implements Runnable {

    // 可重入锁測试
    public synchronized void get() {
        System.out.println(Thread.currentThread().getName());
        set();
    }

    public synchronized void set() {
        System.out.println(Thread.currentThread().getName());
    }

    @Override
    public void run() {
        get();
    }

    public static void main(String[] args) {
        Test test = new Test();
        new Thread(test,"Thread-0").start();
        new Thread(test,"Thread-1").start();
        new Thread(test,"Thread-2").start();
    }
}/* Output: 
        Thread-1
        Thread-1
        Thread-2
        Thread-2
        Thread-0
        Thread-0
 *///:~

---

五. 注意事项

1). 内置锁与字符串常量

　　由于字符串常量池的原因，在大多数情况下，同步synchronized代码块 都不使用 String 作为锁对象，而改用其它，比方 new Object() 实例化一个 Object 对象，由于它并不会被放入缓存中。

看以下的样例：

//资源类
class Service {
    public void print(String stringParam) {
        try {
            synchronized (stringParam) {
                while (true) {
                    System.out.println(Thread.currentThread().getName());
                    Thread.sleep(1000);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

//线程A
class ThreadA extends Thread {
    private Service service;

    public ThreadA(Service service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.print("AA");
    }
}

//线程B
class ThreadB extends Thread {
    private Service service;

    public ThreadB(Service service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.print("AA");
    }
}

//測试
public class Run {
    public static void main(String[] args) {

        //临界资源
        Service service = new Service();

        //创建并启动线程A
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();

        //创建并启动线程B
        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();

    }
}/* Output (死锁): 
        A
        A
        A
        A
        ...
 *///:~

　　出现上述结果就是由于 String 类型的參数都是 “AA”，两个线程持有同样的锁，所以 线程B 始终得不到运行。造成死锁。

进一步地，所谓死锁是指：
　　　　不同的线程都在等待根本不可能被释放的锁。从而导致全部的任务都无法继续完成。

---

b). 锁的是对象而非引用

　　在将不论什么数据类型作为同步锁时，须要注意的是。是否有多个线程将同一时候去竞争该锁对象：
　　1).若它们将同一时候竞争同一把锁，则这些线程之间就是同步的；
　　2).否则。这些线程之间就是异步的。

看以下的样例：

//资源类
class MyService {
    private String lock = "123";

    public void testMethod() {
        try {
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName() + " begin "
                        + System.currentTimeMillis());
                lock = "456";
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + "   end "
                        + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

//线程B
class ThreadB extends Thread {

    private MyService service;

    public ThreadB(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.testMethod();
    }
}

//线程A
class ThreadA extends Thread {

    private MyService service;

    public ThreadA(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.testMethod();
    }
}

//測试
public class Run1 {
    public static void main(String[] args) throws InterruptedException {

        //临界资源
        MyService service = new MyService();

        //线程A
        ThreadA a = new ThreadA(service);
        a.setName("A");

        //线程B
        ThreadB b = new ThreadB(service);
        b.setName("B");

        a.start();
        Thread.sleep(50);// 存在50毫秒
        b.start();
    }
}/* Output(循环): 
       A begin 1484319778766
       B begin 1484319778815
       A   end 1484319780766
       B   end 1484319780815
 *///:~

　　由上述结果可知，线程 A、B 是异步的。由于50毫秒过后， 线程B 取得的锁对象是 “456”，而 线程A 依旧持有的锁对象是 “123”。

所以，这两个线程是异步的。若将上述语句 “Thread.sleep(50);” 凝视。则有：

//測试
public class Run1 {
    public static void main(String[] args) throws InterruptedException {

        //临界资源
        MyService service = new MyService();

        //线程A
        ThreadA a = new ThreadA(service);
        a.setName("A");

        //线程B
        ThreadB b = new ThreadB(service);
        b.setName("B");

        a.start();
        // Thread.sleep(50);// 存在50毫秒
        b.start();
    }
}/* Output(循环): 
       B begin 1484319952017
       B   end 1484319954018
       A begin 1484319954018
       A   end 1484319956019
 *///:~

　　由上述结果可知，线程 A、B 是同步的。由于线程 A、B 竞争的是同一个锁“123”，尽管先获得运行的线程将 lock 指向了 对象“456”。但结果还是同步的。由于线程 A 和 B 共同争抢的锁对象是“123”，也就是说。锁的是对象而非引用。

---

六. 总结

　　用一句话来说。synchronized 内置锁 是一种 对象锁 (锁的是对象而非引用)， 作用粒度是对象 ，能够用来实现对 临界资源的同步相互排斥訪问 ，是 可重入 的。特别地。对于 临界资源 有：

• 若该资源是静态的，即被 static 关键字修饰。那么訪问它的方法必须是同步且是静态的，synchronized 块必须是 class锁；

• 若该资源是非静态的，即没有被 static 关键字修饰，那么訪问它的方法必须是同步的，synchronized 块是实例对象锁；
  　　

实质上。关键字synchronized 主要包括两个特征：

• 相互排斥性：保证在同一时刻，仅仅有一个线程能够运行某一个方法或某一个代码块。

• 可见性：保证线程工作内存中的变量与公共内存中的变量同步。使多线程读取共享变量时能够获得最新值的使用。

---

引用

《Java 并发编程实战》
《Java 多线程编程核心技术》
Java并发编程：synchronized