Java锁的深入

最新推荐文章于 2024-03-21 10:30:00 发布

飘来荡去、、

最新推荐文章于 2024-03-21 10:30:00 发布

阅读量177

点赞数

分类专栏：并发编程文章标签：重入锁读写锁悲观锁乐观锁 CAS无锁机制

本文链接：https://blog.csdn.net/lyj2018gyq/article/details/84989887

版权

并发编程专栏收录该内容

14 篇文章 0 订阅

订阅专栏

一、重入锁

重入锁，也叫做递归锁，指的是同一线程外层函数获得锁之后，内层递归函数仍然有获取该锁的权限。ReentrantLock 和synchronized 都是可重入锁。锁可以传递~。主要就是用来避免死锁的，假设一个类中的所有方法都加锁，当方法之间进行调用时，如果锁是不可重入的，那么就永远调用不了其它方法，因为锁没有释放（都用同一把锁）

轻量级锁（Lock）

重量级锁（synchronized）

区别：Lock要手动释放锁

1.1 synchronized

举例：同一线程在调用自己类中其他synchronized方法/块或调用父类的synchronized方法/块都不会阻碍该线程的执行，就是说同一线程对同一个对象锁是可重入的，而且同一个线程可以获取同一把锁多次，也就是可以多次重入。

package com.thread.lock;

/**
 * @Author: 98050
 * @Time: 2018-12-13 16:29
 * @Feature: 证明synchronized是可重入锁
 */
public class Test implements Runnable{
    public void run() {
        get();
    }

    public synchronized void get(){
        System.out.println("name:"+Thread.currentThread().getName()+",get()");
        set();
    }

    public synchronized void set(){
        System.out.println("name:"+Thread.currentThread().getName()+",set()");
    }

    public static void main(String[] args) {
        Test test = new Test();
        new Thread(test).start();
        new Thread(test).start();
        new Thread(test).start();
        new Thread(test).start();
    }
}

1.2 lock

lock可传递

package com.thread.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: 98050
 * @Time: 2018-12-13 16:43
 * @Feature: 证明lock锁是可重入锁
 */
public class Test002 extends Thread{

    Lock lock = new ReentrantLock();


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

    private void get(){
        try {
            lock.lock();
            System.out.println("name:"+Thread.currentThread().getName()+",get()");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        set();
    }

    private void set(){

        try {
            lock.lock();
            System.out.println("name:"+Thread.currentThread().getName()+",set()");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Test002 test002 = new Test002();
        test002.start();
    }
}

二、读写锁

相比Java中的锁(Locks in Java)里Lock实现，读写锁更复杂一些。假设你的程序中涉及到对一些共享资源的读和写操作，且写操作没有读操作那么频繁。在没有写操作的时候，两个线程同时读一个资源没有任何问题，所以应该允许多个线程能在同时读取共享资源。但是如果有一个线程想去写这些共享资源，就不应该再有其它线程对该资源进行读或写（也就是说：读-读能共存，读-写不能共存，写-写不能共存）。这就需要一个读/写锁来解决这个问题。

示例

package com.thread.lock;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @Author: 98050
 * @Time: 2018-12-13 17:27
 * @Feature: 读写锁
 */
public class Test003 {

    private volatile Map<String,String> cache = new HashMap<String, String>();

    /**
     * 读写锁
     */
    private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

    /**
     * 写入锁
     */
    private ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
    /**
     * 读取锁
     */
    private ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();

    /**
     * 写入元素
     * @param key
     * @param value
     */
    public void put(String key,String value){
        try{
            writeLock.lock();
            System.out.println("写入put方法key:"+key+",value："+value+",开始");
            cache.put(key, value);
            Thread.sleep(300);
            System.out.println("写入put方法key:"+key+",value："+value+",结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            writeLock.unlock();
        }
    }

    /**
     * 读取元素
     * @param key
     * @return
     */
    public String get(String key){

        try {
            readLock.lock();
            System.out.println("读取key:"+key+",开始");
            Thread.sleep(300);
            String value = cache.get(key);
            System.out.println("读取key:"+key+",结束");
            return value;
        } catch (Exception e) {
            return null;
        } finally {
            readLock.unlock();
        }
    }

    public static void main(String[] args) {
        final Test003 test003 = new Test003();

        Thread thread = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 5; i++) {
                    test003.put(i+"", i+"");
                }
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("获取数据：" + test003.get(i+""));
                }
            }
        });

        thread.start();
        thread2.start();
    }

}

结果

为什么不使用synchronized

synchronized每回只能允许一个线程进入方法中，那么多个读取方法就会阻塞；而且使用synchronized会产生脏读，即还没有写入就去读，就得不到数据。

三、悲观锁和乐观锁

3.1 乐观锁

总是认为不会产生并发问题，每次去取数据的时候总认为不会有其他线程对数据进行修改，因此不会上锁，但是在更新时会判断其他线程在这之前有没有对数据进行修改，一般会使用版本号机制或CAS操作实现。

version方式：一般是在数据表中加上一个数据版本号version字段，表示数据被修改的次数，当数据被修改时，version值会加一。当线程A要更新数据值时，在读取数据的同时也会读取version值，在提交更新时，若刚才读取到的version值为当前数据库中的version值相等时才更新，否则重试更新操作，直到更新成功。

核心SQL语句

update table set x=x+1, version=version+1 where id=id and version=version;

先通过select语句获取到id对应的版本号

其它解释：

乐观锁，大多是基于数据版本（ Version ）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个 “version” 字段来实现。

读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数据版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。

假设数据库中帐户信息表中有一个 version 字段，当前值为 1 ；而当前帐户余额字段（ balance ）为 $100 。

1 操作员 A 此时将其读出（ version=1 ），并从其帐户余额中扣除 $50（ $100-$50 ）。

2 在操作员 A 操作的过程中，操作员B 也读入此用户信息（ version=1 ），并从其帐户余额中扣除 $20 （ $100-$20 ）。

3 操作员 A 完成了修改工作，将数据版本号加一（ version=2 ），连同帐户扣除后余额（ balance=$50 ），提交至数据库更新，此时由于提交数据版本大于数据库记录当前版本，数据被更新，数据库记录 version 更新为 2 。

4 操作员 B 完成了操作，也将版本号加一（ version=2 ）试图向数据库提交数据（ balance=$80 ），但此时比对数据库记录版本时发现，操作员 B 提交的数据版本号为 2 ，数据库记录当前版本也为 2 ，不满足 “ 提交版本必须大于记录当前版本才能执行更新 “ 的乐观锁策略，因此，操作员 B 的提交被驳回。

这样，就避免了操作员 B 用基于 version=1 的旧数据修改的结果覆盖操作员A 的操作结果的可能。

CAS操作方式：即compare and swap 或者 compare and set，涉及到三个操作数，数据所在的内存值，预期值，新值。当需要更新时，判断当前内存值与之前取到的值是否相等，若相等，则用新值更新，若失败则重试，一般情况下是一个自旋操作，即不断的重试。

3.2 悲观锁

总是假设最坏的情况，每次取数据时都认为其他线程会修改，所以都会加锁（读锁、写锁、行锁等），当其他线程想要访问数据时，都需要阻塞挂起。可以依靠数据库实现，如行锁、读锁和写锁等，都是在操作之前加锁，在Java中，lock、synchronized的思想也是悲观锁。

四、CAS无锁机制

4.1 原子类

4.1.1 使用悲观锁解决线程安全问题

使用悲观锁（synchronized）

代码：

package com.thread.lock;

/**
 * @Author: 98050
 * @Time: 2018-12-13 21:47
 * @Feature: 原子类的使用
 */
public class Test004 extends Thread {

    private static int COUNT = 0;


    @Override
    public void run() {
        while (true){
            Integer count = null;
            try {
                count = getCount();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count > 20){
                break;
            }
            System.out.println(count);
        }
    }

    /**
     * synchronized具有可重入性、保证原子性和可见性，但是对程序的执行效率有影响，不能禁止重排序，不能解决重排序问题
     * @return
     * @throws InterruptedException
     */
    private synchronized Integer getCount() throws InterruptedException {
        Thread.sleep(300);
        return COUNT ++;
    }

    public static void main(String[] args) {
        Test004 t1 = new Test004();
        Test004 t2 = new Test004();

        t1.start();
        t2.start();
    }
}

为什么加了synchronized还会产生问题？因为创建了两个线程，不同的对象，用的是不同的锁！

修改代码：用同一把object锁~

package com.thread.lock;

/**
 * @Author: 98050
 * @Time: 2018-12-13 21:47
 * @Feature: 原子类的使用
 */
public class Test004 extends Thread {

    private static int COUNT = 0;
    private static Object object = new Object();

    @Override
    public void run() {
        while (true){
            Integer count = null;
            try {
                count = getCount();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count > 20){
                break;
            }
            System.out.println(count);
        }
    }

    /**
     * synchronized具有可重入性、保证原子性和可见性，但是对程序的执行效率有影响，不能禁止重排序，不能解决重排序问题
     * @return
     * @throws InterruptedException
     */
    private Integer getCount() throws InterruptedException {
        synchronized(object) {
            Thread.sleep(300);
            return COUNT++;
        }
    }

    public static void main(String[] args) {
        Test004 t1 = new Test004();
        Test004 t2 = new Test004();

        t1.start();
        t2.start();
    }
}

这下就没有问题了~

4.1.2 使用乐观锁解决线程安全问题

package com.thread.lock;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author: 98050
 * @Time: 2018-12-13 22:35
 * @Feature: 使用乐观锁解决线程安全问题(原子类)
 */
public class Test005 extends Thread {

    /**
     * 线程安全的i++
     */
    private AtomicInteger atomicInteger = new AtomicInteger();

    @Override
    public void run() {
        while (true){
            Integer count = null;
            try {
                count = getCount();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count > 20){
                break;
            }
            System.out.println(count);
        }
    }

    /**
     *
     * @return AtomicInteger底层没有使用锁，使用CAS无锁机制
     * @throws InterruptedException
     */
    private Integer getCount() throws InterruptedException {
        Thread.sleep(300);
        return atomicInteger.incrementAndGet();
    }

    public static void main(String[] args) {
        Test004 t1 = new Test004();
        Test004 t2 = new Test004();

        t1.start();
        t2.start();
    }

}

4.2 CAS无锁模式

4.2.1 什么是CAS

CAS：Compare and Swap，即比较再交换。

jdk5增加了并发包java.util.concurrent.*,其下面的类使用CAS算法实现了区别于synchronouse同步锁的一种乐观锁。JDK 5之前Java语言是靠synchronized关键字保证同步的，这是一种独占锁，也是是悲观锁。

4.2.2 CAS算法理解

（1）与锁相比，使用比较交换（下文简称CAS）会使程序看起来更加复杂一些。但由于其非阻塞性，它对死锁问题天生免疫，并且，线程间的相互影响也远远比基于锁的方式要小。更为重要的是，使用无锁的方式完全没有锁竞争带来的系统开销，也没有线程间频繁调度带来的开销，因此，它要比基于锁的方式拥有更优越的性能。

（2）无锁的好处：

第一，在高并发的情况下，它比有锁的程序拥有更好的性能；

第二，它天生就是死锁免疫的。

就凭借这两个优势，就值得我们冒险尝试使用无锁的并发。

（3）CAS算法的过程是这样：它包含三个参数CAS(V,E,N): V表示要更新的变量，E表示预期值，N表示新值。仅当V值等于E值时，才会将V的值设为N，如果V值和E值不同，则说明已经有其他线程做了更新，则当前线程什么都不做。最后，CAS返回当前V的真实值。结合Java内存模型进行理解：

（4）CAS操作是抱着乐观的态度进行的，它总是认为自己可以成功完成操作。当多个线程同时使用CAS操作一个变量时，只有一个会胜出，并成功更新，其余均会失败。失败的线程不会被挂起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃操作。基于这样的原理，CAS操作即使没有锁，也可以发现其他线程对当前线程的干扰，并进行恰当的处理。

（5）简单地说，CAS需要你额外给出一个期望值，也就是你认为这个变量现在应该是什么样子的。如果变量不是你想象的那样，那说明它已经被别人修改过了。你就重新读取，再次尝试修改就好了。

（6）在硬件层面，大部分的现代处理器都已经支持原子化的CAS指令。在JDK 5.0以后，虚拟机便可以使用这个指令来实现并发操作和并发数据结构，并且，这种操作在虚拟机中可以说是无处不在。

4.2.3 CAS源码分析

    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

CAS比较与交换的伪代码可以表示为：

do{
       备份旧数据；
       基于旧数据构造新数据；
}while(!CAS( 内存地址，备份的旧数据，新数据 ))

上图的解释：CPU去更新一个值，但如果想改的值不再是原来的值，操作就失败，因为很明显，有其它操作先改变了这个值。

就是指当两者进行比较时，如果相等，则证明共享数据没有被修改，替换成新值，然后继续往下运行；如果不相等，说明共享数据已经被修改，放弃已经所做的操作，然后重新执行刚才的操作。容易看出 CAS 操作是基于共享数据不会被修改的假设，采用了类似于数据库的 commit-retry 的模式。当同步冲突出现的机会很少时，这种假设能带来较大的性能提升。

所以CAS是自旋锁实现的

4.2.4 CAS的缺点

CAS存在一个很明显的问题，即ABA问题。

问题：如果变量V初次读取的时候是A，并且在准备赋值的时候检查到它仍然是A，那能说明它的值没有被其他线程修改过了吗？

如果在这段期间曾经被改成B，然后又改回A，那CAS操作就会误认为它从来没有被修改过。针对这种情况，java并发包中提供了一个带有标记的原子引用类AtomicStampedReference，它可以通过控制变量值的版本来保证CAS的正确性。

五、自旋锁

5.1 什么是自旋锁

自旋锁（spinlock）：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。

获取锁的线程一直处于活跃状态，但是并没有执行任何有效的任务，使用这种锁会造成busy-waiting。

5.2 实现

自旋锁是采用让当前线程不停地的在循环体内执行实现的，当循环的条件被其他线程改变时才能进入临界区。如下：

public class SpinLock {
    private AtomicReference<Thread> cas = new AtomicReference<Thread>();
    public void lock() {
        Thread current = Thread.currentThread();
        // 利用CAS
        while (!cas.compareAndSet(null, current)) {
            // DO nothing
        }
    }
    public void unlock() {
        Thread current = Thread.currentThread();
        cas.compareAndSet(current, null);
    }
}

lock（)方法利用的CAS，当第一个线程A获取锁的时候，能够成功获取到，不会进入while循环，如果此时线程A没有释放锁，另一个线程B又来获取锁，此时由于不满足CAS，所以就会进入while循环，不断判断是否满足CAS，直到A线程调用unlock方法释放了该锁。

5.3 自旋锁存在的问题

如果某个线程持有锁的时间过长，就会导致其它等待获取锁的线程进入循环等待，消耗CPU。使用不当会造成CPU使用率极高。
上面Java实现的自旋锁不是公平的，即无法满足等待时间最长的线程优先获取锁。不公平的锁就会存在“线程饥饿”问题。

5.4 自旋锁的优点

自旋锁不会使线程状态发生切换，一直处于用户态，即线程一直都是active的；不会使线程进入阻塞状态，减少了不必要的上下文切换，执行速度快
非自旋锁在获取不到锁的时候会进入阻塞状态，从而进入内核态，当获取到锁的时候需要从内核态恢复，需要线程上下文切换。（线程被阻塞后便进入内核（Linux）调度状态，这个会导致系统在用户态与内核态之间来回切换，严重影响锁的性能）

5.5 自旋锁和互斥锁的区别

互斥锁：线程会从sleep（加锁）——>running（解锁），过程中有上下文的切换，cpu的抢占，信号的发送等开销。悲观锁

自旋锁：线程一直是running（加锁——>解锁），死循环检测锁的标志位 乐观锁

其实，自旋锁与互斥锁比较类似，它们都是为了解决对某项资源的互斥使用。无论是互斥锁，还是自旋锁，在任何时刻，最多只能有一个保持者，也就说，在任何时刻最多只能有一个执行单元获得锁。但是两者在调度机制上略有不同。对于互斥锁，如果资源已经被占用，资源申请者只能进入睡眠状态。但是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁，”自旋”一词就是因此而得名。