Java并发编程7_各种锁的理解

最新推荐文章于 2024-07-17 19:49:32 发布
最新推荐文章于 2024-07-17 19:49:32 发布
阅读量150 收藏
点赞数 1
分类专栏： JUC并发编程 文章标签： jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62866676/article/details/126879701
版权

目录

一、公平锁、非公平锁

二、可重入锁

三、自旋锁

四、死锁

一、公平锁、非公平锁

概念

  • 公平锁：非常公平，线程之间不可以插队，线程执行必须讲究先来后到
  • 非公平锁：非常不公平，线程之间可以插队(默认），比如A线程3s执行完成，B线程3h执行完成，那么就算B线程排A线程之前，当锁释放是，A线程还是可以去争抢锁，保证效率问题

查看ReentrantLock类的源码：

	//无参构造： 默认非公平锁
	/**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        // NonfairSync是一个非公平锁
        sync = new NonfairSync();
    }


	============ 可以传入true变为公平锁 =======
 	// 有参构造
	/**
     * 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();
    }

二、可重入锁

概念

  • 又称递归锁，线程拿到最外层的锁A，锁里面又调用了其他方法（其他方法有锁B），就可以自动获得里面的锁B，此时外边的锁A也不会释放
  • 线程执行完全部的任务（锁A + 锁B中的代码），才会释放最外边的锁A，其他线程才能拿到最外层的锁A

 举例：

============ synchronized ===========

import java.util.concurrent.TimeUnit;

public class Demo1 {


    public static void main(String[] args) {

        Phone1 p = new Phone1();

        // 发短信
        new Thread(()->{
            System.out.println("线程1开始执行");
            // 获得一个锁，内部执行 调用 call()另外一个加锁的方法，因此内部锁自动获取
            p.sendMessage();

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

        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        // 打电话
        new Thread(()->{
            System.out.println("线程2开始执行");
            p.call();
        },"线程2").start();

        
    }
}


class Phone1 {

    public synchronized void sendMessage(){
        System.out.println("发短信");
        // 继续获得内部的锁
        call();
    }

    public synchronized void call(){
        System.out.println("打电话");
    }
}


/**
 * 输出：
 * 线程1开始执行
 * 发短信
 * 打电话
 * 线程2开始执行
 * 打电话
 **/


============= lock锁 ================

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

public class Demo1 {


    public static void main(String[] args) {

        Phone1 p = new Phone1();

        // 发短信
        new Thread(()->{
            System.out.println("线程1开始执行");
            // 获得一个锁，内部执行 调用 call()另外一个加锁的方法，因此内部锁自动获取
            p.sendMessage();

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

        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        // 打电话
        new Thread(()->{
            System.out.println("线程2开始执行");
            p.call();
        },"线程2").start();


    }
}


class Phone1 {

    public  void sendMessage(){
        // 创建锁
        Lock lock = new ReentrantLock();
        // 加锁
        lock.lock();

        try {
            System.out.println("发短信");
            // 继续获得内部的锁,又是一对新的 lock 锁
            call();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }

    }

    public  void call(){

        // 创建锁
        Lock lock = new ReentrantLock();
        // 加锁
        lock.lock();

        try {
            System.out.println("打电话");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }
    }
}


/**
 * 输出：
 * 线程1开始执行
 * 发短信
 * 打电话
 * 线程2开始执行
 * 打电话
 **/

注意

  • synchronized关键字提供的锁是单一的，而Lock锁则是需要配对的，每个lock.lock()都是一把锁，都需要lock.unlock()解锁
  • 如果出现不配对的情况就会出现死锁

三、自旋锁

概念

  • AtomicXxx类下的CAS（CompareAndSet）方法底层就是 自旋锁，不断循环直到成功为止

  • 自旋锁主要应用CAS操作，直到手动释放锁才停止

  • 例如：AtomicInteger的getAndAddInt()方法底层就是用的自旋锁

 自己实现自旋锁：

package cn.test;

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

public class Demo {
    public static void main(String[] args) {

        // 创建一个自定义的自旋锁对象
        Spinlock lock = new Spinlock();

        new Thread(()->{
            // 加锁
            lock.myLock();

            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
              
                // 解锁
                lock.myUnLock();

            }
        },"T1").start();

        // 保证线程T1先拿到锁

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

        new Thread(()->{
            // 加锁
            lock.myLock();

            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
               
                // 解锁
                lock.myUnLock();

            }

        },"T2").start();
    }




}

/**
 * 自定义自旋锁
 */

class Spinlock {
    // 创建原子引用对象，泛型为Thread，因为没有给Thread赋值，所以atomicReference初始值 = null
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    // 加锁，之后一直到自旋锁的循环中，不会释放锁，直到 手动释放锁
    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "==== > myLock");
        // 如果第一个参数期望值null与atomicReference的内存值相同，就将内存值改为thread，此时atomicReference内存值从null -> thread
        // 其他线程再来调用myLock方法，进入到while判断，因为atomicReference.compareAndSet(null, thread)中期望值null与atomicReference的内存值不相同
        // 那么不满足条件就会返回false，就会一直while循环
        while (!atomicReference.compareAndSet(null, thread)) {

        }

    }


    // 解锁
    public void myUnLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "==== > myUnLock");
        atomicReference.compareAndSet(thread,null);
        
    }
}
输出：
T1==== > myLock
T2==== > myLock
T1==== > myUnLock
T2==== > myUnLock

四、死锁

概念

  • 死锁是指两个或两个以上的线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种程序阻塞的现象， 此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

  • 例如：A持有A锁，B持有B锁，这时A想要去获取B锁，B也想要去获取A锁，这就造成了死锁

 代码举例：

package cn.test;

import java.util.concurrent.TimeUnit;

public class Demo {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";
        // T1线程获得lockA锁，想获取lockB锁
        new Thread(new MyThread(lockA, lockB), "T1").start();
        // T2线程获得lockB锁，想获取lockA锁
        new Thread(new MyThread(lockB, lockA), "T2").start();
    }
}

/**
 * 资源类
 */

class MyThread implements Runnable{

    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName() + "锁:" + lockA + ",想获取:" + lockB);

            // 睡眠2s，保证另一个线程锁住资源
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() + "锁:" + lockB + ",想获取:" + lockA);
            }
        }
    }
}
输出：
T2锁:lockB,想获取:lockA
T1锁:lockA,想获取:lockB

1.排查死锁

方法

  1. Idea的Terminal控制台输入命令： jps -l  定位进程号
  2. 再输入jstack 进程号 查看堆栈信息

 

Mr_代码先生
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 锁详解
ycfxhsw的博客
07-06 309
公平锁：是指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。类似排队打饭，先来后到。非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。公平锁，就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照 FIFO 的规则从队列中取到自己。非公平锁，比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁的方式。
Java各种锁的理解
m0_47396773的博客
01-25 222
Java各种锁的理解1. 乐观锁 VS 悲观锁2. 自旋锁 VS 适应性自旋锁3. 无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁4. 公平锁 VS 非公平锁5. 可重入锁 VS 非可重入锁6. 独享锁 VS 共享锁 Java提供了种类丰富的锁，每种锁因其特性的不同，在适当的场景下能够展现出非常高的效率。 Java中往往是按照是否含有某一特性来定义锁，通过特性将锁进行分组归类，如下图所示： 1. 乐观锁 VS 悲观锁 乐观锁与悲观锁是一种广义上的概念，体现了看待线程同步的不同角度。在Java和数据库中
史上最全 Java 中各种锁的介绍
龚礼鹏的博客
06-16 4972
转载自：https://www.jianshu.com/p/94cf9ebd8932 Java提供了种类丰富的锁，每种锁因其特性的不同，在适当的场景下能够展现出非常高的效率。本文旨在对锁相关源码（本文中的源码来自JDK 8）、使用场景进行举例，为读者介绍主流锁的知识点，以及不同的锁的适用场景。 Java中往往是按照是否含有某一特性来定义锁，我们通过特性将锁进行分组归类，再使用对比的方式进行介绍，帮助大家更快捷的理解相关知识。下面给出本文内容的总体分类目录： 1. 乐观锁 VS 悲观锁# 乐.
对Java中各种锁的理解及死锁排查
weixin_40169609的博客
05-08 94
1.公平锁、非公平锁 Synchronized非公平锁，Lock可以自己设置公平or非公平。 默认非公平。 java Lock lock=new ReentrantLock(true); （公平锁）一群人排队上厕所。 **优点：**所有人都能上厕所，等着就完了。 **缺点：**所有人都要站在厕所门口排队（所有线程唤醒CPU开销大）。 （非公平锁）一群人抢着上厕所，抢不到就等下次再抢。 **优点：**不用大家排队（没必要所有线程都唤醒CPU开销小）前一个线程执行完了随机给一个人发消息说可以来上厕所了notif
JAVA中使用ReentrantLock时检测死锁
ACGkaka的博客
12-08 282
DeadlockChecker.java static class DeadlockChecker { private final static ThreadMXBean mbean = ManagementFactory.getThreadMXBean(); public static void check() { Thread tt = new Thread(() -> { while(true) { lo
Java多线程下——各类锁的详解
weixin_45696320的博客
08-26 2404
假设男主是一个锁, 女主是一个线程. 如果只有这一个线程来使用这个锁, 那么男主女主即使不领证结婚(避免了高成本操作), 也可以一直幸福的生活下去.但是,但是，但是，女配出现了, 也尝试竞争男主, 此时不管领证结婚这个操作成本多高, 女主也势必要把这个动作完成了, 让女配死心.比如一个递归函数里有加锁操作，递归过程中这个锁会阻塞自己吗？实际开发过程中, 使用细粒度锁, 是期望释放锁的时候其他线程能使用锁,但是实际上可能并没有其他线程来抢占这个锁. 这种情况 JVM 就会自动把锁粗化, 避免频繁申请释放锁..
Java并发编程之锁
chrissw的博客
08-11 118
锁 1.AQS AQS是java中管理“锁”的抽象类，锁的许多公共方法都是在这个类中实现。AQS是独占锁(例如，ReentrantLock)和共享锁(例如，Semaphore)的公共父类。 1.AQS锁的类别 分为“独占锁”和“共享锁”两种 (01) 独占锁 – 锁在一个时间点只能被一个线程锁占有。根据锁的获取机制，它又划分为“公平锁”和“非公平锁”。公平锁，是按照通过CLH等待线程按照先来先得的...
Java并发编程实战_java并发_
10-03
锁机制在Java并发编程中占有重要地位。除了内置的synchronized，Java还提供了显式锁如ReentrantLock，它具有可中断的等待和公平锁等特性。读写锁（ReentrantReadWriteLock）允许多个读取者同时访问，但在写操作时...
Java并发编程实战之互斥锁.pptx
11-13
Java并发编程中的互斥锁是解决多线程环境下原子性问题的关键工具。原子性问题源自于线程在执行过程中可能被CPU切换，导致同一时间多个线程操作共享变量，从而引发数据不一致。为了解决这个问题，我们需要确保对共享...
java并发编程实战源码,java并发编程实战pdf,Java
09-10
《Java并发编程实战》是Java并发编程领域的一本经典著作，它深入浅出地介绍了如何在Java平台上进行高效的多线程编程。这本书的源码提供了丰富的示例，可以帮助读者更好地理解书中的理论知识并将其应用到实际项目中。...
java并发编程2
02-15
以上知识点覆盖了Java并发编程的主要方面，包括线程管理、同步机制、并发工具、设计模式、并发集合以及并发编程的最佳实践等，是理解和掌握Java并发编程的关键。在实际开发中，理解和熟练运用这些知识可以编写出高效...
Java 并发之 ReentrantReadWriteLock 深入分析
09-19 760
前言 上篇文章分析了AQS的实际应用之一：ReentrantLock 的实现。ReentrantLock 和synchronized 都是独占锁，而AQS还支持共享锁，本篇就来分析AQS 共享锁的实际应用。 通过本篇文章，你将了解到： 1、共享锁、独享锁区别 2、读锁的实现原理 3、写锁的实现原理 4、读写锁 tryLock 原理 5、读写锁的应用 1、共享锁、独享锁区别 基本差别 共享锁、独占锁是在AQS里实现的，核心是"state"的值： 如上图，对于共享锁来说，允许多个线程对state进行有效修
JAVA中的各种锁机制
2201_75382167的博客
03-13 2297
JAVA中的各种锁机制
Java 各种锁总结
huifeidewoniu_的博客
08-01 950
锁的学习
# 5000字 | 24张图 | Java中的21种锁，一篇搞定
悟空聊架构的专栏
09-03 697
本篇主要内容如下： 本篇文章已收纳到我的Java在线文档、 Github 我的SpringCloud实战项目持续更新中 帮你总结好的锁： 序号 锁名称 应用 1 乐观锁 CAS 2 悲观锁 synchronized、vector、hashtable 3 自旋锁 CAS 4 可重入锁 synchronized、Reentrantlock、Lock 5 读写锁 ReentrantReadWriteLock，CopyOnWriteArrayList、CopyOnWriteArr.
重学Java—Java中各类锁详解
weixin_43917227的博客
09-23 210
如果物理机器有多个处理器，能够让两个或以上的线程同时并行执行，我们就可以让后面那个请求锁的线程不放弃CPU的执行时间，看看持有锁的线程是否很快就会释放锁。不够灵活：加锁和释放的时机单一，每个锁仅有一个单一的条件(某个对象)，相对而言，读写锁更加灵活 无法知道是否成功获得锁，相对而言，Lock可以拿到状态，如果成功获取锁，…可重入锁：递归锁，是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁（前提锁对象得是同一个对象或者class），不会因为之前已经获取过还没释放而阻塞。
Java锁详解
weixin_46587652的博客
08-22 5748
Java锁详解
JDK、JRE、JVM的区别&&java的基本数据类型
最新发布
qq2259583140的博客
07-17 347
Java Delopment kit是java工具包，包含了编译器javac，调试器（jdb）以及其他用于开发和调试java程序的工具。JDK是开发人员在开发java应用程序时候所需要的的基本工具。Java Runtime Enviroment是java运行环境，包含了用于执行java程序的运行时库（java API）以及java虚拟机（JVM）。JRE只是用于运行java程序而不包含开发工具。Java Virtual Machine是Java虚拟机是一种能够执行java字节码的虚拟机。
深入理解Java并发编程：实战指南
"《Java Concurrency in Practice》是关于Java并发编程的一本权威著作，由Brian Göetz、Tim Peierls、Joshua Bloch等人撰写。这本书深入探讨了Java多线程编程的各个方面，旨在帮助开发者理解和掌握并发编程的实践...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值