Android多线程之线程锁

前言

上篇文章讲了线程安全问题，要保证原子性，可见性和有序性的操作才能保证线程安全。也讲到了synchronized、volatile，本章讲讲这些是什么。

什么是锁

首先要知道一个东西，锁（Lock）。锁，大家都知道吧，把东西锁起来不让别人拿到，直到把锁打开，才可以拿到。把东西比作数据，把人比作线程，多线程间能对同个数据进行操作是不安全的，但是锁能保证你当前只有一个线程能对数据操作，直到线程操作完，下个线程接着操作。这就是锁的作用，让多个线程更好地协作，避免多个线程的操作交错导致数据异常的问题。接下来看看锁的一些特点和问题，一定要耐心看完对锁才能进一步了解。

锁的特点

临界区
当我们给东西上锁后，进行操作，操作完再把锁打开，这个上锁和解锁的中间，就是临界区。放在代码中是这么解释的，持有锁的线程获取锁后和释放锁前执行的代码叫做临界区。（看到后面怎么用锁，大概就知道是什么意思了）
排他性
还记得原子性是什么吗？操作不可分割，也就是说整个操作只能是一个线程去执行，那这个操作的范围是多大呢？就是刚才说的临界区。总结一点：排他性能够保障一个共享变量在任一时刻只能被一个线程访问，这就保证了临界区代码一次只能够被一个线程执行，临界区的操作具有不可分割性
串行
在没有锁的时候，多线程下并发对数据进行操作，这是很危险的。所以在有锁的情况下，只能一个个线程访问数据，就体现出串行了
三种保障
锁能够保护共享变量实现线程安全，它的作用包括保障原子性、可见性和有序性。
调度策略
锁的调度策略分为公平策略和非公平策略，对应的锁就叫公平锁和非公平锁。多线程情况下，会有多个线程要访问数据，只能有一个进去访问，其他都在外面等待，但是公平策略情况下，这个等待是按照先到排前面的规则来执行；不公平策略情况下，按照抢占式来抢占，没有顺序。公平锁以增加上下文切换为代价，保障了锁调度的公平性，增加了线程暂停和唤醒的可能性。

锁的两个问题

泄漏锁
锁泄漏是指一个线程获得锁后，由于程序的错误导致锁一直无法被释放，导致其他线程一直无法获得该锁。
活跃性问题
锁泄漏会导致活跃性问题，这些问题包括死锁、和锁死等。（后面会讲到死锁和锁死的差别，别混淆了）

锁的类型

锁可分为内部锁（synchronized）、显式锁（ReentrantLock）、读写锁（ReentrantReadWriteLock）、轻量级锁（volatile）四种。

内部锁（synchronized）

synchronized是个关键字应该都有见过吧，它可以修饰方法（同步方法），也可以修饰代码块，也可以修饰静态方法给它加锁。

修饰实例方法

    private var count = 0
    @Synchronized
    fun log(text: String) {
        for (index in 0..4) {
            count++
            println(Thread.currentThread().name + "：" + text + "：" + count)
        }
    }

    fun getLog(){
        thread { log("测试1") }
        thread { log("测试2") }
    }
        //测试结果
        Thread-292：测试1：1
        Thread-292：测试1：2
        Thread-292：测试1：3
        Thread-292：测试1：4
        Thread-292：测试1：5
        Thread-293：测试2：6
        Thread-293：测试2：7
        Thread-293：测试2：8
        Thread-293：测试2：9
        Thread-293：测试2：10

由于用synchronized修饰了方法，测试2的线程需要等待测试1的线程执行完才可以执行

修饰静态方法

    companion object{
        private var count = 0
        @Synchronized
        fun log(text: String){
            for (index in 0..4) {
                count++
                println(Thread.currentThread().name + "：" + text + "：" + count)
            }
        }
    }

修饰代码块

    private var count = 0
    fun println1(text: String) {
        synchronized(this) {
            count++
            println(Thread.currentThread().name + "：" + text + "：" + count)
        }
    }
//或者
    private var count = 0
    private val lock = Any()
    fun println1(text: String) {
        synchronized(lock) {
            count++
            println(Thread.currentThread().name + "：" + text + "：" + count)
        }
    }

其中，修饰方法时候，锁住的是当前类的字节码文件；修饰代码块的时候，锁住的是对象

synchronized

还是拿图出来比较好解释

在多线程运行过程中，线程会去先抢对象的监视器（monitor），这个监视器是对象独有的，其实就相当于一把钥匙，抢到了，那你就获得了当前代码块儿的执行权。

其他没有抢到的线程会进入队列(SynchronizedQueue)当中等待，等待当前线程执行完后，释放锁。最后当前线程执行完毕后通知出队然后继续重复当前过程。从 jvm 的角度来看 monitorenter 和 monitorexit 指令代表着代码的执行与结束。

再来看看这个锁的特点：
1、监视器锁：因为使用 synchronized 实现的线程同步是通过监视器（monitor）来实现的，所以内部锁也叫监视器锁。

2、自动获取/释放：线程对同步代码块的锁的申请和释放由 JVM 内部实施，线程在进入同步代码块前会自动获取锁，并在退出同步代码块时自动释放锁，这也是同步代码块被称为内部锁的原因。（异常时也是会自动释放的）

3、锁定方法/类/对象：synchronized 关键字可以用来修饰方法，锁住特定类和特定对象。

4、临界区：同步代码块就是内部锁的临界区，线程在执行临界区代码前必须持有该临界区的内部锁。

5、锁句柄：内部锁锁的对象就叫锁句柄（就是刚才代码里面的this或者lock对象），锁句柄通常会用 private 和 final 关键字进行修饰。因为锁句柄变量一旦改变，会导致执行同一个同步代码块的多个线程实际上用的是不同的锁。

6、不会泄漏：泄漏指的是锁泄漏，内部锁不会导致锁泄漏，因为 javac 编译器把同步代码块编译为字节码时，对临界区中可能抛出的异常做了特殊处理，这样临界区的代码出了异常也不会妨碍锁的释放。

7、非公平锁：内部锁是使用的是非公平策略，是非公平锁，也就是不会增加上下文切换开销。

显式锁（ReentrantLock）

ReentrantLock 的使用同 synchronized 有点不同，它的加锁和解锁操作都需要手动完成

private int count = 0;
private ReentrantLock reentrantLock = new ReentrantLock();
public void print(String text) {
  reentrantLock.lock();
  try {
    System.out.println(Thread.currentThread().getName() + "：" + text + "：" + count);
  } catch (Exception e) {
  } finally {
    reentrantLock.unlock();
  }
}

lock() 和 unlock() 分别是加锁和解锁操作。ReentrantLock 与 synchronized 不同，当异常发生时 synchronized 会自动释放锁，但是 ReentrantLock 并不会自动释放锁。因此好的方式是将 unlock 操作放在 finally 代码块中，保证任何时候锁都能够被正常释放掉。

默认情况下，synchronized 和 ReentrantLock 都是非公平锁。但是 ReentrantLock 可以通过传入 true 来创建一个公平锁。所谓公平锁就是通过同步队列来实现多个线程按照申请锁的顺序获取锁。

创建一个公平锁：

private int count = 0;
private ReentrantLock reentrantLock = new ReentrantLock(true);
public void print(String text) {
    reentrantLock.lock();
    try {
    System.out.println(Thread.currentThread().getName() + "：" + text + "：" + count);
    } catch (Exception e) {
    } finally {
    reentrantLock.unlock();
    }
}

读写锁

private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
public void test() {
  // 读操作
  reentrantReadWriteLock.readLock().lock();
  try {
  } catch (Exception e) {
  } finally {
    reentrantReadWriteLock.readLock().unlock();
  }
  // 写操作
  reentrantReadWriteLock.writeLock().lock();
  try {
  } catch (Exception e) {
  } finally {
    reentrantReadWriteLock.writeLock().unlock();
  }
}

读写锁和显式锁的差别在于，把读和写的操作细分出来，这样在读写时不会发生冲突。

轻量级锁（volatile）

volatile，用来修饰变量的关键字，当我们多线程对一个变量进行修改时，会有线程安全问题。volatile就是把这个变量改动时候会设立一个屏障，简单点说，就是你要去取值时是写的操作，那么你在取值前去把要把这个值修改的线程给拦住，你写完之后，再加一层存储的屏障，这屏障是为了让你把修改的值更新到主存去，等更新完后两个屏障一起去掉，之后用这个volatile修饰的变量，每次取值都要去主存中取，这样就能保住读的时候能读到正取的数据，也就保住了可见性。

注：volatile不能保证原子性，因为当一个变量进行x++的操作后实际是分为temp = x，temp = x + 1，x = temp，这三个操作，那么在中途另一个线程插进来了，值就不正确了。