当前位置:

首页 > 编程开发 > java中各类锁的机制是什么

java中各类锁的机制是什么

前言总结java常见的锁区分各个锁机制以及如何使用使用方法锁名考察线程是否要锁住同步资源乐观锁和悲观锁锁住同步资源后,要不要阻塞不阻塞可以使用自旋锁一个线程多个流程获取同一把锁可重入锁多个线程公用一把锁读写锁(写的共享锁)多个线程竞争要不要排队公平锁与非公平锁1.乐观锁与悲观锁悲观锁:不能同时进行多人,执行的时候先上锁。传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁乐观锁:通过版本号一致与否,即给数据加上版本,同步更新数据以及加上版本号。不会上锁,判断

本文目录

    前言

    总结java常见的锁

    区分各个锁机制以及如何使用

    使用方法锁名
    考察线程是否要锁住同步资源乐观锁和悲观锁
    锁住同步资源后,要不要阻塞不阻塞可以使用自旋锁
    一个线程多个流程获取同一把锁可重入锁
    多个线程公用一把锁读写锁(写的共享锁)
    多个线程竞争要不要排队公平锁与非公平锁

    1. 乐观锁与悲观锁

    悲观锁:不能同时进行多人,执行的时候先上锁。传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁

    乐观锁:通过版本号一致与否,即给数据加上版本,同步更新数据以及加上版本号。不会上锁,判断版本号,可以多人操作,类似生活中的抢票。每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号等机制。乐观锁适用于多读的应用类型,这样可以提高吞吐量。Redis就是利用这种check-and-set机制实现事务的

    (乐观锁可以使用版本号机制和CAS算法实现)

    java中各类锁的机制是什么

    通过具体案例演示悲观锁和乐观锁

    在redis框架中

    执行multi之前,执行命令watch

    具体格式如下

    watch key1 [key2]

    具体代码格式如下

    127.0.0.1:6379> flushdb
    OK
    127.0.0.1:6379> set add 100
    OK
    127.0.0.1:6379> watch add
    OK
    127.0.0.1:6379> multi
    OK
    127.0.0.1:6379(TX)> incrby add 20
    QUEUED
    127.0.0.1:6379(TX)> exec
    1) (integer) 120
    127.0.0.1:6379>

    flushdb是清空数据库

    java中各类锁的机制是什么

    但如果在另一个服务器上,输入exec,会显示出错

    因为用的是乐观锁,被修改了之后版本会发生改变

    总的来说:

    悲观锁:单独每个人完成事情的时候,执行上锁解锁。解决并发中的问题,不支持并发操作,只能一个一个操作,效率低

    乐观锁:每执行一件事情,都会比较数据版本号,谁先提交,谁先提交版本号

    2. 公平锁与非公平锁

    公平锁:先来先到

    非公平锁:不是按照顺序,可插队

    • 公平锁:效率相对低

    • 非公平锁:效率高,但是线程容易饿死

    通过这个函数Lock lock = new ReentrantLock(true);。创建一个可重入锁,true 表示公平锁,false 表示非公平锁。默认非公平锁

    通过查看源码

    带有参数的ReentrantLock(true)为公平锁

    ReentrantLock(false)为非公平锁

    主要是调用NonfairSync()与FairSync()

    public ReentrantLock() {
            sync = new NonfairSync();
        }
    
        /**
         * Creates an instance of {@code ReentrantLock} with the
         * given fairness policy.
         *
         * @param fair {@code true} if this lock should use a fair ordering policy
         */
        public ReentrantLock(boolean fair) {
            sync = fair ? new FairSync() : new NonfairSync();
        }

    具体其非公平锁与公平锁的源码

    查看公平锁的源码

    static final class FairSync extends Sync {
       private static final long serialVersionUID = -3000897897090466540L;
    
      /**
      * Acquires only if reentrant or queue is empty.
       */
      final boolean initialTryLock() {
       Thread current = Thread.currentThread();
       int c = getState();
       if (c == 0) {
       if (!hasQueuedThreads() && compareAndSetState(0, 1)) {
         setExclusiveOwnerThread(current);
          return true;
        }
        } else if (getExclusiveOwnerThread() == current) {
          if (++c < 0) // overflow
              throw new Error("Maximum lock count exceeded");
             setState(c);
             return true;
           }
        return false;
    }

    通过代码实例具体操作

    //第一步  创建资源类,定义属性和和操作方法
    class LTicket {
        //票数量
        private int number = 30;
    
        //创建可重入锁
        private final ReentrantLock lock = new ReentrantLock(true);
        //卖票方法
        public void sale() {
            //上锁
            lock.lock();
            try {
                //判断是否有票
                if(number > 0) {
                    System.out.println(Thread.currentThread().getName()+" :卖出"+(number--)+" 剩余:"+number);
                }
            } finally {
                //解锁
                lock.unlock();
            }
        }
    }
    
    public class LSaleTicket {
        //第二步 创建多个线程,调用资源类的操作方法
        //创建三个线程
        public static void main(String[] args) {
    
            LTicket ticket = new LTicket();
    
    new Thread(()-> {
        for (int i = 0; i < 40; i++) {
            ticket.sale();
        }
    },"AA").start();
    
            new Thread(()-> {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }
            },"BB").start();
    
            new Thread(()-> {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }
            },"CC").start();
        }
    }

    结果截图如下

    java中各类锁的机制是什么

    都是A线程执行,而BC线程都没执行到,出现了非公平锁

    具体改变其设置可以通过可重入锁中的一个有参构造方法

    修改代码为private final ReentrantLock lock = new ReentrantLock(true);

    代码截图为

    java中各类锁的机制是什么

    3. 可重入锁

    可重入锁也叫递归锁

    而且有了可重入锁之后,破解第一把之后就可以一直进入到内层结构

    Object o = new Object();
    new Thread(()->{
        synchronized(o) {
            System.out.println(Thread.currentThread().getName()+" 外层");
    
            synchronized (o) {
                System.out.println(Thread.currentThread().getName()+" 中层");
    
                synchronized (o) {
                    System.out.println(Thread.currentThread().getName()+" 内层");
                }
            }
        }
    
    },"t1").start();

    synchronized (o)代表锁住当前{ }内的代码块

    以上都是synchronized锁机制

    下面讲解lock锁机制

    public class SyncLockDemo {
    
        public synchronized void add() {
            add();
        }
    
        public static void main(String[] args) {
            //Lock演示可重入锁
            Lock lock = new ReentrantLock();
            //创建线程
            new Thread(()->{
                try {
                    //上锁
                    lock.lock();
                    System.out.println(Thread.currentThread().getName()+" 外层");
    
                    try {
                        //上锁
                        lock.lock();
                        System.out.println(Thread.currentThread().getName()+" 内层");
                    }finally {
                        //释放锁
                        lock.unlock();
                    }
                }finally {
                    //释放做
                    lock.unlock();
                }
            },"t1").start();
    
            //创建新线程
            new Thread(()->{
                lock.lock();
                System.out.println("aaaa");
                lock.unlock();
            },"aa").start();
            }
     }

    在同一把锁中的嵌套锁,内部嵌套锁没解锁还是可以输出,但是如果跳出该线程,执行另外一个线程就会造成死锁

    要把握上锁与解锁的概念,都要写上

    java中各类锁的机制是什么

    4. 读写锁(共享锁与独占锁)

    读锁是共享锁,写锁是独占锁

    • 共享锁的一种具体实现

    • 读写锁管理一组锁,一个是只读的锁,一个是写锁。

    读写锁:一个资源可以被多个读线程访问,也可以被一个写线程访问,但不能同时存在读写线程,读写互斥,读读共享(写锁独占,读锁共享,写锁优先级高于读锁)

    读写锁ReentrantReadWriteLock

    读锁为ReentrantReadWriteLock.ReadLock,readLock()方法

    写锁为ReentrantReadWriteLock.WriteLock,writeLock()方法

    创建读写锁对象private ReadWriteLock rwLock = new ReentrantReadWriteLock();

    写锁 加锁 rwLock.writeLock().lock();,解锁为rwLock.writeLock().unlock();

    读锁 加锁rwLock.readLock().lock();,解锁为rwLock.readLock().unlock();

    案例分析:

    模拟多线程在map中取数据和读数据

    完整代码如下

    //资源类
    class MyCache {
        //创建map集合
        private volatile Map map = new HashMap<>();
    
        //创建读写锁对象
        private ReadWriteLock rwLock = new ReentrantReadWriteLock();
    
        //放数据
        public void put(String key,Object value) {
            //添加写锁
            rwLock.writeLock().lock();
    
            try {
                System.out.println(Thread.currentThread().getName()+" 正在写操作"+key);
                //暂停一会
                TimeUnit.MICROSECONDS.sleep(300);
                //放数据
                map.put(key,value);
                System.out.println(Thread.currentThread().getName()+" 写完了"+key);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //释放写锁
                rwLock.writeLock().unlock();
            }
        }
    
        //取数据
        public Object get(String key) {
            //添加读锁
            rwLock.readLock().lock();
            Object result = null;
            try {
                System.out.println(Thread.currentThread().getName()+" 正在读取操作"+key);
                //暂停一会
                TimeUnit.MICROSECONDS.sleep(300);
                result = map.get(key);
                System.out.println(Thread.currentThread().getName()+" 取完了"+key);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //释放读锁
                rwLock.readLock().unlock();
            }
            return result;
        }
    }
    
    public class ReadWriteLockDemo {
        public static void main(String[] args) throws InterruptedException {
            MyCache myCache = new MyCache();
            //创建线程放数据
            for (int i = 1; i <=5; i++) {
                final int num = i;
                new Thread(()->{
                    myCache.put(num+"",num+"");
                },String.valueOf(i)).start();
            }
    
            TimeUnit.MICROSECONDS.sleep(300);
    
            //创建线程取数据
            for (int i = 1; i <=5; i++) {
                final int num = i;
                new Thread(()->{
                    myCache.get(num+"");
                },String.valueOf(i)).start();
            }
        }
    }

    5. 互斥锁

    互斥锁是独占锁的一种常规实现,是指某一资源同时只允许一个访问者对其进行访问,具有唯一性和排它性

    pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;//创建互斥锁并初始化
    
    pthread_mutex_lock(&mutex);//对线程上锁,此时其他线程阻塞等待该线程释放锁
    
    //要执行的代码段
    
    pthread_mutex_unlock(&mutex);//执行完后释放锁

    6. 自旋锁

    查看百度百科的解释,具体如下 :

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

    通俗的来说就是一个线程在获取锁的时候,如果锁已经被其它线程获取,那么该线程将循环等待,然后不断的判断锁是否能够被成功获取,直到获取到锁才会退出循环。获取锁的线程一直处于活跃状态,但是并没有执行任何有效的任务。

    其特点:

    1. 持有锁时间等待过长,消耗CPU

    2. 无法满足等待时间最长的线程优先获取锁。不公平的锁就会存在“线程饥饿”问题

    3. 自旋锁不会使线程状态发生切换,处于用户态(不会到内核态进行线程的状态转换),一直都是活跃,不会使线程进入阻塞状态,减少了不必要的上下文切换,执行速度快。

    其模拟算法如下

    do{
    	b=1;
    	while(b){
    		lock(bus);
    		b = test_and_set(&lock);
    		unlock(bus);
    	}
    	//临界区
    	//lock = 0;
    	//其余部分
    }while(1)

    7. 无锁 / 偏向锁 / 轻量级锁 / 重量级锁

    • 无锁:没有对资源进行锁定,所有的线程都能访问并修改同一个资源,但同时只有一个线程能修改成功

    • 偏向锁:是指一段同步代码一直被一个线程所访问,那么该线程会自动获取锁,降低获取锁的代价

    • 轻量级锁:锁是偏向锁的时候,被另外的线程所访问,偏向锁就会升级为轻量级锁,其他线程会通过自旋的形式尝试获取锁,不会阻塞,从而提高性能

    • 重量级锁:线程并发加剧,线程的自旋超过了一定次数,或者一个线程持有锁,一个线程在自旋,还有线程要访问

    本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系bd@zhengruan.com
    作者最新文章
    编程开发 Java
    相关文章 更多
    Yandex官网入口及网页搜索使用方法
    Yandex官网入口及网页搜索使用方法

    Yandex官网入口是https://www.yondex.net/,该平台支持多语言切换、智能搜索匹配、虚拟键盘变更及实时翻译,提供地图、图片、新闻、购物等垂直服务,并具备账户同步、隐私管理、个性化首页和云存储等功能。

    Java单元测试入门:使用JUnit 5编写第一个测试用例
    Java单元测试入门:使用JUnit 5编写第一个测试用例

    面向初学者的JUnit 5实用入门指南。从测试概念、Maven依赖配置,到手把手编写首个单元测试用例及断言验证,助你掌握Java单元测试的核心流程。

    Java变量未初始化报错解析:局部变量与成员变量默认值差异
    Java变量未初始化报错解析:局部变量与成员变量默认值差异

    深入解析Java中局部变量未初始化编译报错与成员变量自动赋予默认值的机制差异,涵盖JVM内存分配、编译期确定性赋值检查与实际排查修复方案。

    Java获取当前时间并格式化输出:DateTimeFormatter与SimpleDateFormat
    Java获取当前时间并格式化输出:DateTimeFormatter与SimpleDateFormat

    详细讲解在Java中获取当前系统时间并进行格式化输出的两种核心方案:基于Java 8全新日期时间API的DateTimeFormatter与传统遗留的SimpleDateFormat,包含完整代码示例、线程安全机制对比及生产选型建议。

    Java中final与static final常量的定义及初始化规则
    Java中final与static final常量的定义及初始化规则

    深入解析Java中final变量与static final常量的定义、内存语义、初始化时机及合法赋值路径,涵盖编译期常量优化与实战避坑指南。

    Java抽象方法与接口方法的区别及选型建议
    Java抽象方法与接口方法的区别及选型建议

    深入对比Java中抽象类抽象方法与接口方法的语法演进、设计意图及运行期差异,并提供清晰的架构选型决策流程与实战范例。

    Java实现HTTP请求与JSON解析的完整代码示例
    Java实现HTTP请求与JSON解析的完整代码示例

    本文提供Java标准库HttpClient发起HTTP GET/POST请求并结合Jackson进行JSON数据反序列化与序列化的完整代码示例与工程实践指南。

    Java递归出现StackOverflowError的原因分析及栈空间优化方案
    Java递归出现StackOverflowError的原因分析及栈空间优化方案

    详细分析Java递归调用出现StackOverflowError的原因,结合代码说明线程栈、栈帧和递归深度之间的关系,并介绍终止条件排查、迭代改写、减少栈帧开销以及通过-Xss调整JVM栈空间的方法。

    Java空指针异常(NPE)的代码排查与修复实例
    Java空指针异常(NPE)的代码排查与修复实例

    针对Java中常见的NullPointerException(NPE),本文从堆栈日志定位、典型代码触发场景、具体修复代码对比到防御体系进行系统讲解,提供实用且易上手的排查与修复方案。

    selenium上传文件教程本地文件路径设置方法
    selenium上传文件教程本地文件路径设置方法

    深入解析Selenium处理文件上传的技术细节,涵盖标准HTML控件的路径直接注入法与非标准控件的系统级模拟方案,提供Windows与Linux环境下的路径设置最佳实践及常见异常排查。

    查看更多
    精品专题 更多
    装机必备
    装机必备

    正软商城装机必备专区,精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件,帮助用户快速完成新电脑软件配置。

    Windows
    Windows

    正软商城Windows软件专区,汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件,提供软件介绍、系统要求、正版授权及购买下载服务。

    PDF教程
    PDF教程

    正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法,同时介绍常用PDF软件和工具的使用技巧。

    Mac软件 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    Aperty macOS版
    Aperty macOS版
    macOS

    Aperty 是 Skylum 推出的 AI 人像修图软件,支持自然肤质修饰、瑕疵处理、面部与身体调整、预设及批量同步。

    WINDOWS 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    PixTV 网页版
    PixTV 网页版
    Windows

    PixTV 是一款在浏览器中使用的 AI 视觉内容创作平台,提供图片、视频、音频、文字生成、AI 分镜、局部重绘、提示词反推和无限画布等工具,适合短剧、漫剧、广告及社交媒体内容制作。