Lock在多线程模式下的应用

最新推荐文章于 2022-07-13 22:44:48 发布
最新推荐文章于 2022-07-13 22:44:48 发布
阅读量166 收藏
点赞数
分类专栏： java 文章标签： java Lock ReentrantLock condition 多线程循环打印
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ym563099457/article/details/121199263
版权

Lock多线程模式下的使用记住三个步骤

a.判断  while条件判断 多线程模式下一定是while

b.干活  执行业务代码

c.通知 唤醒下一个要运行的线程

还得记住 线程操作资源类，资源类要定义好 condition条件别忘了

1.一个初始值为0的变量 两个线程对其交替操作一个加1 一个减1 来5轮（生产者 消费者模拟）
 

/**
 * 一个初始值为0的变量 两个线程对其交替操作
 * 一个加1 一个减1 来5轮
 */
public class ProdConsumer {
  public static void main(String[] args) {
    ShareDate shareDate = new ShareDate();
    new Thread(()->{
      try {
        for (int i = 1; i < 5; i++) {
          shareDate.increment();
        }
      } catch (Exception e) {
        e.printStackTrace();
      }
    },"aa").start();

    new Thread(()->{
      try {
        for (int i = 1; i < 5; i++) {
          shareDate.decrement();
        }
      } catch (Exception e) {
        e.printStackTrace();
      }
    },"bb").start();
  }
}

class ShareDate{
  private  int number = 0 ;
  private Lock lock = new ReentrantLock();
  private Condition condition = lock.newCondition();

  public void increment(){
    //判断
    lock.lock();
    try {
      while(number != 0){
        //等待  不能生产
        condition.await();
      }
      //干活
      number++;
      System.out.println(Thread.currentThread().getName()+"--"+number);
      condition.signalAll();
    } catch (Exception e) {
      e.printStackTrace();
    }finally {
      lock.unlock();
    }
  }

  public void decrement() throws Exception{
    //判断
    lock.lock();
    try {
      while(number == 0){
        //等待  不能生产
        condition.await();
      }
      //干活
      number--;
      System.out.println(Thread.currentThread().getName()+"--"+number);
      condition.signalAll();
    } catch (Exception e) {
      e.printStackTrace();
    }finally {
      lock.unlock();
    }
  }
}

2.生产者消费者加强版，BlockQueue

使用阻塞队列好处：我们不需要关系什么时候阻塞线程，什么时候唤醒线程

class MyResource{
    private volatile boolean flag = true;
    private AtomicInteger atomicInteger = new AtomicInteger();
    BlockingQueue<String> blockingQueue = null;

  public MyResource(BlockingQueue<String> blockingQueue) {
    this.blockingQueue = blockingQueue;
    System.out.println(blockingQueue.getClass().getName());
  }

  public void myProd() throws InterruptedException {
    String data = null;
    boolean retvalue;
    while(flag) {
      data = atomicInteger.incrementAndGet()+"";
      retvalue = blockingQueue.offer(data,2L, TimeUnit.SECONDS);
      if (retvalue) {
        System.out.println(Thread.currentThread().getName()+"插入队列："+data+"成功");
      }else {
        System.out.println(Thread.currentThread().getName()+"插入队列："+data+"失败");
      }
      TimeUnit.SECONDS.sleep(1);
    }
    System.out.println(Thread.currentThread().getName()+"生产结束");
  }

  public void myCons() throws InterruptedException {
    String result = null;
    //TimeUnit.SECONDS.sleep(10);
    while (flag){
      result = blockingQueue.poll(2L,TimeUnit.SECONDS);
      if(null == result || result.equalsIgnoreCase("")){
        flag = false;
        System.out.println(Thread.currentThread().getName()+"消费超时，退出");
        return;
      }
      System.out.println(Thread.currentThread().getName()+"消费队列"+result+"成功");
    }
  }

  public void stop() throws Exception{
    this.flag = false;
  }
}
public class ProdConsumer_BlockQueue {
  public static void main(String[] args) throws Exception{
  MyResource myResource = new MyResource(new ArrayBlockingQueue<>(3));
  new Thread(() ->{
    System.out.println(Thread.currentThread().getName()+"启动");
    try {
      myResource.myProd();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  },"prod").start();

    new Thread(() ->{
      System.out.println(Thread.currentThread().getName()+"启动");
      try {
        myResource.myCons();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    },"cons").start();

    TimeUnit.SECONDS.sleep(5);
    System.out.println();
    System.out.println("5秒后main叫停");
    myResource.stop();
  }
}

结果：

java.util.concurrent.ArrayBlockingQueue
prod启动
prod插入队列：1成功
cons启动
cons消费队列1成功
prod插入队列：2成功
cons消费队列2成功
prod插入队列：3成功
cons消费队列3成功
prod插入队列：4成功
cons消费队列4成功
prod插入队列：5成功
cons消费队列5成功

5秒后main叫停
prod生产结束
cons消费超时，退出

 思考下 消费者先不消费的场景 如下代码所示

class MyResource{
    private volatile boolean flag = true;
    private AtomicInteger atomicInteger = new AtomicInteger();
    BlockingQueue<String> blockingQueue = null;

  public MyResource(BlockingQueue<String> blockingQueue) {
    this.blockingQueue = blockingQueue;
    System.out.println(blockingQueue.getClass().getName());
  }

  public void myProd() throws InterruptedException {
    String data = null;
    boolean retvalue;
    while(flag) {
      data = atomicInteger.incrementAndGet()+"";
      retvalue = blockingQueue.offer(data,2L, TimeUnit.SECONDS);
      if (retvalue) {
        System.out.println(Thread.currentThread().getName()+"插入队列："+data+"成功");
      }else {
        System.out.println(Thread.currentThread().getName()+"插入队列："+data+"失败");
      }
      TimeUnit.SECONDS.sleep(1);
    }
    System.out.println(Thread.currentThread().getName()+"生产结束");
  }

  public void myCons() throws InterruptedException {
    String result = null;
    TimeUnit.SECONDS.sleep(10);
    while (flag){
      result = blockingQueue.poll(2L,TimeUnit.SECONDS);
      if(null == result || result.equalsIgnoreCase("")){
        flag = false;
        System.out.println(Thread.currentThread().getName()+"消费超时，退出");
        return;
      }
      System.out.println(Thread.currentThread().getName()+"消费队列"+result+"成功");
    }
  }

  public void stop() throws Exception{
    this.flag = false;
  }
}
public class ProdConsumer_BlockQueue {
  public static void main(String[] args) throws Exception{
  MyResource myResource = new MyResource(new ArrayBlockingQueue<>(3));
  new Thread(() ->{
    System.out.println(Thread.currentThread().getName()+"启动");
    try {
      myResource.myProd();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  },"prod").start();

    new Thread(() ->{
      System.out.println(Thread.currentThread().getName()+"启动");
      try {
        myResource.myCons();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    },"cons").start();

    TimeUnit.SECONDS.sleep(20);
    System.out.println();
    System.out.println("20秒后main叫停");
    myResource.stop();
  }
}

结果

java.util.concurrent.ArrayBlockingQueue
prod启动
prod插入队列：1成功
cons启动
prod插入队列：2成功
prod插入队列：3成功
prod插入队列：4失败
prod插入队列：5失败
cons消费队列1成功
cons消费队列2成功
cons消费队列3成功
cons消费队列6成功
prod插入队列：6成功
prod插入队列：7成功
cons消费队列7成功
prod插入队列：8成功
cons消费队列8成功
prod插入队列：9成功
cons消费队列9成功
prod插入队列：10成功
cons消费队列10成功
prod插入队列：11成功
cons消费队列11成功
prod插入队列：12成功
cons消费队列12成功
prod插入队列：13成功
cons消费队列13成功
prod插入队列：14成功
cons消费队列14成功
prod插入队列：15成功
cons消费队列15成功

20秒后main叫停
prod生产结束
cons消费超时，退出

 

3.实现AA--BB--CC三个线程启动  要求

AA打印5次后BB打印10次 cc打印15次 紧接着 AA打印5次后BB打印10次 cc打印15次

来十轮

package com.example.starter;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//线程操作资源类
class ShareResoucre{
  private int number = 1;
  private Lock lock = new ReentrantLock();
  private Condition c1 = lock.newCondition();
  private Condition c2 = lock.newCondition();
  private Condition c3 = lock.newCondition();

  public void prints5(){
    lock.lock();
    try {
      //判断
      while(number != 1){
        c1.await();
      }
      //干活
      for (int i = 0; i < 5; i++) {
        System.out.println(Thread.currentThread().getName()+"--"+i);
      }
      // //通知
      number = 2;
      c2.signal();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      lock.unlock();
    }
  }

  public void prints10(){
    lock.lock();
    try {
      //判断
      while(number != 2){
        c2.await();
      }
      //干活
      for (int i = 0; i < 10; i++) {
        System.out.println(Thread.currentThread().getName()+"--"+i);
      }
      // //通知
      number = 3;
      c3.signal();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      lock.unlock();
    }
  }

  public void prints15(){
    lock.lock();
    try {
      //判断
      while(number != 3){
        c3.await();
      }
      //干活
      for (int i = 0; i < 15; i++) {
        System.out.println(Thread.currentThread().getName()+"--"+i);
      }
      // //通知
      number = 1;
      c1.signal();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      lock.unlock();
    }
  }
}
public class SynAndReentrantLockDemo {
  public static void main(String[] args) {
    ShareResoucre shareResoucre = new ShareResoucre();
    for (int i = 0; i < 10; i++) {
      new Thread(() ->{
        shareResoucre.prints5();
      },"AA").start();

      new Thread(() ->{
        shareResoucre.prints10();
      },"BB").start();

      new Thread(() ->{
        shareResoucre.prints15();
      },"CC").start();
    }
  }
}

4.尝试使用如下方式实现步骤3的需求

此方式会造成死循环，因为使用同一个lock锁对象，进入某个方法时  number不满足条件将会无限循环 不释放锁

//线程操作资源类
class ShareResoucre{
  private volatile  int number = 1;
  private Lock lock = new ReentrantLock();

  private Condition c1 = lock.newCondition();
  private Condition c2 = lock.newCondition();
  private Condition c3 = lock.newCondition();

  public void prints5(){
    lock.lock();
    try {
      //System.out.println("prints5");
      //判断
      while(number != 1){
        Thread.sleep(3);
       // c1.await();
      }
      //干活
      for (int i = 0; i < 5; i++) {
        System.out.println(Thread.currentThread().getName()+"--"+i);
      }
      // //通知
      number = 2;
      //c2.signal();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      lock.unlock();
    }
  }

  public void prints10(){
    lock.lock();
    try {
      //判断
      while(number != 2){
       // c2.await();
      }
      //干活
      for (int i = 0; i < 10; i++) {
        System.out.println(Thread.currentThread().getName()+"--"+i);
      }
      // //通知
      number = 3;
      //c3.signal();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      lock.unlock();
    }
  }

  public void prints15(){
    lock.lock();
    try {
      //判断
      while(number != 3){
        //c3.await();
      }
      //干活
      for (int i = 0; i < 15; i++) {
        System.out.println(Thread.currentThread().getName()+"--"+i);
      }
      // //通知
      number = 1;
      //c1.signal();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      lock.unlock();
    }
  }
}
public class SynAndReentrantLockDemo {
  public static void main(String[] args) {
    ShareResoucre shareResoucre = new ShareResoucre();
    for (int i = 0; i < 10; i++) {
      new Thread(() ->{
        shareResoucre.prints5();
      },"AA").start();

      new Thread(() ->{
        shareResoucre.prints10();
      },"BB").start();

      new Thread(() ->{
        shareResoucre.prints15();
      },"CC").start();
    }
  }
}

5.可以使用如下方式优化，创建三个锁对象

//线程操作资源类
class ShareResoucre{
  private volatile  int number = 1;
  private Lock lock1 = new ReentrantLock();
  private Lock lock2 = new ReentrantLock();
  private Lock lock3 = new ReentrantLock();
/*  private Condition c1 = lock.newCondition();
  private Condition c2 = lock.newCondition();
  private Condition c3 = lock.newCondition();*/

  public void prints5(){
    lock1.lock();
    try {
      //判断
      while(number != 1){
        Thread.sleep(3);
       // c1.await();
      }
      //干活
      for (int i = 0; i < 5; i++) {
        System.out.println(Thread.currentThread().getName()+"--"+i);
      }
      // //通知
      number = 2;
      //c2.signal();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      lock1.unlock();
    }
  }

  public void prints10(){
    lock2.lock();
    try {
      //判断
      while(number != 2){
       // c2.await();
      }
      //干活
      for (int i = 0; i < 10; i++) {
        System.out.println(Thread.currentThread().getName()+"--"+i);
      }
      // //通知
      number = 3;
      //c3.signal();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      lock2.unlock();
    }
  }

  public void prints15(){
    lock3.lock();
    try {
      //判断
      while(number != 3){
        //c3.await();
      }
      //干活
      for (int i = 0; i < 15; i++) {
        System.out.println(Thread.currentThread().getName()+"--"+i);
      }
      // //通知
      number = 1;
      //c1.signal();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      lock3.unlock();
    }
  }
}
public class SynAndReentrantLockDemo {
  public static void main(String[] args) {
    ShareResoucre shareResoucre = new ShareResoucre();
    for (int i = 0; i < 10; i++) {
      new Thread(() ->{
        shareResoucre.prints5();
      },"AA").start();

      new Thread(() ->{
        shareResoucre.prints10();
      },"BB").start();

      new Thread(() ->{
        shareResoucre.prints15();
      },"CC").start();
    }
  }
}

奋进中的程序员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程下的单例模式参考
09-02
本篇将探讨如何在Java多线程下实现单例模式，重点关注`synchronized`关键字和`java.util.concurrent.locks.Lock`接口的`ReentrantLock`类。 首先，我们来看传统的懒汉式单例模式，它延迟初始化，只有在第一次调用`...
多线程设计模式
08-28
多线程有助于提高应用程序的响应速度和并发能力，尤其是在处理I/O密集型或计算密集型任务时。 二、多线程设计模式 1. 生产者-消费者模式：这种模式用于处理生产数据和消费数据的场景。生产者将数据放入队列，消费...
多线程文件锁 java_Java NIO中的FileLock（文件锁）
weixin_42519826的博客
02-21 359
FileLock，文件锁。文件锁在OS中很常见，如果多个程序同时访问、修改同一个文件，很容易因为文件数据不同步而出现问题。给文件加一个锁，同一时间，只能有一个程序修改此文件，或者程序都只能读此文件，这就解决了同步问题，保证了线程安全。文件锁是进程级别的，不是线程级别的。文件锁可以解决多个进程并发访问、修改同一个文件的问题，但不能解决多线程并发访问、修改同一文件的问题。就是说使用文件锁时，同一进程内...
多线程-Lock的使用
weixin_51604685的博客
07-13 564
有关于多线程下的lock的使用
线程学习7——lock语句
weixin_34090643的博客
06-03 120
什么是lock语句？ lock语句是设置锁定和解除锁定的一种简单方式。 为什么使用lock语句？ 在使用多线程的过程中，会出现很多难以发现的问题，比如竞态条件与死锁，为了避免这些同步问题，所以使用lock语句，当然这并不是解决同步问题的唯一方法。 lock语句的作用： lock 关键字可确保当一个线程位于代码的临界区时，另一个线程不会进入该临界区。 如果其他线程尝试进入锁定的代...
ReentrantLock 中的 4 个坑
欢迎来到我的博客
12-08 565
JDK 1.5 之前 synchronized 的性能是比较低的，但在 JDK 1.5 中，官方推出一个重量级功能 Lock，一举改变了 Java 中锁的格局。JDK 1.5 之前当我们谈到锁时，只能使用内置锁 synchronized，但如今我们锁的实现又多了一种显式锁 Lock。 Lock 简介 Lock 是一个顶级接口，它的所有方法如下图所示： 它的子类列表如下： 我们通常会使用 ReentrantLock 来定义其实例，它们之间的关联如下图所示： PS：Sy..
C#多线程开发-了解C#5.0 05
zls365365的博客
04-21 114
正文共2000字，预计阅读时间：5min。前面一篇文章，了解了任务并行库。这是异步编程基础设施，它允许我们以模块化的方式设计程序，来组合不同的异步操作。解决了以往线程之间传递消息难等问题，但是我们在阅读和编写此类程序时还是会觉得非常难理解程序的实际执行顺利，总感觉把主动权交给并行库，总觉得心里面没底。而且随着系统的不断扩大，业务的不断完善，了解程序的先后执行次序就变得很重...
java多线程设计模式
06-04
在这个主题中，我们将深入探讨一些关键的概念、设计模式和最佳实践，以帮助开发者更好地理解和应用多线程技术。 1. **线程基础** - **线程创建**：Java提供了多种创建线程的方式，如继承`Thread`类或实现`Runnable...
Java多线程编程实战指南 设计模式篇
07-26
本书可能还会涉及以下设计模式在多线程环境下的应用： 1. 工厂模式：用于创建线程对象，减少客户端直接创建线程带来的复杂性和耦合。 2. 模板方法模式：定义一个操作中的算法骨架，而将一些步骤延迟到子类中，使得...
JAVA多线程模式高清版+DEMO
11-19
这个压缩包文件"JAVA多线程模式高清版+DEMO"显然是关于Java多线程设计模式的详细教程，很可能包含了理论讲解、代码示例以及实战DEMO。 在Java多线程编程中，了解和掌握以下知识点至关重要： 1. **线程的创建与启动...
Java多线程编程实战指南 设计模式篇.rar
03-26
2. 单例模式：在多线程环境下，确保类只有一个实例，通常采用双重检查锁定(DCL)或静态内部类等方式实现。 3. 状态模式：用于管理对象状态的变化，例如线程的状态（新建、运行、阻塞、死亡等），可以使用枚举类型来...
Java多线程生产者消费者模式实现过程解析
08-19
Java多线程生产者消费者模式是指在Java编程中，使用多线程来实现生产者和消费者之间的数据交换 и处理的模式。该模式下，生产者负责产生数据，而消费者负责处理数据。这种模式可以提高系统的性能和效率，特别是在高...
C#多线程Singleton(单件)模式模板
10-28
- 如果程序运行在多进程而非多线程环境下，这种单例模式可能不再适用，因为每个进程都有自己的内存空间，不会感知到其他进程的实例。 总之，C#中的线程安全单例模式是通过结合`volatile`关键字和`lock`语句来实现...
多线程应用实例
10-09
1. **线程安全**：如果一个方法在多线程环境下能正确运行，我们就说它是线程安全的。常见的线程安全问题包括数据竞争、活锁和死锁。 2. **线程不安全的示例**：多个线程同时修改全局变量可能导致数据错误，需要使用...
C#编程中的多线程处理实例
10-22
在C#编程中，多线程处理是一种提升应用程序性能的关键技术。它允许程序同时执行多个任务，从而充分利用多核处理器的计算能力。本篇将深入探讨如何在C#中实现多线程，以及如何利用Lock机制确保线程安全。 首先，创建...
redis报错:Unexpected exception while processing command
netho0的博客
12-05 9538
1. 定位到日志,他说这个数据不是期望得到的 2.打开redis连接工具,检查该数据 3.发现这个数据少了个引号,导致没用被正确识别的string ----------------------------- redis中放了个list<String>,前期测试数据时手动添加了个数据,没有加上引号,后面跑起来后导致的解析失败问题 ...
Java多线程-Lock锁
weixin_45203607的博客
10-03 621
Java多线程-Lock锁 介绍 在 jdk1.5 之后，并发包中新增了 Lock 接口(以及相关实现类)用来实现锁功能，Lock 接口提供了与 synchronized 关键字类似的同步功能，但需要在使用时手动获取锁和释放锁。 Lock 接口与synchronized关键字的区别 Lock 接口可以尝试非阻塞地获取锁 当前线程尝试获取锁。如果这一时刻锁没有被其他线程获取到，则成功获取并持有锁。 Lock 接口能被中断地获取锁 与 synchronized 不同，获取到锁的线程能够响应中断，当获取到的锁的线
[多线程]Lock锁方式解决线程安全问题
self
04-21 205
/** * 解决线程安全问题的方式三：Lock锁 ---- JDK5.0新增 * 1. 面试题：synchronized与Lock的异同？ * 相同点：二者都可以解决线程安全问题 * 不同点：synchronized机制在执行完相应的同步代码以后，自动释放同步监视器 * Lock需要手动的启动同步(lock()),同时结束同步也需要手动的实现(unlock()) * * 2. synchronized与Lock的对比： * 1）Lock是显式锁(手动开启和关闭.
多线程-Lock锁
weixin_46751741的博客
02-20 262
synchronized和Lock锁的区别 Lock是显示锁（手动开启和关闭锁，必须关闭锁）, synchronized是隐式锁，出了作用域自动释放. Lock锁只有代码块锁，synchronized有代码块锁和方法锁 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩充性（提供更多主类） 优先使用顺序： Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外） Lock（锁） 从JDK 5.0开始，Java提供了强大的线程
Java多线程设计模式解析
"Java多线程设计模式是Java编程中用于高效并发处理的关键技术。它允许程序同时执行多个任务，从而...Java多线程设计模式是构建高性能并发应用程序的基础，理解并熟练运用这些模式可以极大地提高程序的效率和健壮性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值