首页 > 编程语言 >JUC并发编程(终章)各种锁的理解

JUC并发编程(终章)各种锁的理解

时间:2023-11-16 17:25:23浏览次数:36  
标签:JUC Thread lock 编程 call ems new 终章 public

各种锁的理解

公平锁、非公平锁

公平锁:先到先得(不可插队)

非公平锁:达者为先(可插队)---------->默认

public ReentrantLock() {
    //默认非公平锁
    sync = new NonfairSync();
}
//重载的构造方法,通过fair控制是否公平
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}
可重入锁(递归锁)

所有的锁都是可重入锁

Synchronized版

package org.example.lock;


public class Demo01 {
    public static void main(String[] args) {
        phone1 p1 = new phone1();
        new Thread(()->{
            p1.ems();
        },"A").start();
        new Thread(()->{
            p1.ems();
        },"B").start();
    }
}
class phone1{
    public synchronized void ems(){
        System.out.println(Thread.currentThread().getName()+"---------->ems");
        call();
    }
    public synchronized void call(){
        System.out.println(Thread.currentThread().getName()+"---------->call");
    }
}

ems方法中包含了call方法,所以当我们调用ems方法获取到锁时,也把call方法的synchronized锁获取到了。

错误理论

  • 当线程A运行ems方法后运行call方法时ems锁释放,线程B可以获取到ems方法

正确理论

  • 当线程A运行ems方法后运行call方法时ems方法的锁还未释放时就拿到了call方法中的锁,当call方法的锁释放后ems方法的锁才会释放。线程B此时就可以运行ems方法了

Lock版

package org.example.lock;

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

public class Demo02 {
    public static void main(String[] args) {
        phone2 p2 = new phone2();
        new Thread(()->{
            p2.ems();
        },"A").start();
        new Thread(()->{
            p2.ems();
        },"B").start();
    }
}
class phone2{
    Lock lock = new ReentrantLock();
    public  void ems(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"---------->ems");
            call();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //等待call方法锁解锁后再解锁
            lock.unlock();
        }

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

    }
}
自旋锁

spinlock(不断尝试直至成功)

已经见过了,就是unsafe中的自增getAndAddInt方法中的do-while循环就是一把自旋锁

自己写一把锁

package org.example.lock;

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

public class SpinLockDemo {
    //int 0
    //Thread null
    public static AtomicReference<Thread> atomic = new AtomicReference<>();

    public static void lock(){
        Thread thread = Thread.currentThread();
        System.out.println("===============>"+thread.getName()+"===========>lock");
        //自旋锁,若线程等于null,则compareAndSet为true,加!就为false,就会一直循环
        while (!atomic.compareAndSet(null,thread)){

        }
    }
    public static void unlock(){
        Thread thread = Thread.currentThread();
        System.out.println("===============>"+thread.getName()+"===========>unlock");
        //自旋锁
        atomic.compareAndSet(thread,null);
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            try {
                lock();
                TimeUnit.SECONDS.sleep(10);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                unlock();
            }
        },"A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            try {
                lock();
                TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                unlock();
            }
        },"B").start();
    }
}
死锁

死锁是什么

死锁测试

package org.example.lock;

import java.util.concurrent.TimeUnit;

public class DeadLockDemo {
    public static void main(String[] args) {
        String a = "A";
        String b = "B";
        new Thread(()->{new MyThread(a, b).run();},"A").start();
        new Thread(()->{new MyThread(b, a).run();},"B").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()+"lock:"+lockA+"=>get"+lockB);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+"lock:"+lockB+"=>get"+lockA);
            }
        }
    }
}

程序突然卡住死锁如何排查?

1、使用jps-l定位进程号

查看当前java活着的进程

2、使用jstack 进程号查看死锁问题

查找到一个死锁问题!

面试或者工作中排查问题:

1、查看异常

2、查看日志

3、查看堆栈信息

标签:JUC,Thread,lock,编程,call,ems,new,终章,public
From: https://www.cnblogs.com/nhgtx/p/17806051.html

相关文章

  • Java编程小案例
    1.不借助第三者实现两个变量值的交换。packagejava_11_9;importjava.util.Scanner;publicclassNumberSwap{ publicstaticvoidmain(String[]args){ @SuppressWarnings("resource") Scannerscanner=newScanner(System.in); System.out.print("请输入a的值:&q......
  • 《Unix/Linux系统编程》第十二章学习笔记
    《Unix/Linux系统编程》第十二章学习笔记概念介绍块设备I/O缓冲区用来代替磁盘I/O的文件存取方法,基本原理是使用一系列的I/O缓冲区作为块设备的缓存内存。当进程试图读取(dev,blk)标识的磁盘块时,它首先在缓冲区缓存中搜索分配给磁盘块的缓冲区。如果该缓冲区存在并且包含有效......
  • Android并发编程高级面试题汇总(含详细解析 五)
    Android并发编程高级面试题汇总最全最细面试题讲解持续更新中......
  • java8 stream api流式编程
    ......
  • 82岁老人,6个月自学编程,上架自己开发的App!
    82岁老人,6个月自学编程,上架自己开发的App!核桃编程营 ​关注 大部分人在二三十岁上就死去了,过了这个年龄,他们只是自己的影子。此后的余生则是在模仿自己中度过。日复一日,更机械,更装腔作势地重复有生之年的所思所想,所爱所恨。——罗曼·罗兰而有的人,在人生黄......
  • 第6章 Qt GUI--界面编程基础
    QtGUI--界面编程基础认识设计师界面--每个窗口的功能及用法在UI设计师界面设计的属性会被QTwidget设计在这里面拖动拖放试试看属性是根据基础的父类从上到下排序的编辑和信号槽模式核心--信号槽的理解与应用(这里比较粗糙)QT和其他GUI框架最大的区别红灯是......
  • (十九)C#编程基础复习——交错数组
    C#中的交错数组其实就是元素为数组的数组,换句话说就是交错数组中的每个元素都可以是维度和大小不同的数组,所以有时交错数组也称为“数组的数组”。这一节比较复杂,用到的时候可以再深入挖掘,多敲代码练习总会出奇迹。一、声明交错数组交错数组声明语法:data_type[][]array_name;......
  • Java编程:删除 List 元素的三种正确方法
    删除List中的元素会产生两个问题:删除元素后List的元素数量会发生变化;对List进行删除操作可能会产生并发问题;我们通过代码示例演示正确的删除逻辑packagecom.ips.list;importjava.util.ArrayList;importjava.util.Iterator;importjava.util.List;importjava.util.c......
  • Linux_C环境编程:时间日期函数总结
    摘自:https://blog.csdn.net/u010429831/article/details/122722187一、时间日期类型Linux下常用的时间类型有6个:time_t,clock_t,structtimeb,structtimeval,structtimespec,structtm1.1time_t类型time_t是一个长整型,一般用来表示从1970年1月1日0时0分0秒以来的秒数......
  • WSL+ vscode 编程方法记录
    WSL的终端可以安装zsh,使用起来体验感比CMD好太多了,再加上环境配置要方便很多,所以这里记录一下开发的流程和注意事项。这里使用conda控制不同的Python环境,进行日常代码工作。还可以使用Docker实现更加严格和规范的环境配置。Windows图形界面查看WSL中的文件:方法1:资......