Java锁机制

最新推荐文章于 2024-03-11 16:53:19 发布
最新推荐文章于 2024-03-11 16:53:19 发布
阅读量173 收藏
点赞数
分类专栏： InterviewRequestions Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38826019/article/details/110819624
版权

一、公平锁和非公平锁

1.1 是什么

1.1.1 公平锁

是指多个线程按照申请锁的顺序来获取锁，类似排队打饭先来后到

1.1.2 非公平锁

是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取到锁，在高并发情况下，有可能造成优先级反转或者饥饿现象(一直被别人加塞，后面的一直等待)

通俗理解：排队打饭，正常情况下，先到先打，突然来了一个人，加塞到第一个人前面先打饭，这就不公平了吧

1.2 区别

公平锁

Threads acuire a fair lock in the order in which they requested it

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

非公平锁

a nonfair lock permits barging: threads requesting a lock can jump ahead of the queue of waiting threads if the lock happens to be available when it is requested.

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

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

对于Java ReentrantLock而言

通过构造函数指定该锁是否是公平锁，默认是非公平锁，非公平锁的优点在于吞吐量比公平锁大

对于synchronized而言，也是一种非公平锁。

二、可重入锁(递归锁)

2.1 是什么

指的是同一个线程，外层函数获得锁之后，内层递归函数仍然能够获取该锁的代码，

同一个线程，在外层方法获取锁的时候，再进入内层方法会自动获取锁

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

//可重入锁也叫递归锁，作用防止死锁
public class JavaLock {

    //我已经进入我家大门了，我再次进入我家厨房不用再获取锁
    public sync void method01() {
        method01();
    }

    public sync void method02() {
        //todo
    }
}

2.2 作用

ReentrantLock/synchronized就是一个典型的可重入锁，可重入锁最大的作用就是避免死锁

2.3 代码示例

2.3.1 synchronzied可重入锁

//资源类
class Phone {
    //同步方法可以进入另外一个同步方法
    //同步方法
    public synchronized void sendSMS() throws Exception {
        System.out.println(Thread.currentThread().getName() + "\t invoked sendSMS()");
        sendEmail();
    }

    //同步方法
    public synchronized void sendEmail() throws Exception {
        System.out.println(Thread.currentThread().getName() + "\t ####invoked sendEmail()");
    }
}
//可重入锁也叫递归锁，作用防止死锁
public class JavaLock {
    public static void main(String[] args) {
        Phone phone = new Phone();
        //线程操纵资源类
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "t1").start();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "t2").start();
    }
}

2.3.2 ReentrantLock可重入锁

class Phone1 implements Runnable {

    private Lock lock = new ReentrantLock();

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

    private void get() {
        //可以出现多个lock,unlock，但是，lock，unlock数量要匹配
        lock.lock();
        lock.lock();
        try {
            //线程可以进入任何一个它已经拥有的锁
            //所同步着的代码块
            System.out.println(Thread.currentThread().getName() + "\t invoked get");
            set();
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }

    private void set() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t ***** invoked set");
        } finally {
            lock.unlock();
        }
    }
}
public class ReentrantLockDemo {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();
        Thread t3 = new Thread(phone1, "t3");
        Thread t4 = new Thread(phone1, "t4");
        t3.start();
        t4.start();
    }
}

三、自旋锁

3.1 概念

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

例如，CAS底层

如果当前对象的值，与期望值一直不相等，则会一直循环获取，会消耗大量CPU资源

3.2 通俗解释

假如，老师在讲台上讲课，突然接了个电话，但是，小明现在有问题要问老师

第一种情况

阻塞：小明在旁边等老师打完电话，然后问老师，这时候啥也不能做，单纯的等着

第二种情况

循环：小明先去做自己的事情，过一会看老师打完电话没有，如果没有接着去做其他事情，然后再看老师有没有打完电话，循环的方式去查看。

3.3 手写自旋锁

3.3.1 自旋锁的好处

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

public class SpinLockDemo {

    //原子引用线程,默认为null
    AtomicReference<Thread> atomicReference = new AtomicReference<>();
    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t come in");
        while (!atomicReference.compareAndSet(null, thread)) {
            System.out.println("尝试获取锁失败，等待释放锁");
        }
    }

    public void myUnlock() {
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread, null);
        System.out.println(Thread.currentThread().getName() + "\t invoiked myUnlock");
    }

    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(() -> {
            spinLockDemo.myLock();
            //暂停一会儿线程
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnlock();
        }, "AA").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnlock();
        }, "BB").start();

    }
}

四、独占锁(写)

4.1 概念

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

机场航班信息，能被机场所有旅客共享，但是，展示的内容只能有机场的工作人员来改动

五、共享锁(读)

5.1 概念

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

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

读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的 

5.2 问题

/**
 * 资源类
 */
class MyCache {
    //保证可见性
    private volatile Map<String, Object> map = new HashMap<>();
    //private Lock lock = new ReentrantLock();

    //写操作
    public void put(String key, Object value) {
        System.out.println(Thread.currentThread().getName() + "\t 正在写入: " + key);
        //暂停一会儿线程
        try {
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + "\t 写入完成: ");
    }

    //读操作
    public void get(String key) {
        System.out.println(Thread.currentThread().getName() + "\t 正在读取: ");
        try {
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Object result = map.get(key);
        System.out.println(Thread.currentThread().getName() + "\t 读取完成: " + result);
    }
}

/**
 * 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。
 * 但是
 * 如果有一个线程想去写共享资源，就不应该再有其他线程可以对该资源进行读或写
 * 读-读能共存
 * 读-写不能共存
 * 写-写不能共存
 * 写操作：原子+独占，整个过程必须是一个完整的统一体，中间不许被分割，被打断
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.put(temp + "", temp);
            }, String.valueOf(i)).start();
        }

        for (int i = 1; i <= 5; i++) {
            int finalI = i;
            new Thread(() -> {
                myCache.get(finalI + "");
            }, String.valueOf(i)).start();
        }
    }
}

5.3 ReentrantReadWriteLock优化

/**
 * 资源类
 */
class MyCache {

    //保证可见性
    private volatile Map<String, Object> map = new HashMap<>();
    //private Lock lock = new ReentrantLock();
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    //写操作
    public void put(String key, Object value) {
        rwLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在写入: " + key);
            //暂停一会儿线程
            try {
                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 {
            rwLock.writeLock().unlock();
        }
    }

    //读操作
    public void get(String key) {
        rwLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在读取: ");
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t 读取完成: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rwLock.readLock().unlock();
        }
    }
}

/**
 * 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。
 * 但是
 * 如果有一个线程想去写共享资源，就不应该再有其他线程可以对该资源进行读或写
 * 读-读能共存
 * 读-写不能共存
 * 写-写不能共存
 * 写操作：原子+独占，整个过程必须是一个完整的统一体，中间不许被分割，被打断
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.put(temp + "", temp);
            }, String.valueOf(i)).start();
        }

        for (int i = 1; i <= 5; i++) {
            int finalI = i;
            new Thread(() -> {
                myCache.get(finalI + "");
            }, String.valueOf(i)).start();
        }
    }
}

六、悲观锁

悲观锁(Pessimistic Lock)，顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。

七、乐观锁

乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。(获取version，更新的时候比较version)。乐观锁适用于多读的应用类型，这样可以提高吞吐量。

乐观锁策略：提交版本必须大于记录的当前版本才能执行更新。

orderCodephonenamelock_version
117816110623jak1

现在，张三要对上面运单号为1的数据，做更新操作。更新之前，首先要查出此数据吧，Vo vo = findVoByOrderCode(String orderCode)，然后，vo.setName(newName)，最后执行更新操作。此时，李四这个人也要改运单号为1的手机号，两个人几乎同时进行，查出来的版本号，这时查出来的版本号都为1。但是，李四的事务执行比较快，先于张三更改完成，将版本号lock_version设为了2。此时，张三事务也将结束，但是，在执行更新操作的时候，发现自己的版本号是1，而服务器上的版本号为2，张三一提交立即报异常。这个时候需要，张三重新从数据库查出最新的，再次提交更新。

update test_table set name = 'jak', lock_version = #{lockVersion} + 1 where orderCode = 1 and lock_version = #{lockVersion};

视频教程，源码链接

星夜孤帆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一篇文章即可读懂java中的锁机制
cuichunchi的博客
03-27 2万+
在java中的锁分为以下（其实就是按照锁的特性和设计来划分）： 1、公平锁/非公平锁 2、可重入锁 3、独享锁/共享锁 4、互斥锁/读写锁 5、乐观锁/悲观锁 6、分段锁 7、偏向锁/轻量级锁/重量级锁 8、自旋锁（java.util.concurrent包下的几乎都是利用锁） 从底层角度看常见的锁也就两种：Synchronized和Lock接口以及ReadWriteLock接口...
Java锁机制详解.pdf
11-02
Java锁机制详解.pdf java线程 java多线程 Java锁机制详解.pdf java线程 java多线程
java中的锁
枕头
05-30 2707
       参考文章：JAVA锁机制一段synchronized的代码被一个线程执行之前，他要先拿到执行这段代码的权限，在java里边就是拿到某个同步对象的锁（一个对象只有一把锁）； 如果这个时候同步对象的锁被其他线程拿走了，他（这个线程）就只能等了（线程阻塞在锁池等待队列中）。 取到锁后，他就开始执行同步代码(被synchronized修饰的代码）；线程执行完同步代码后马上就把锁还给同步对象，...
java Lock锁详解
qq_42077317的博客
03-11 1278
1.公平锁：就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己。await(long time, TimeUnit unit)：使当前线程等待一段时间，在指定的时间内没有被其他线程调用signal()或signalAll()方法唤醒，将自动唤醒。await()：使当前线程等待，直到被其他线程调用signal()或signalAll()方法唤醒。
java线程的上锁
Grit_ICPC的博客
08-08 482
import java.io.*; import java.lang.*; import java.util.*; public class hehe implements Runnable{ Timer ti = new Timer(); public static void main(String args[]){ hehe he = new hehe(); Thread t1 =
java锁
qq_37466464的博客
04-30 5354
1.悲观锁 ：锁住资源其他线程不能在访问 2.乐观锁： 不锁资源，默认其他进程不会修改资源 锁住同步资源失败 线程是否需要阻塞？ 阻塞 不阻塞： 自旋锁 适应性自旋锁 减少了线程上下文的其二环 因为是不阻塞 而是一直原地等待 多线程竞争同步资源的流程细节有没有区别 1.不锁住资源 多个线程中只有一个能修改资源，其他线程重试 2.同意下城执行同步资源时自动获取资源 偏向锁 3.多个线程竞争同步资源时，没有获取资源的线程自旋等...
java上锁方式
qq_56352553的博客
07-14 321
2.同步class 3.lock String name = Thread.currentThread().getName(); // 2、判断余额是否足够 // 小明 小红 lock.lock(); // 上锁 try { if(this.money >= money){ // 钱够了 System.out.println(name+“来取钱，吐出：” + money); // 更新余额 this.money -= money; System.out.println(name+“取钱后，余额剩余：”
Java锁机制Lock用法示例
08-27
主要介绍了Java锁机制Lock用法,结合具体实例形式分析了Java锁机制的相关上锁、释放锁、隐式锁、显式锁等概念与使用技巧,需要的朋友可以参考下
java锁机制详解.pdf
09-30
java锁机制详解.pdf
java锁机制Synchronized.pdf
10-27
java锁机制Synchronized.pdf
彻底理解Java中的各种锁.pdf
06-18
java各种锁机制
java锁详解.pdf
12-31
java锁详解.pdf
java锁机制Synchronized参考.pdf
02-12
java锁机制Synchronized参考.pdf
java锁机制基类AbstractQueuedSynchronizer从设计到实现到应用
06-14
从并发概念、场景分析出发，依次引出锁、等待队列等概念，直至分析清楚java锁机制实现的原理。并以java锁机制实现基类AbstractQueuedSynchronizer的实现为例，从类（核心属性、方法）设计思路，到对关键代码做注释...
java锁机制Synchronizedjava锁机制Synchronized
05-04
java锁机制Synchronized java锁机制Synchronized java锁机制Synchronized java锁机制Synchronized
面向Java锁机制的字节码自动重构框架.zip
10-16
面向Java锁机制的字节码自动重构框架
JAVA锁的问题
qq_31941773的博客
10-25 725
今天我在学习集合框架想到一个问题，发现自己对锁不太了解 起因： Hashtable是线程安全的，原因是在方法加了synchronized关键词 public synchronized V put(K key, V value) {} public synchronized V get(Object key) {} 我们在获得get方法后还可以调用put方法么，显然是不可以的，如果可以就不是...
java 加锁_Java中的各种锁
weixin_39583751的博客
12-02 1079
转自公众号Java建设者 ，作者cxuan Java 锁分类 Java 中的锁有很多，可以按照不同的功能、种类进行分类，下面是我对 Java 中一些常用锁的分类，包括一些基本的概述 https://www.javashitang.com/wp-content/uploads/2020/01/beepress8-1578910007.jpg 从线程是否需要对资源加锁可以分为 悲观锁 ...
Java锁机制，synchronized和lock详解。
记录开发日常笔记
08-16 6858
Java锁机制详解
java锁机制的应用场景
最新发布
04-11
Java锁机制是用于控制多线程并发访问共享资源的一种机制。它可以确保在同一时间只有一个线程可以访问共享资源，从而避免了数据竞争和并发访问的问题。以下是Java锁机制的几个常见应用场景： 1. 多线程同步：在多...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值