当前位置： 首页 > news >正文

javaSE学习笔记21-线程（thread）-锁（synchronized 与Lock）

news 来源：原创 2025/6/8 6:58:01

死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程 都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能 会发生“死锁"的问题;

死锁是指多个线程在执行过程中，因为争夺资源而造成的一种互相等待的现象，导致这些线程都无法继续执行下去。

练习代码

package com.lock;

/*
死锁
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程
都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能
会发生“死锁"的问题;
 */

//死锁：多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {

    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"灰姑凉");
        Makeup g2 = new Makeup(0,"白雪公主");

        g1.start();
        g2.start();
    }
}

//口红（Lipstick）
class Lipstick{

}

//镜子（Mirror）
class Mirror{

}

//化妆（Makeup）
class Makeup extends Thread{

    //需要的资源只有一份，用static来抱着只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;//使用化妆品的人

    Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }
    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆，互相持有对方的锁,就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) {//获得口红的锁
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(1000);

                synchronized (mirror){//1s钟后想获得镜子 的锁
                    System.out.println(this.girlName + "获得镜子的锁");
                }
            }
        }else {
            synchronized (mirror) {//获得镜子的锁
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(2000);

                synchronized (lipstick){//2s钟后想获得口红 的锁
                    System.out.println(this.girlName + "获得口红的锁");
                }
            }

        }
    }
}

代码结构

  1. DeadLock类：这是主类，包含main方法，用于启动两个线程。

  2. Lipstick类和Mirror类：这两个类分别代表口红和镜子，是共享资源。

  3. Makeup类：继承自Thread类，表示一个化妆的线程。每个线程代表一个女孩，她们需要使用口红和镜子来化妆。

代码逻辑

  1. 共享资源：

    • Lipstick和Mirror是两个共享资源，分别代表口红和镜子。

    • 这两个资源被声明为static，确保它们在所有Makeup实例之间共享。

  2. Makeup类：

    • choice：表示女孩的选择，决定她们先获取哪个资源。

    • girlName：表示女孩的名字。

    • run()方法：线程启动后执行的方法，调用makeup()方法。

    • makeup()方法：模拟化妆过程，尝试获取口红和镜子的锁。

  3. 死锁的产生：

    • 如果choice为0，线程会先获取口红的锁，然后尝试获取镜子的锁。

    • 如果choice为1，线程会先获取镜子的锁，然后尝试获取口红的锁。

    • 由于两个线程的执行顺序不同，可能会导致以下情况：

      • 线程1（灰姑凉）持有口红的锁，等待镜子的锁。

      • 线程2（白雪公主）持有镜子的锁，等待口红的锁。

    • 这样，两个线程互相等待对方释放资源，导致死锁。

代码执行流程

  1. 启动线程：

    • g1和g2两个线程分别启动，代表灰姑凉和白雪公主。

    • g1的choice为0，g2的choice为1。

  2. 线程执行：

    • g1先获取口红的锁，然后尝试获取镜子的锁。

    • g2先获取镜子的锁，然后尝试获取口红的锁。

  3. 死锁发生：

    • g1持有口红的锁，等待g2释放镜子的锁。

    • g2持有镜子的锁，等待g1释放口红的锁。

    • 两个线程都无法继续执行，形成死锁。

如何避免死锁

  1. 锁的顺序：确保所有线程以相同的顺序获取锁。例如，所有线程都先获取口红的锁，再获取镜子的锁。

  2. 超时机制：在获取锁时设置超时时间，如果超时则释放已持有的锁并重试。

  3. 死锁检测：使用工具或算法检测死锁，并采取相应措施解除死锁。

优化后代码

package com.lock;

/*
死锁
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程
都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能
会发生“死锁"的问题;

死锁避免方法
产生死锁的四个必要条件
1.互斥条件:一个资源每次只能被一个进程使用；
2.请求与保持条件:一个进程因请求资源而阻塞时，对已获得的资源保持不放；
3.不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺；
4，循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

只要想办法破其中的任意一个或多个条件就可以避免死锁发生
 */

//死锁：多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {

    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"灰姑凉");
        Makeup g2 = new Makeup(0,"白雪公主");

        g1.start();
        g2.start();
    }
}

//口红（Lipstick）
class Lipstick{

}

//镜子（Mirror）
class Mirror{

}

//化妆（Makeup）
class Makeup extends Thread{

    //需要的资源只有一份，用static来抱着只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;//使用化妆品的人

    Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }
    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆，互相持有对方的锁,就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) {//获得口红的锁
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(1000);
                }
            synchronized (mirror){//1s钟后想获得镜子 的锁
                System.out.println(this.girlName + "获得镜子的锁");
            }
        }else {
            synchronized (mirror) {//获得镜子的锁
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(2000);
                }
            synchronized (lipstick){//2s钟后想获得口红 的锁
                System.out.println(this.girlName + "获得口红的锁");
            }
        }
    }
}

修改后的代码分析

关键修改点

  1. 锁的嵌套被移除：

    • 在原始代码中，synchronized块是嵌套的，即一个线程在持有第一个锁的情况下尝试获取第二个锁。

    • 在修改后的代码中，synchronized块是分开的，线程在释放第一个锁之后才会尝试获取第二个锁。

  2. 锁的获取顺序：

    • 修改后的代码中，线程不会同时持有两个锁，而是先释放一个锁，再尝试获取另一个锁。

    • 这样就不会出现两个线程互相等待对方释放锁的情况。

修改后的代码执行逻辑

线程1（灰姑凉）的执行流程：

  1. 获取lipstick的锁。

  2. 打印“灰姑凉获得口红的锁”。

  3. 释放lipstick的锁。

  4. 获取mirror的锁。

  5. 打印“灰姑凉获得镜子的锁”。

  6. 释放mirror的锁。

线程2（白雪公主）的执行流程：

  1. 获取mirror的锁。

  2. 打印“白雪公主获得镜子的锁”。

  3. 释放mirror的锁。

  4. 获取lipstick的锁。

  5. 打印“白雪公主获得口红的锁”。

  6. 释放lipstick的锁。

为什么避免了死锁？

  1. 锁的释放：

    • 每个线程在获取一个锁后，会先释放它，再尝试获取另一个锁。

    • 这样就不会出现一个线程持有lipstick的锁并等待mirror的锁，而另一个线程持有mirror的锁并等待lipstick的锁的情况。

  2. 没有互相等待：

    • 线程1和线程2不会同时持有对方需要的锁，因此不会形成互相等待的僵局。

Lock锁 

1、JDK5.0开始，Java提供了更强大的线程同步机制--通过显式定义同步锁对象来实现同步。
同步锁使用Lock对象充当
2、java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。
锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
ReentrantLoc类（可重入锁）实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是
ReentrantLock，可以显式加锁、释放锁

以下代码演示了如何使用ReentrantLock来实现线程同步，确保多个线程安全地访问共享资源。ReentrantLock是Java中提供的一种显式锁机制，相比于synchronized关键字，它提供了更灵活的锁控制方式。

package com.lock;

import java.util.concurrent.locks.ReentrantLock;

/*
Lock（锁）
1、JDK5.0开始，Java提供了更强大的线程同步机制--通过显式定义同步锁对象来实现同步。
同步锁使用Lock对象充当
2、java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。
锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
ReentrantLoc类（可重入锁）实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是
ReentrantLock，可以显式加锁、释放锁

 */
//测试lock锁
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();

        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}

class TestLock2 implements Runnable{

    int ticketNums = 10;

    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                lock.lock();//加锁
                if (ticketNums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }else {
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

代码结构

  1. TestLock类：

    • 这是主类，包含main方法，用于启动多个线程。

    • 创建了一个TestLock2对象，并启动三个线程来执行该对象的run方法。

  2. TestLock2类：

    • 实现了Runnable接口，表示一个任务，可以被多个线程执行。

    • 包含一个共享资源ticketNums（票数），多个线程会竞争访问和修改这个资源。

    • 使用ReentrantLock来确保对ticketNums的访问是线程安全的。

代码逻辑

1. 共享资源

  • ticketNums：表示剩余的票数，初始值为10。

  • 多个线程会同时访问和修改ticketNums，因此需要确保线程安全。

2. ReentrantLock

  • ReentrantLock是一个可重入锁，允许线程多次获取同一把锁。

  • 通过lock()方法加锁，通过unlock()方法解锁。

  • 使用try-finally块确保锁一定会被释放，避免死锁。

3. 线程执行逻辑

  • 每个线程执行TestLock2的run方法。

  • 在while (true)循环中，线程不断尝试获取锁并访问共享资源ticketNums。

  • 如果ticketNums > 0，线程会休眠1秒（模拟耗时操作），然后打印并减少ticketNums的值。

  • 如果ticketNums <= 0，线程退出循环，任务结束。

代码执行流程

  1. 启动线程：

    • 在main方法中，创建了一个TestLock2对象，并启动三个线程。

    • 这三个线程会并发执行TestLock2的run方法。

  2. 线程竞争锁：

    • 每个线程在执行run方法时，会先调用lock.lock()尝试获取锁。

    • 只有一个线程能成功获取锁，其他线程会被阻塞，直到锁被释放。

  3. 访问共享资源：

    • 获取锁的线程会检查ticketNums的值。

    • 如果ticketNums > 0，线程会休眠1秒，然后打印ticketNums的值并将其减1。

    • 如果ticketNums <= 0，线程会退出循环。

  4. 释放锁：

    • 线程在完成对共享资源的操作后，会调用lock.unlock()释放锁。

    • 其他被阻塞的线程会竞争获取锁，继续执行。

  5. 任务结束：

    • 当ticketNums的值减少到0时，所有线程都会退出循环，任务结束。

关键点

  1. ReentrantLock的作用：

    • 确保多个线程对共享资源ticketNums的访问是互斥的，避免数据竞争。

    • 相比于synchronized，ReentrantLock提供了更灵活的锁控制，例如可中断锁、超时锁等。

  2. try-finally的作用：

    • 在try块中加锁，在finally块中解锁，确保锁一定会被释放，避免死锁。

  3. 线程安全：

    • 通过ReentrantLock实现了对共享资源的线程安全访问。

改进建议

  1. 锁的粒度：

    • 当前代码中，锁的粒度较大（整个while循环都在锁内），可能会影响并发性能。可以根据实际需求调整锁的粒度。

  2. 公平锁：

    • ReentrantLock默认是非公平锁，可以通过构造函数new ReentrantLock(true)创建公平锁，确保线程按顺序获取锁。

  3. 锁的可中断性：

    • ReentrantLock支持可中断的锁获取（lockInterruptibly()），可以在线程等待锁时响应中断。

改进后代码：

package com.lock;

import java.util.concurrent.locks.ReentrantLock;

/*
改进后的TestLock示例：
1. 缩小锁的粒度，只对共享资源的访问和修改加锁。
2. 使用公平锁，确保线程按顺序获取锁。
3. 优化代码结构，提高可读性和可维护性。
*/

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();

        // 启动多个线程
        new Thread(testLock2, "线程1").start();
        new Thread(testLock2, "线程2").start();
        new Thread(testLock2, "线程3").start();
    }
}

class TestLock2 implements Runnable {
    private int ticketNums = 10; // 共享资源，表示剩余的票数

    // 定义公平锁
    private final ReentrantLock lock = new ReentrantLock(true);

    @Override
    public void run() {
        while (true) {
            // 尝试获取锁
            lock.lock();
            try {
                if (ticketNums > 0) {
                    // 模拟耗时操作
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    // 打印当前线程名和剩余的票数
                    System.out.println(Thread.currentThread().getName() + " 售出票号：" + ticketNums--);
                } else {
                    // 票已售完，退出循环
                    break;
                }
            } finally {
                // 释放锁
                lock.unlock();
            }

            // 模拟线程切换，增加并发性
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

synchronized 与Lock的对比

1、lock是显式锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
2、Lock只有代码块锁，synchronized有代码块锁和方法锁；
3、使用Lock锁，JVM将花费较少的时间来调度线程（性能更好，并且具有更好的扩展性（提供更多的子类））
4、优先使用顺序：
    Lock > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）

相关文章：

  • 从零开始用STM32驱动DRV8301：无人机/机器人电机控制指南
  • 基于图扑 HT 可视化实现智慧地下采矿可视化
  • CentOS更换yum源
  • 安装MySQL9.1.0-winx64.msi的报错解决办法：Database initialization failed。（也适用9.2.0）
  • 基于spring的策略模式
  • 【树莓派Pico设备驱动】-MAX7219驱动8位7段数码管（基于SPI）
  • 微信小程序地图map全方位解析
  • Vue实战【后端返回ArrayBuffer时，前端如何处理并成功下载ArrayBuffer文件】
  • Hive JOIN过滤条件位置玄学：ON vs WHERE的量子纠缠
  • c#编程：LINQ是什么？
  • 关于docker及容器的了解学习记录
  • 【 Avalonia UI 语言国际化 I18n】图文结合教学，保姆级教学，语言国际化就是这么简单(.Net C#)
  • 谷粒商城学习笔记-13-配置git-ssh-配置代码免密提交
  • 自然语言处理:第九十二章 chatBI 经验(转载)
  • ES6相关操作(2)
  • PHP集成软件用哪个比较好？
  • 41. 缺失的第一个正数（LeetCode 热题 100）
  • Linux高并发服务器开发 第十九天（线程 进程）
  • LeetCode热题100——滑动窗口/子串
  • dify安装
  • wordpress 仿站步骤/seowhy官网
  • 郑州上海做网站的公司有哪些/企业网站营销实现方式
  • 手机移动网站设计/seo赚钱暴利
  • 典型的b2b网站有哪些/网站策划书模板
  • 个人备案的网站可以做宣传/宁波seo关键词
  • 公司网站建设 阜阳/百度竞价推广计划