锁的种类

  • 独享锁 VS 共享锁
  • 独享锁:锁只能被一个线程持有(synchronized)
  • 共享锁:锁可以被多个程序所持有(读写锁)
  • 乐观锁 VS 悲观锁
  • 乐观锁:每次去拿数据的时候都乐观地认为别人不会修改,所以不进行加锁操作。乐观锁适用于多读的应用类型。(CAS,Atomic)
  • CAS(Compare And Swap),其思想是:我认为V的值应该为 A,如果是,那么将 V 的值更新为 B,否则不修改并告诉V的值实际为多少。这样一来当有多个线程尝试修改同一个对象时,只有一个线程能够成功修改,因为一旦有一个线程修改成功了,那么其他线程就没法满足 V 的值是 A 了。其他线程修改失败之后不会被挂起,而是再次尝试修改。
  • 悲观锁:总是假设最坏的情况,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会阻塞直到它拿到锁。
  • 公平锁 VS 非公平锁
  • 公平锁:对于等待锁队列中的线程,按照先来先得的原则,给予锁。
  • 非公平锁:一个线程一执行到需要锁的地方,就尝试去要锁,失败了再进等待队列。这样一来,就能够大大减少唤醒线程的开销,但有可能会出现某线程饿死的情况。
  • synchronized 是非公平锁,lock 可以是公平也可以非公平。
  • 其他概念
  • 可重入锁(synchronized 和 lock):可重入性表明了锁的分配不是基于方法而是基于线程的。如:synchronized 了两个方法 method1, method2,method1 中调用了 method2,那么只要线程获得了 method1 的锁,那么它就一定能够进入 method2 而不需再申请锁。
  • 可中断锁(lockInterruptible()):对于等待锁的线程,若等待时间过长,想中断该等待过程,让该线程去做其他的事,那么就需要可中断锁。

Java 锁的状态

Java 锁状态的级别从低到高为:无锁状态、偏向锁状态、轻量级锁状态、重要级锁状态,而锁的状态是被记录在 Java 对象的对象头中。

  • Java 的对象头:由 Mark Word、指向类的指针、数组长度,其中 Mark Word 负责记录有关锁的信息
  • 32 位 JVM 中 Mark Word 存储的内容为

锁状态

25bit

4bit

1bit (是否是偏向锁)

2bit (锁标志位)

无锁

对象的 HashCode

分代年龄

0

01

偏向锁

线程 ID 与 Epoch

分代年龄

1

01

轻量级锁

指向栈中的锁记录指针

同前

同前

00

重量级锁

指向重量级锁的指针

同前

同前

10

GC 标记


11

  • 偏向锁、轻量级锁概念的出现,都是为了减少同步唤醒的代价,若所有锁都为重量级的,那么所有等待锁的线程必须进入阻塞态
  • 偏向锁:大多数情况下,锁并不存在被大量线程竞争,而且总是由一个线程多次重复申请,那么这时只需要让偏向锁记录该线程 ID,这样当该线程又来声请锁的时候,就能快速获得锁了。
  • 轻量级锁:存在竞争,但是不强力且持有锁的线程会很快释放锁,在这种情况下,等待锁的线程可以处于自旋状态,而不必进入阻塞状态。
  • Java 中锁的状态是一级一级往上升的,具体情况为:
  • 当未遇到同步代码块(即没有出现锁的时候),处于无锁状态。
  • 当对象被当作了同步锁,但当前只有一个线程 A 申请了该锁(没有竞争产生),那么对象的锁状态就会升级为偏向锁。
  • 当又有另一线程 B 来申请锁时,这时会检查当前占用该锁的线程 A 是否处于活跃状态或者仍然需要该锁,即是否有竞争会产生。若无,则偏向锁偏向 B,A 释放偏向锁。
  • 若有,那么偏向锁就会升级会轻量级锁。但若竞争进一步加大(有很多线程需求锁,且占用时间较长),那么锁就会进一步升级为重量级锁。

Java 锁机制的实现

synchronized

从上一节我们可以看出来,Java 中能够作为锁的只能是对象,所以 synchronized 的实现,也是通过对对象进行加锁实现的。

  • synchronized 的三种用法
  • synchronized aMethod,锁一个类的方法,可以防止多个线程同时调用同一个对象的这个方法,但是能够同时调用。
  • static synchronized aMethod,锁一个类的静态方法,可以防止多个线程同时这个类的该静态方法。
  • synchronized (object){代码块},把 object 对象当作该代码块的锁
  • synchronized 使用起来简单,但是有如下缺点
  • 不支持中断,可能造成其他线程等待很长的时间,甚至死锁。
  • 不支持读写锁,即读读操作是能够同时进行的,但是 synchronized 没法实现。
Lock

Lock 是 java.util.concurrent.locks 包里的一个接口,对应的 ReentrantLock 类实现了该接口。

  • 一般使用方法
public class LockTest {
    private Lock alock = new ReentrantLock(); // 锁需要定义在具体使用锁的栈帧的上一层,即若在线程里定义的话,不同的线程会 new 出不同的锁,这样就不能实现同步了。
    
    public static void main(String[] args) {
        Runnable r = () -> {
            alock.lock(); // 获得锁
            try {
                // do something
            } catch(Exception e){
                
            } finally{
                alock.unlock();
            }
        }
        Thread test = new Thread(r);
        test.start();
    }
}
  • 获得锁的方法
  • lock(): 获取锁,若失败,则等待
  • tryLock(long time, TimeUnit unit): 尝试获得锁,返回一个布尔值,表明是否获得到了锁。
  • lockInterruptibly(): 若某一个线程使用这个方法等待获取锁,那么可以通过 thread.interrupt() 的方法去让他中断等待,干别的事。
  • 除此之外,java.util.concurrent.locks 包内还定义有 ReadWriteLock 接口,并有多种读写锁的实现类。
volatile

一种轻量级同步机制,能够保证 volatile 修饰的变量具有可见性,但不具备原子性

  • 原子性与可见性
  • 原子性:在多线程并发的条件下,对于变量的操作是线程安全的,不会受到其他线程的干扰。Atomatic 基于底层硬件处理器提供的原子指令,保证并发时线程安全。
  • 可见性:在多线程并发的条件下,对于变量的修改,其他线程中能获取到修改后的。volatile 通过对于值的操作,会立即更新到主存中,当其他线程获取该值会从主存中获取。
  • 使用方法与 synchronized 一样,都是 Java 关键词。
Atomatic

前面提到过 Atomatic 是一种乐观锁,它是通过操作的原子性来保证自己的线程安全的,即操作是不可被打断的,且具有排他性。当某一线程进行该原子操作时,其他想要执行该操作的线程只能处于自旋状态,等待该操作完成。

  • 其实,这个给人的感觉,atomatic 有点像轻量级锁,不过这种线程的等待,不是通过软件实现的,而是通过硬件实现的(硬件上的原子操作)。
  • 不过这种依靠硬件上的原子操作实现的锁机制,导致 atomatic 的相关操作都比较基础。
  • 使用方法:参见 java.util.concurrent.atomic