java的“锁”事（锁的种类）

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量115 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1023077106/article/details/126429053
版权

Java‘锁’事

1、乐观锁和悲观锁

1.1、悲观锁

//认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加上锁，确保数据不会被别的线程修改，例如：synchronize和Lock的实现锁都是悲观锁
//适合写操作的场景，先加锁可以保证写操作时数据准确

1.2、乐观锁

//认为自己在使用数据时不会有别的线程修改数据或资源，所以不会添加锁
//在java中是通过使用无锁编程来实现，只是在更新数据的时候去判断,之前有没有别的线程更新了这个数据
//如果这个数据已经被其他线程更新，则根据不同的实现方式执行不同的操作，比如：放弃修改、重试抢锁等
//判断规则
//版本号机制version 最常采用的是CAS算法，java原子类中的通常操作通过CAS自旋实现的 （比较并交换）

2、8种情况演示锁运行案例

2.1、1-2案例演示

/**
问题:
1.标准访问有ab两个线程，请问先打印邮件还是消息
2.sendEmail()方法中加入暂停3秒，请问先打印邮件还是消息
结论
一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，
其他的线程都只能等待，换句话说，某一个时刻，只能有一个线程去访问synchronized方法
 锁的是当前对象this，被锁定后，其他的线程都不能进入当前对象的其它的synchronized方法中
*/
class phone {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }

    public synchronized void sendMsg() {
//        try{
//            TimeUnit.SECONDS.sleep(3);
//        }catch (InterruptedException e){
//            e.printStackTrace();
//        }
        System.out.println("------sendMsg");
    }

    public void hello() {
        System.out.println("----------hello");
    }
}
public class LockBDemo {
    public static void main(String[] args) {
        phone phone = new phone();
        phone phone2 = new phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        
        new Thread(() -> {
//            phone2.sendMsg();
            phone.sendMsg();
//            phone.hello();
        }, "B").start();

    }
}

2.2、3-4案例演示

/**
问题:
3.添加一个hello()方法，请问先打印邮件还是hello()
4.有两部手机，请问先打印邮件还是消息
结论
加个普通方法后发现和同步锁无关
换成两个对象后，不是同一把锁，情况立刻变化
*/
class phone {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }

    public synchronized void sendMsg() {
//        try{
//            TimeUnit.SECONDS.sleep(3);
//        }catch (InterruptedException e){
//            e.printStackTrace();
//        }
        System.out.println("------sendMsg");
    }

    public void hello() {
        System.out.println("----------hello");
    }
}

public class LockBDemo {
    public static void main(String[] args) {
        phone phone = new phone();
        phone phone2 = new phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();

        new Thread(() -> {
            phone2.sendMsg();
//            phone.sendMsg();
            phone.hello();
        }, "B").start();

    }
}

2.3、5-6案例演示

/**
问题:
5.有两个静态同步方法，有一部手机，请问先打印邮件还是消息
6.有两个静态同步方法，有两部手机，请问先打印邮件还是消息
结论
 三种synchronized锁的有一些差别
 对于普通的同步方法，锁的是当前实例对象，通常是this，具体的一部部手机，所有的普通同步方法用的都是同一把锁 -->实例对象本身
 对于静态同步方法，锁的是当前类的class对象，例如phone.class，唯一的模板对象
 对于同步方法块，锁的是synchronized括号内的对象
*/
class phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }

    public static synchronized void sendMsg() {
//        try{
//            TimeUnit.SECONDS.sleep(3);
//        }catch (InterruptedException e){
//            e.printStackTrace();
//        }
        System.out.println("------sendMsg");
    }

    public void hello() {
        System.out.println("----------hello");
    }
}

public class LockBDemo {
    public static void main(String[] args) {
        phone phone = new phone();
        phone phone2 = new phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();

        new Thread(() -> {
            phone2.sendMsg();
            phone.sendMsg();
//            phone.hello();
        }, "B").start();

    }
}

2.4、7-8案例演示

/**
问题:
 有一个静态同步方法，一个普通同步方法，一部手机，请问先打印邮件还是消息
 有一个静态同步方法，一个普通同步方法，两部手机，请问先打印邮件还是消息
结论
  当一个线程试图访问同步代码时，它首先必须得到锁，正常退出或抛出异常时必须释放锁
  
 所有的普通方法同步方法用的都是同一把锁--实例对象本身，就是new出来的具体实例对象本身，本类this
  也就是说明如果一个实例对象的普通同步方法获取锁之后，该实例对象的其他普通同步方法必须等待获取锁的方法释放锁后才能获取锁
  
  所有的静态同步方法用的也是同一把锁--类对象本身，就是我们说过的唯一模板class
  具体实例对象this和唯一模板class，这两把锁是两个不同的对象，所以静态同步方法与普通同步方法之间是不会有竞争锁的条件的
  但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁
*/
class phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }

    public  synchronized void sendMsg() {
//        try{
//            TimeUnit.SECONDS.sleep(3);
//        }catch (InterruptedException e){
//            e.printStackTrace();
//        }
        System.out.println("------sendMsg");
    }

    public void hello() {
        System.out.println("----------hello");
    }
}

public class LockBDemo {
    public static void main(String[] args) {
        phone phone = new phone();
        phone phone2 = new phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();

        new Thread(() -> {
            phone2.sendMsg();
            phone.sendMsg();
//            phone.hello();
        }, "B").start();

    }
}
//打印顺序
//------sendMsg
//------sendMsg
//------sendEmail

3、公平锁和非公平锁

3.1、公平锁

3.1.1、概述
  • 公平锁是指多个线程按照申请锁的顺序来获取锁，这里类似排队买票，先来的人先买后来的人排队。这就是公平锁ReentrantLock lock = new ReentrantLock(true)

3.2、非公平锁

3.2.1、概述
  • 非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发环境下，有可能造成优先级翻转或者饥饿状态（某个线程一直得不到锁）。这就是非公平锁ReentrantLock lock = new ReentrantLock()

3.3、代码演示

class Ticket{
    private int number = 50;
    ReentrantLock lock = new ReentrantLock();//ReentrantLock() 非公平锁  ReentrantLock(true) 公平锁

    public void sale(){
        lock.lock();
        try{
            if(number > 0){
                System.out.println(Thread.currentThread().getName() + "卖出第 : \t" +(number --));
            }
        }finally {
           lock.unlock();
        }

    }
}
public class SaleTicketDome {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(() ->{
            for (int i = 0; i < 55; i++) {
                ticket.sale();
            }
        },"t1").start();
        new Thread(() ->{
            for (int i = 0; i < 55; i++) {
                ticket.sale();
            }
        },"t2").start();
        new Thread(() ->{
            for (int i = 0; i < 55; i++) {
                ticket.sale();
            }
        },"t3").start();
    }
}

3.4 问题

  • 为什么默认是非公平锁
    1. 恢复挂起的线程到真正获得锁是有时间差的，从开发人员看这时间微乎其微，但是从CPU的角度来看，这个时间差存在的还是很明显，所以非公平锁更充分的利用CPU的时间片，尽量减少CPU空闲状态时间
    2. 使用多线程很重要的考量点是线程切换的开销，当采用公平锁时，当一个线程请求锁获取同步状态，然后释放到同步状态，所以港释放锁的线程在此刻两次获取同步状态的概率就变得非常大，所以就减少了线程的开销。

4、可重入锁（递归锁）

4.1、概述

  • 可重入锁是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁（前提，锁对象是同一个对象）不会因为之前已经获取还没有释放而阻塞
  • ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是一定程度避免死锁。

4.2、可重入锁的种类

4.2.1、synchronized隐式可重入锁
4.2.1.1、synchronized同步代码块及同步方法演示
//同步代码块
public class ReEntryLockDemo {
    public static void main(String[] args) {
        final  Object o = new Object();
        new Thread(() ->{
            synchronized (o){
                System.out.println(Thread.currentThread().getName() + "\t -----外层调用" );
                synchronized (o){
                    System.out.println(Thread.currentThread().getName() + "\t -----中层调用" );
                    synchronized (o){
                        System.out.println(Thread.currentThread().getName() + "\t -----内层调用" );
                    }
                }
            }
        },"t1").start();
    }
}
//输出
//t1	 -----外层调用
//t1	 -----中层调用
//t1	 -----内层调用

//同步方法
public synchronized void  m1(){
        System.out.println(Thread.currentThread().getName() + "\t -----m1()" );
        m2();
        System.out.println(Thread.currentThread().getName() + "\t -----经过m2" );
    }

    private synchronized void m2() {
        System.out.println(Thread.currentThread().getName() + "\t -----m2()" );
        m3();
    }

    private synchronized void m3() {
        System.out.println(Thread.currentThread().getName() + "\t -----m3()" );
    }

    public static void main(String[] args) {
        ReEntryLockDemo lockDemo = new ReEntryLockDemo();
        new Thread(() ->{
            lockDemo.m1();
        },"t1").start();
    }

//输出
//t1	 -----m1()
//t1	 -----m2()
//t1	 -----m3()
//t1	 -----经过m2
4.2.2.2、synchronized可重入锁的实现机制
  • 每个锁对象拥有一个锁计数器和一个指向持有该锁的线程的指针
  • 当执行monitorenter时，如果目标锁对象的计数器为零，那么说明它没有被其他线程所持有，Java虚拟机会将该锁对象的持有线程设置为当前线程，并且将其计数器加1
  • 在目标锁对象的暑假前不为零的情况下，如果锁对象的持有线程是当前线程，那么Java虚拟机可以将其计数器加1，否则需要等待，直至持有线程释放锁
  • 当monitorexit时，Java虚拟机则需要将锁对象的计数器减1，计数器为零代表锁已被释放。
4.2.2、reentrantLock显式可重入锁
4.2.1.1、reentrantLock演示
public class ReEntryLock {
    public static void main(String[] args) {
        final ReentrantLock lock = new ReentrantLock();
        new Thread(() ->{
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t -----外层调用" );
                lock.lock();
                try{
                    System.out.println(Thread.currentThread().getName() + "\t -----中层调用" );
                }finally {
                    //
                    lock.unlock();
                }
            }finally {
                //由于加锁次数和释放次数不一样，第二个线程始终无法获取锁，导致一直等待
                lock.unlock(); //正常情况下，加锁几次就要解锁几次
            }
        },"t1").start();

        new Thread(() ->{
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t -----外层调用" );
            }finally {
                lock.unlock();
            }
        },"t2").start();
    }
}
//输出
//main	 -----外层调用
//main	 -----中层调用

5、死锁及排查

5.1、概述

  • 死锁是指两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力干涉它们都将无法推进下去。

5.2、死锁代码演示

public class deadLock {
    public static void main(String[] args) {
        final Object o = new Object();
        final Object o1 = new Object();

        new Thread(() -> {
            synchronized (o) {
                System.out.println(Thread.currentThread().getName() + "\t" + "o进来了");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o1) {
                    System.out.println(Thread.currentThread().getName() + "\t" + "o1进来了");
                }
            }
        }, "t1").start();
        new Thread(() -> {
            synchronized (o1) {
                System.out.println(Thread.currentThread().getName() + "\t" + "o1进来了");

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o) {
                    System.out.println(Thread.currentThread().getName() + "\t" + "o进来了");
                }
            }

        }, "t2").start();
    }
}
5.2.1、死锁查看方式（命令方法）
  1. jps -l
  2. jstack 进程编号

6、写锁（独占锁）/读锁（共享锁）

7、自旋锁SpinLock

8、无锁->独占锁->读写锁->邮戳锁

9、无锁->偏向锁->轻量锁->重量锁

无心码码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 类锁
qq_45858803的博客
12-23 379
文章目录代码类锁示例关于类锁 代码类锁示例 package sybchro; public class O1 { public static void main(String[] args) { MyClass myClass1 = new MyClass(); MyClass myClass2 = new MyClass(); MyThread myThread1= new MyThread(myClass1); MyThread
java中的锁
Elroy1230的博客
03-30 104
1.jdk 1.6后Synchronized 锁优化（分级锁） 1. 检测Mark Word里面是不是当前线程ID,如果是,表示当前线程处于偏向锁 2. 如果不是,则使用CAS将当前线程ID替换到Mark Word,如果成功则表示当前线程获得偏向锁,设置偏向标志位1 3. 如果失败,则说明发生了竞争,撤销偏向锁,升级为轻量级锁 4. 当前线程使用CAS将对象头的mark Word锁标记位替换为锁记录指针,如果成功,当前线程获得锁 5. 如果失败,表示其他线程竞争锁,当前线程尝试通过自旋获取锁 for(;;
锁分类 java_java锁的种类
weixin_30836221的博客
02-12 101
锁大概有以下名词：自旋锁，自旋锁的其他种类，阻塞锁，可重入锁，读写锁，互斥锁，悲观锁，乐观锁，公平锁，偏向锁，对象锁，线程锁，锁粗化，锁消除，轻量级锁，重量级锁，信号量，独享锁，共享锁，分段锁我们所说的锁的分类其实应该按照锁的特性和设计来划分概述其实从并发的角度来讲，按照线程安全的三种策略看，主要内容都集中在互斥同步里，我们所讨论的锁也集中在这个部分。这个部分的锁都是悲观锁，第二个部分是非阻塞同步...
java锁的种类_Java中的锁——锁的分类
weixin_35973657的博客
02-19 138
Java中有各种各样的锁，例如公平锁、乐观锁等等，这篇文章主要介绍一下各种锁的分类。按照其性质分类公平锁/非公平锁公平锁是指多个线程按照申请锁的顺序来获取锁。非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者线程饥饿。公平和非公平锁的队列都基于锁内部维护的一个双向链表，表结点Node的值就是每一个请求当前锁的线程。公平锁...
java分类锁,java锁分类
weixin_35193131的博客
03-21 47
1.公平锁/非公平锁公平锁指多个线程按照申请的顺序获得锁。非公平锁指线程获取锁的顺序可能跟申请的顺序不一致。有可能出现优先级反转或饥饿现象。对于java而言ReentrantLock根据构造函数可以指定成公平锁和非公平锁，默认是非公平锁。synchronized是一种非公平锁，由于它并不像reentrantLock是通过AQS实现的。2.可重入锁可重入锁又称递归锁，即线程在外层方法获取的锁再进入内...
java锁详解.pdf
12-31
Java 锁详解 Java 锁是 Java 并发编程中的一种基本机制，用于确保线程安全和避免竞争条件。Java 锁可以分为两大类：synchronized 锁和 ReentrantLock 锁。 一、Synchronized 锁 1. 锁的原理：synchronized 锁是...
Java中的锁分类的详细介绍
08-29
Java 中的锁分类可以分为多种类型，包括公平锁、非公平锁、可重入锁、独享锁、共享锁、互斥锁、读写锁、乐观锁、悲观锁、分段锁、偏向锁、轻量级锁、重量级锁、自旋锁等。这些锁的分类并不是指锁的状态，有的指锁的...
Java锁.xmind
07-12
【图解版】Java锁精确分类，从JAVA各类锁进行分析和分类，精确分类Java各种锁，不可用于商业用途，如有版权问题，请联系删除！
浅谈对java中锁的理解
08-31
二、锁的分类 根据使用方式的不同，锁可以分为对象锁和类锁。对象锁是作用在实例方法或者一个对象实例上面的，而类锁是作用在静态方法或者Class对象上面的。一个类可以有多个实例对象，因此一个类的对象锁可能会有多...
golang 接口
m0_70982551的博客
07-24 869
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 456
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 549
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 539
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 344
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 397
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 835
java、数据类型、循环、选择等
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 168
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 852
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
java锁种类得区别
02-01
Java有多种锁类型，它们的区别如下： 1. 内置锁(intrinsic lock)或监视器锁(monitor lock)：这是Java中最常用的锁类型。内置锁是Java中每个对象都有的一个内置的锁，可以用来保护对象的访问。内置锁可以通过`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值