java的锁：公平锁，非公平锁，可重入锁，自旋锁，独占锁（写锁） / 共享锁（读锁） / 互斥锁

最新推荐文章于 2024-04-13 13:42:15 发布

Hai-Yang-code

最新推荐文章于 2024-04-13 13:42:15 发布

阅读量336

点赞数

分类专栏：面试专栏文章标签： java

本文链接：https://blog.csdn.net/weixin_45007916/article/details/108094587

版权

面试专栏专栏收录该内容

39 篇文章 1 订阅

订阅专栏

公平锁和非公平锁

公平锁

是指多个线程按照申请锁的顺序来获取锁，类似于排队买饭，先来后到，先来先服务，就是公平的，也就是队列

非公平锁

是指多个线程获取锁的顺序，并不是按照申请锁的顺序，有可能申请的线程比先申请的线程优先获取锁，在高并发环境下，有可能造成优先级翻转，或者饥饿的线程（也就是某个线程一直得不到锁），类似于允许排队加塞。。。

如何创建

并发包中ReentrantLock的创建可以指定析构函数的boolean类型来得到公平锁或者非公平锁，默认是非公平锁

synchronized修饰的也是非公平锁

/**
* 创建一个可重入锁，true 表示公平锁，false 表示非公平锁。默认非公平锁
*/
Lock lock = new ReentrantLock(true);

两者区别

公平锁：就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列中的第一个，就占用锁，否者就会加入到等待队列中，以后安装FIFO的规则从队列中取到自己

非公平锁： 非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁那种方式。

可重入锁（递归锁）

概念

可重入锁就是递归锁

指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取到该锁的代码，在同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁

也就是说：线程可以进入任何一个它已经拥有的锁所同步的代码块

ReentrantLock / Synchronized 就是一个典型的可重入锁

代码举例：

package com.qcby.bilbil.gc;

/**
 * @author HuangHaiyang
 * @date 2020/08/19
 * @description: description
 * @version: 1.0.0
 */

class Method{
    
    public synchronized void method1(){
        method2();
    }
    public synchronized void method2(){

    }
}

可重入锁就是，在一个method1方法中加入一把锁，方法2也加锁了，那么他们拥有的是同一把锁。也就是说我们只需要进入method1后，那么它也能直接进入method2方法，因为他们所拥有的锁，是同一把。

作用

可重入锁的最大作用就是避免死锁。

可重入锁验证

证明Synchronized

package com.qcby.bilbil.gc;

/**
 * @author HuangHaiyang
 * @date 2020/08/19
 * @description: description
 * @version: 1.0.0
 */

class Phone{

    public synchronized void sendSms(){
        System.out.println(Thread.currentThread().getName()+" 在发短信");
        // 在同步方法中，调用另外一个同步方法
        sendEmail();
    }

    public synchronized void sendEmail(){
        System.out.println(Thread.currentThread().getName()+" 在发邮件");
    }
}

public class ReentrantDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(phone::sendSms,"t1线程").start();

        new Thread(phone::sendSms,"t2线程").start();
    }
}

结果

t1线程 在发短信
t1线程 在发邮件
t2线程 在发短信
t2线程 在发邮件

这就说明当 t1 线程进入sendSMS的时候，拥有了一把锁，同时t2线程无法进入，直到t1线程拿着锁，执行了sendEmail 方法后，才释放锁，这样t2才能够进入。t1线程在外层方法获取锁的时候，t1在进入内层方法会自动获取锁。

证明ReentrantLock

package com.qcby.bilbil.gc;

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

/**
 * @author HuangHaiyang
 * @date 2020/08/19
 * @description: description
 * @version: 1.0.0
 */

class Phone{

    Lock lock=new ReentrantLock();
    public void getLock(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+" getLock");
            setLock();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void setLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+" setLock");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

public class ReentrantDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(phone::getLock,"t3线程").start();
        new Thread(phone::getLock,"t4线程").start();
    }
}

结果

t4线程 getLock
t4线程 setLock
t3线程 getLock
t3线程 setLock

最后输出结果我们能发现，结果和加synchronized方法是一致的，都是在外层的方法获取锁之后，线程能够直接进入里层

当我们在getLock方法加两把锁会是什么情况呢？

public void getLock(){
        lock.lock();
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+" getLock");
            setLock();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }

结果不变因为里面不管有几把锁，其它他们都是同一把锁，也就是说用同一个钥匙都能够打开

当我们在getLock方法加两把锁，但是只解一把锁会出现什么情况呢？

public void getLock(){
        lock.lock();
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+" getLock");
            setLock();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

程序直接卡死，线程不能出来，也就说明我们申请几把锁，最后需要解除几把锁

当我们只加一把锁，但是用两把锁来解锁的时候，又会出现什么情况呢？

 public void getLock(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+" getLock");
            setLock();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

这个时候，运行程序会直接报错

t3线程 getLock
t3线程 setLock
t4线程 getLock
t4线程 setLock
Exception in thread "t4线程" Exception in thread "t3线程" java.lang.IllegalMonitorStateException
	at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
	at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
	at com.qcby.bilbil.gc.Phone.getLock(ReentrantDemo.java:35)
	at java.lang.Thread.run(Thread.java:745)
java.lang.IllegalMonitorStateException
	at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
	at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
	at com.qcby.bilbil.gc.Phone.getLock(ReentrantDemo.java:35)
	at java.lang.Thread.run(Thread.java:745)

Process finished with exit code 0

自旋锁

自旋锁：spinlock，是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU

原来提到的CAS，底层使用的就是自旋，自旋就是多次尝试，多次访问，不会阻塞的状态就是自旋。
在这里插入图片描述

优缺点

优点：循环比较获取直到成功为止，没有类似于wait的阻塞

缺点：当不断自旋的线程越来越多的时候，会因为执行while循环不断的消耗CPU资源

手写自旋锁

通过CAS操作完成自旋锁，A线程先进来调用myLock方法自己持有锁5秒，B随后进来发现当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到

package com.qcby.bilbil.gc;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/**
 * @author HuangHaiyang
 * @date 2020/08/19
 * @description: description
 * @version: 1.0.0
 */



public class SpinLockDemo {

    AtomicReference<Thread> acquireThread = new AtomicReference<> ();

    public void myLock() {
        // 获取当前进来的线程
        Thread thread=Thread.currentThread();

        System.out.println(Thread.currentThread().getName()+" 进入");

        // 开始自旋，期望值是null，更新值是当前线程，如果是null，则更新为当前线程，否者自旋
        while (!acquireThread.compareAndSet(null,thread)){

        }

    }

    public void myUnlock(){
        // 获取当前进来的线程
        Thread thread=Thread.currentThread();

        // 自己用完了后，把atomicReference变成null
        acquireThread.compareAndSet(thread, null);

        System.out.println(Thread.currentThread().getName()+" 完成");
    }

    public static void main(String[] args) {

        SpinLockDemo spinLockDemo=new SpinLockDemo();

        new Thread(()->{
            // 开始占有锁
            spinLockDemo.myLock();
            //占有5秒
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //释放锁
            spinLockDemo.myUnlock();

        },"t1线程").start();

        // 让main线程暂停1秒，保证t1线程先执行
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        // 1秒后，启动t2线程，开始占用这个锁
        new Thread(() -> {

            // 开始占有锁
            spinLockDemo.myLock();
            // 开始释放锁
            spinLockDemo.myUnlock();

        }, "t2线程").start();


    }

}

t1线程 进入
t2线程 进入

。。。。
t1线程 完成
t2线程 完成

独占锁（写锁） / 共享锁（读锁） / 互斥锁

概念

独占锁：指该锁一次只能被一个线程所持有。对ReentrantLock和Synchronized而言都是独占锁

共享锁：指该锁可以被多个线程锁持有

对ReentrantReadWriteLock其读锁是共享，其写锁是独占

写的时候只能一个人写，但是读的时候，可以多个人同时读

为什么会有写锁和读锁

原来我们使用ReentrantLock创建锁的时候，是独占锁，也就是说一次只能一个线程访问，但是有一个读写分离场景，读的时候想同时进行，因此原来独占锁的并发性就没这么好了，因为读锁并不会造成数据不一致的问题，因此可以多个人共享读。多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行，但是如果一个线程想去写共享资源，就不应该再有其它线程可以对该资源进行读或写。

读-读：能共存

读-写：不能共存

写-写：不能共存

代码实现

package com.qcby.bilbil.gc;

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

/**
 * @author HuangHaiyang
 * @date 2020/08/19
 * @description: description
 * @version: 1.0.0
 */

class MyCache{

    private volatile Map<String,String> map=new HashMap<>();
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void put(String key, String value) {

        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在写入：" + key);
            try {
                // 模拟网络拥堵，延迟0.3秒
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "\t 写入完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }
    public void get(String key) {
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在读取:");
            try {
                // 模拟网络拥堵，延迟0.3秒
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String value = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t 读取完成：" + value);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }

}

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        // 线程操作资源类，5个线程写
        for (int i = 0; i < 5; i++) {
            // lambda表达式内部必须是final
            final int tempInt = i;
            new Thread(() -> {
                myCache.put(tempInt + "", tempInt +  "");
            }, String.valueOf(i)).start();
        }
        // 线程操作资源类， 5个线程读
        for (int i = 0; i < 5; i++) {
            // lambda表达式内部必须是final
            final int tempInt = i;
            new Thread(() -> {
                myCache.get(tempInt + "");
            }, String.valueOf(i)).start();
        }
    }
}

0	 正在写入：0
0	 写入完成
1	 正在写入：1
1	 写入完成
2	 正在写入：2
2	 写入完成
3	 正在写入：3
3	 写入完成
4	 正在写入：4
4	 写入完成
0	 正在读取:
2	 正在读取:
1	 正在读取:
4	 正在读取:
3	 正在读取:
0	 读取完成：0
3	 读取完成：3
4	 读取完成：4
1	 读取完成：1
2	 读取完成：2

Process finished with exit code 0

从运行结果我们可以看出，写入操作是一个一个线程进行执行的，并且中间不会被打断，而读操作的时候，是同时5个线程进入，然后并发读取操作

Hai-Yang-code

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
java的锁：公平锁，非公平锁，可重入锁，自旋锁，独占锁（写锁） / 共享锁（读锁） / 互斥锁

公平锁和非公平锁公平锁是指多个线程按照申请锁的顺序来获取锁，类似于排队买饭，先来后到，先来先服务，就是公平的，也就是队列非公平锁是指多个线程获取锁的顺序，并不是按照申请锁的顺序，有可能申请的线程比先申请的线程优先获取锁，在高并发环境下，有可能造成优先级翻转，或者饥饿的线程（也就是某个线程一直得不到锁），类似于允许排队加塞。。。如何创建并发包中ReentrantLock的创建可以指定析构函数的boolean类型来得到公平锁或者非公平锁，默认是非公平锁synchronized修饰的也是非公平锁/
复制链接

扫一扫