JUC Lock锁与线程通信

最新推荐文章于 2024-11-10 08:43:33 发布
最新推荐文章于 2024-11-10 08:43:33 发布
阅读量229 收藏
点赞数 1
分类专栏： 高并发 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46167190/article/details/121685123
版权

JUC Lock锁

多线程编程步骤

运用了高内聚低耦合的方法

  • 创建资源类，在资源类创建属性和方法
  • 创建多个线程，调用资源类的操作方法

Lock接口实例

synchronized锁上锁和解锁的过程由jvm隐式的完成

Lock接口可以手动的实现上锁和解锁的过程

ReentrantLock(可重入锁)

ReentrantLock是lock接口的一个实现类，使用可重入锁的方法对线程的同步来进行控制

可重入锁：进入上锁退出解锁 主要的区别在于需要手动的上锁和解锁。

package com.xiaoxu.lock;

import java.util.concurrent.locks.ReentrantLock;
/**
 * 可重入锁
 * @author chenruxu
 */

//创建资源类
class LTicket{

    //创建可重入锁
    private final ReentrantLock lock = new ReentrantLock();

    private int number=30;
    //卖票的方法
    public void sale(){
        //上锁
        lock.lock();
        try {
            //判读是否有票可卖
            if(number>0){
                System.out.println(Thread.currentThread().getName()+"卖出了第"+(+number--)+"张票");

            }
        }finally {
            //解锁
            lock.unlock();
        }
    }

}
public class LSaleTicket {
    public static void main(String[] args) {
        LTicket ticket = new LTicket();
        //lamber表达式

        /**
         * AA线程
         */
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"AA").start();
        /**
         * BB线程
         */
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"BB").start();
        /**
         * CC线程
         */
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"CC").start();
    }
}

通过可重入锁多线程买票的并发问题，对卖票的过程加锁来解决了线程之间的不安全问题。

其中Lock是一个接口，在发生异常的时候不会和synchronized一样自动的释放锁，可能会引起死锁现象。

线程之间的通信

多线程编程的步骤2

  • 创建资源类

  • 在资源类中操作方法 判读 干活 通知。

  • 创建多个线程，调用资源类操作方法，完成过程。

  • 防止虚假唤醒的问题

实例一：a（add）线程 +1 b线程 -1

变量值为1的时候加1 0的时候a线程等待。

实现方式synchronized关键字实现和lock锁的实现方式

synchronized实现方式

package com.xiaoxu.synchroniz;
/**
 * synchronized关键字实现
 *
 */
//创建资源类
class Share{
    //初始值
    private int number = 0;

    //+1的方法
    public synchronized void incr() throws InterruptedException {
        if (number!=0){ //判断number是否为0 等待
            this.wait();
        }
        //如果number的值是0就加1操作
        number++;
        System.out.println(Thread.currentThread().getName()+"::"+number);
        //通知其他的线程（个人理解就是解锁）
        this.notifyAll();
    }

    /**
     * -1的方法
     */
    public synchronized void decr() throws InterruptedException {
        if(number!=1){
            this.wait();
        }
        //实现步骤
        number--;
        System.out.println(Thread.currentThread().getName()+"::"+number);
        //通知其他的线程
        this.notifyAll();
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Share share = new Share();
        //创建多个线程
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr(); //+1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr(); //-1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tjw4cGRq-1638446376730)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20211202155350256.png)]

线程之间的通信虚假唤醒问题

产生虚假唤醒问题的代码

package com.xiaoxu.synchroniz;
/**
 * synchronized关键字实现
 *
 */
//创建资源类
class Share{
    //初始值
    private int number = 0;

    //+1的方法
    public synchronized void incr() throws InterruptedException {
        if (number!=0){ //判断number是否为0 等待
            this.wait();
        }
        //如果number的值是0就加1操作
        number++;
        System.out.println(Thread.currentThread().getName()+"::"+number);
        //通知其他的线程（个人理解就是解锁）
        this.notifyAll();
    }

    /**
     * -1的方法
     */
    public synchronized void decr() throws InterruptedException {
        if(number!=1){
            this.wait();
        }
        //实现步骤
        number--;
        System.out.println(Thread.currentThread().getName()+"::"+number);
        //通知其他的线程
        this.notifyAll();
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Share share = new Share();
        //创建多个线程
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr(); //+1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr(); //-1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr(); //+1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"CC").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr(); //-1
                } catch (InterruptedException e) {
                    e.printStakTrace();
                }
            }
        },"DD").start();

    }
}

产生虚假唤醒的原因：线程的虚假唤醒的问题。wait（)方法释放锁之后，如果该线程继续抢到cpu的资源之后，会在wait()语句这里唤醒，if语句的判断会失效。解决的方法是将if语句换成对应的while语句解决虚假唤醒的问题。

下面是将原来的资源类中对资源进行操作的方法中进行锁条件判断语句中的if替换为while之后解决的过程。

package com.xiaoxu.synchroniz;
/**
 * synchronized关键字实现
 *
 */
//创建资源类
class Share{
    //初始值
    private int number = 0;

    //+1的方法
    public synchronized void incr() throws InterruptedException {
        while (number!=0){ //判断number是否为0 等待
            this.wait();
        }
        //如果number的值是0就加1操作
        number++;
        System.out.println(Thread.currentThread().getName()+"::"+number);
        //通知其他的线程（个人理解就是解锁）
        this.notifyAll();
    }

    /**
     * -1的方法
     */
    public synchronized void decr() throws InterruptedException {
        while (number!=1){
            this.wait();
        }
        //实现步骤
        number--;
        System.out.println(Thread.currentThread().getName()+"::"+number);
        //通知其他的线程
        this.notifyAll();
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Share share = new Share();
        //创建多个线程
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr(); //+1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr(); //-1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr(); //+1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"CC").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr(); //-1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"DD").start();

    }
}

Lock接口实现

package com.xiaoxu.lock;

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

/**
 * lock接口实现
 */

//创建资源类
class Share{
    private int number = 0;

    //创建lock
    private Lock lock= new ReentrantLock();
    private Condition condition=lock.newCondition();
    //+1
    public void incr() throws InterruptedException {
        //加锁
        lock.lock();
        try {
            //判断
            while (number!=0){
                condition.await();
            }
            //操作
            number++;
            System.out.println(Thread.currentThread().getName()+"::"+number);
            //唤醒
            condition.notify();
        }finally {
            //解锁
            lock.unlock();
        }
    }

    //-1
    public void decr() throws InterruptedException {
        //上锁
        lock.lock();
        try {
            while (number!=1){
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"::"+number);
            condition.notify();
        }finally {
            //解锁
            lock.unlock();
        }

    }

}

public class ThreadDemo2 {
    public static void main(String[] args) {
        Share share = new Share();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

    }
}

线程的定制化通信

应用场景：

启动三个线程按照如下的要求进行

AA打印5次 BB打印10次 CC打印15次共执行10轮

使我们线程之间的顺序按照指定的顺序进行。思路为三个线程设置三个标志位。标志位1打印A5次 修改标志位为2通知B过程以此类推。最后一个CC线程的标志位改完1。完成操作。下面对代码进行实现。

package com.xiaoxu.lock;

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

//第一步 创建资源类
class ShareResource{
    //定义标志位
    private int flag = 1; //1 AA 2BB 3CC
    //创建lock锁
    private Lock lock = new ReentrantLock();

    //创建三个condition
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    //打印5次
    public void print5(int loop) throws InterruptedException {
        lock.lock();
        try{
            //判断
            while (flag!=1){
                c1.await();
            }
            //干活
            for (int i = 1; i <=5; i++) {
                System.out.println(Thread.currentThread().getName()+"::"+i+"轮数"+loop);
            }
            //通知
            flag = 2;
            c2.signal();
        }finally {
            //释放锁
            lock.unlock();
        }
    }

    public void print10(int loop) throws InterruptedException {
        //上锁操作
        lock.lock();
        try {
            while (flag!=2){
                c2.await();
            }
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName()+"::"+i+"轮数"+loop);
            }
            //修改标志位 进行通知Cc线程
            flag = 3;
            c3.signal();
        }finally {
            //解锁
            lock.unlock();
        }
    }


    public void print15(int loop) throws InterruptedException {
        //上锁操作
        lock.lock();
        try {
            while (flag!=3){
                c3.await();
            }
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName()+"::"+i+"轮数"+loop);
            }
            //修改标志位 进行通知Cc线程
            flag = 1;
            c1.signal();
        }finally {
            //解锁
            lock.unlock();
        }
    }
}

public class ThreadDemo3 {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        //创建多线程
        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    shareResource.print5(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    shareResource.print10(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    shareResource.print15(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"CC").start();
    }
}
总有人会抬头看见月亮
关注
专栏目录
基于Java JUC框架的售票系统与多线程锁通信设计源码
09-30
该项目为Java JUC框架下的售票系统设计源码，包含25个文件，其中包括23个Java源文件、1个属性文件和1个...项目涵盖了乘务员售票、一锁八式、Lock锁和多线程通信等多线程技术实践，旨在通过源码学习提升并发编程能力。
JUC学习------Lock实现线程之间的通信
niulinbiao的博客
01-19 585
文章预览前言案例注意 前言 前面已经了解了Synchronized实现线程之间的通信，使用关键字synchronized与wait()方法和notify()方式结合实现线程间通信，也就是等待/通知模式。在ReentrantLock中，是借助Condition对象进行实现的。下面对Lock实现线程之间的通信进行分析 Condition的创建方式如下： Lock lock = new ReentrantLock(); Condition condition = lock.newCondition(); Con
同步方法及Lock锁情况下的线程通信
qq_46921806的博客
08-15 153
涉及线程的同步和通信 假设仓库中只存放一件产品，如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止，如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。 使用 同步方法或Lock锁进行线程通信时，两者唯一不同的是商品类，其他的（消费者线程，生产者线程，测试类都是相同的） 1.同步方法下的商品类 package com.yue2.commu4; //同步方法下的线程通信 public class Product {
Lock、死锁、线程间通信、线程组、线程池，以及定时器
啊帅和和的博客
08-20 513
这一块的内容主要是有关死锁、线程间通信、线程组、线程池以及定时器的内容。 这一部分的内容，如果想搞得比较明白，最好先看一下上一篇大数据进阶25的内容。地址如下： 大数据进阶25-多线程 Lock 在上一篇大数据 进阶25-多线程 里面，虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5之后提供了一个新的锁对象Lock Lock（接口）： void lock() 获得锁，加锁 void unlock() 释放锁 子
JUC多线程学习个人笔记
07-08
4. **锁机制**：JUC通过Lock接口（如ReentrantLock）和Condition接口提供了比synchronized更细粒度的锁控制。Lock接口支持可重入锁，可以精确控制线程的等待和唤醒，而Condition则可以实现线程间的条件等待和通知。 ...
JUC代码演示 Java多线程并发
05-03
了解和掌握线程的基本概念（如用户线程与守护线程）、同步机制（如`synchronized`和`Lock`接口），以及线程间通信的方法对于开发高质量的并发应用至关重要。希望本篇文章能帮助读者更好地理解和运用Java多线程并发的...
JUC学习笔记（Java多线程）
07-04
同步机制是多线程编程中的重要部分，JUC提供了多种工具来实现线程间的同步与通信。`synchronized`关键字是Java内置的同步机制，它可以保证同一时刻只有一个线程访问共享资源。另外，JUC还提供了`Lock`接口，它的实现...
尚硅谷Java视频_JUC 视频教程
02-17
尚硅谷_JUC线程高级_Condition 线程通信 ·10. 尚硅谷_JUC线程高级_线程按序交替 ·11. 尚硅谷_JUC线程高级_ReadWriteLock 读写锁 ·12. 尚硅谷_JUC线程高级_线程八锁 ·13. 尚硅谷_JUC线程高级_线程池 ·14. ...
JAVA-01-变量
LJH_laura_li的博客
11-08 434
在方法、构造函数或块内部定义的变量。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 1027
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 656
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 337
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
在 C# 中，如何实现观察者模式？
Leo的博客
11-06 497
观察者模式是一种设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当该主题对象的状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。这个模式常用于事件处理系统、通知系统等场景。
并发编程的基础：深入理解内存屏障（Memory Barriers）
2401_86353562的博客
11-06 1007
内存屏障是一种基础语言，在不同的计算机架构下有不同的实现细节。本文主要在x86_64处理器下，通过Linux及其内核代码来分析和使用内存屏障对大多数应用层开发者来说，“内存屏障”（memory Barrier）是一种陌生，甚至有些诡异的技术。实际上，他机制常被用在操作系统内核中，用于实现同步、驱动程序利用它，能够实现高效的无锁数据结构，提高多线程程序的性能表现。本文首先探讨了内存屏障的必要性，之后介绍如何利用内存屏障实现一个无锁唤醒振荡器（队列），用于在多个线程间进行高效的数据交换。
ArkTS--应用状态
最新发布
qq_63946637的博客
11-10 522
本文旨在帮助大家学习鸿蒙中的LocalStorage和AppStorage
greendao使用封装
白高林的专栏
11-07 449
greenDAO
MySQL 到 ClickHouse 数据同步优化（三）
Kami‘s home
11-08 822
CloudCanal 再次优化 MySQL 到 ClickHouse 数据链路，大幅提升数据同步性能，帮助业务快速构建实时数据分析环境。
【JAVA】Java基础—面向对象编程基础：类与对象的概念
thinking_chou的专栏
11-07 1039
类是一个用户定义的数据类型，它包含了属性和方法。属性用于描述对象的特征，方法用于描述对象的行为。类与对象是Java编程的核心概念。类是对象的蓝图，定义了对象的属性和方法；对象是类的实例，具有独立的状态和行为。通过类与对象，我们可以更好地模拟现实世界中的事物，使得程序设计更加清晰和模块化。
C++接口类， 抽象类和实体类简述
Joshua的专栏
11-09 305
在C++中，接口类通常是指只包含纯虚函数（pure virtual functions）的类。接口类的主要目的是定义一组通用的行为，但不提供任何具体的实现。通过上述示例可以看出，C++通过抽象类和多重继承实现了类似Java中的单一实体继承和多接口继承的效果。在C++中，虽然没有像Java那样明确的“接口”关键字，但可以通过抽象类和纯虚函数来实现接口的概念。实体类是指可以实例化的类，即类中所有的函数都有具体的实现，包括继承自抽象类的纯虚函数。单实体继承（多接口继承）的设计理念和好处。类继承和接口继承的比较。
Java并发编程：深入理解锁机制与JUC包
同步锁保证了在同一时刻只有一个线程能够执行与该锁关联的代码，实现了互斥访问。这种锁机制的核心原理是线程间的互斥和可重入性，即一个线程可以在获取自身锁的情况下再次进入同步代码块。 **JUC包中的锁** 相较于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

总有人会抬头看见月亮

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值