Java中活锁的具体实现

最新推荐文章于 2024-09-04 02:23:05 发布
最新推荐文章于 2024-09-04 02:23:05 发布
阅读量239 收藏 5
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DISSUB/article/details/137198336
版权

这里写自定义目录标题

活锁

与死锁一样，活锁同样会发生在多个相互协作的线程间，当他们为了彼此间的响应而相互礼让，使得没有一个线程能够继续前进，那么就发生了活锁。同死锁一样，发生活锁的线程无法继续执行。

相当于两个在半路相遇的人：出于礼貌他们相互礼让，避开对方的路，但是在另一条路上又相遇了。就这样，不停地一直避让下去。。。。

活锁代码示例

package com.derucci.admin;

import org.junit.Test;

import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;
import java.util.function.IntBinaryOperator;
import java.util.function.Supplier;
import java.util.stream.Stream;

/**
 * @author: zzq
 * @Date: 2022/2/22
 * @Time: 10:39
 * @Version:
 * @Description:
 */
public class JavaTest {

    public static void main(String[] args) throws Exception {
        ReentrantLock breadLock = new ReentrantLock();
        ReentrantLock waterLock = new ReentrantLock();

        ExecutorService executorService = Executors.newCachedThreadPool();

        executorService.submit(
                () -> {
                    try {
                        // 尝试获得bread锁
                        while (breadLock.tryLock(10, TimeUnit.SECONDS)) {
                            System.out.println("拿到面包了，等着拿水。。。");
                            TimeUnit.SECONDS.sleep(1);

                            // 判断water是否被锁住，如果锁住，释放bread锁，再次尝试
                            if (waterLock.isLocked()) {
                                breadLock.unlock();
                                continue;
                            }

                            // 尝试获得water锁
                            if (!waterLock.tryLock(10, TimeUnit.SECONDS)) {
                                // 如果没有获得到，释放bread锁，再次尝试
                                breadLock.unlock();
                                continue;
                            }

                            System.out.println("拿到水了");
                            break;
                        }
                        System.out.println("吃面包，喝水");
                    } catch (InterruptedException e) {
                        System.out.println("线程中断");
                    } finally {
                        breadLock.unlock();
                        waterLock.unlock();
                    }
                }
        );

        executorService.submit(
                () -> {
                    try {
                        // 尝试获得water锁
                        while (waterLock.tryLock(10, TimeUnit.SECONDS)) {
                            System.out.println("拿到水了，等着拿面包");
                            TimeUnit.SECONDS.sleep(1);

                            // 判断bread是否被锁住，如果锁住，释放water锁，再次尝试
                            if (breadLock.isLocked()) {
                                waterLock.unlock();
                                continue;
                            }

                            // 尝试获得bread锁
                            if (!breadLock.tryLock(10, TimeUnit.SECONDS)) {
                                // 如果没有获得到，释放water锁，再次尝试
                                waterLock.unlock();
                                continue;
                            }

                            System.out.println("拿到面包了");
                            break;
                        }
                        System.out.println("喝水，吃面包");
                    } catch (InterruptedException e) {
                        System.out.println("线程中断");
                    } finally {
                        waterLock.unlock();
                        breadLock.unlock();
                    }
                }
        );

    }
}

程序运行结果：

拿到面包了，等着拿水。。。
拿到水了，等着拿面包
拿到面包了，等着拿水。。。
拿到水了，等着拿面包
拿到水了，等着拿面包
拿到面包了，等着拿水。。。
拿到水了，等着拿面包
拿到面包了，等着拿水。。。
拿到水了，等着拿面包

解决活锁

锁让出的时候添加随机睡眠时间

package com.derucci.admin;

import org.junit.Test;

import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;
import java.util.function.IntBinaryOperator;
import java.util.function.Supplier;
import java.util.stream.Stream;

/**
 * @author: zzq
 * @Date: 2022/2/22
 * @Time: 10:39
 * @Version:
 * @Description:
 */
public class JavaTest {

    public static void main(String[] args) throws Exception {
        ReentrantLock breadLock = new ReentrantLock();
        ReentrantLock waterLock = new ReentrantLock();

        ExecutorService executorService = Executors.newCachedThreadPool();

        executorService.submit(
                () -> {
                    try {
                        // 尝试获得bread锁
                        while (breadLock.tryLock(10, TimeUnit.SECONDS)) {
                            System.out.println("拿到面包了，等着拿水。。。");
                            TimeUnit.SECONDS.sleep(1);

                            // 判断water是否被锁住，如果锁住，释放bread锁，再次尝试
                            if (waterLock.isLocked()) {
                                breadLock.unlock();
                                // 避免活锁
                                TimeUnit.MILLISECONDS.sleep(1000);
                                continue;
                            }

                            // 尝试获得water锁
                            if (!waterLock.tryLock(10, TimeUnit.SECONDS)) {
                                // 如果没有获得到，释放bread锁，再次尝试
                                breadLock.unlock();
                                continue;
                            }

                            System.out.println("拿到水了");
                            break;
                        }
                        System.out.println("吃面包，喝水");
                    } catch (InterruptedException e) {
                        System.out.println("线程中断");
                    } finally {
                        breadLock.unlock();
                        waterLock.unlock();
                    }
                }
        );

        executorService.submit(
                () -> {
                    try {
                        // 尝试获得water锁
                        while (waterLock.tryLock(10, TimeUnit.SECONDS)) {
                            System.out.println("拿到水了，等着拿面包");
                            TimeUnit.SECONDS.sleep(1);

                            // 判断bread是否被锁住，如果锁住，释放water锁，再次尝试
                            if (breadLock.isLocked()) {
                                waterLock.unlock();
                                // 避免活锁
                                TimeUnit.MILLISECONDS.sleep(1500);
                                continue;
                            }

                            // 尝试获得bread锁
                            if (!breadLock.tryLock(10, TimeUnit.SECONDS)) {
                                // 如果没有获得到，释放water锁，再次尝试
                                waterLock.unlock();
                                continue;
                            }

                            System.out.println("拿到面包了");
                            break;
                        }
                        System.out.println("喝水，吃面包");
                    } catch (InterruptedException e) {
                        System.out.println("线程中断");
                    } finally {
                        waterLock.unlock();
                        breadLock.unlock();
                    }
                }
        );

    }
}

程序运行结果：

拿到面包了，等着拿水。。。
拿到水了，等着拿面包
拿到面包了
喝水，吃面包
拿到面包了，等着拿水。。。
拿到水了
吃面包，喝水

DISSUB
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java中各种死锁详细讲述及其解决方案（图文并茂，浅显易懂）
Java框架、并发编程、分布式、微服务、Redis、HarmonyOS、中间件等技术
07-01 3731
1、简介 在遇到线程安全问题的时候，我们会使用加锁机制来确保线程安全，但如果过度地使用加锁，则可能导致锁顺序死锁(Lock-Ordering Deadlock)。或者有的场景我们使用线程池和信号量来限制资源的使用，但这些被限制的行为可能会导致资源死锁(Resource DeadLock)。这是来自Java并发必读佳作 Java Concurrency in Practice 关于活跃性危险中的描述。 我们知道Java应用程序不像数据库服务器，能够检测一组事务中死锁的发生，进而选择一个事务去执行；在Java程
Java中常见死锁与活锁的实例详解
08-26
主要介绍了Java中常见死锁与活锁的实例详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java线程：活锁
weixin_44689901的博客
03-31 576
如果两个线程互相改变对方的结束条件，就可能导致双方谁也无法结束。活锁是指，线程没有发生阻塞，但依然执行不下去的情况。相当于一个抽水一个注水，水池永远不会空或者满。
彻底理解死锁和活锁 java实现
一个技术菜鸟的博客
07-10 1860
以下使用转账场景来解释说明以上问题，首先认识两个基础类：抽象账户类和工具类： 抽象账户类 /** * 账户抽象类，由子类实现转账操作 */ public abstract class AbstractAccount { //用户名 public String name; //余额 public int balance = 0; //账户锁 public final Lock LOCK = new ReentrantLock(); //构造方法
【Java并发】聊聊活锁
日拱一卒，不期速成！
01-21 428
【Java并发】聊聊活锁
java 活锁_Java中常见死锁与活锁的实例
weixin_42395980的博客
02-15 512
顺序死锁：过度加锁，导致由于执行顺序的原因，互相持有对方正在等待的锁资源死锁：多个线程在相同的资源上发生等待由于调用顺序而产生的死锁public class Test {Object leftLock = new Object();Object rightLock = new Object();public static void main(String[] args) {final Test t...
线程活跃性问题(死锁、活锁、饥饿)
weixin_45876411的博客
12-22 1024
活锁表示执行任务的线程没有被阻塞,但由于某些条件没有被满足导致重复的去尝试执行任务(失败->尝试->失败)，“活锁”与“死锁”的区别在于“死锁”线程一直处于等待状态而“活锁”执行线程在不断的执行;“饥饿”是指线程执行时无法获取到它所需要的资源比如(CPU),一种情况是“线程”优先级分配不合理导致部分线程一直无法被CPU调度执行;另一种情况是某线程持有某个操作的“锁”但其又处于无限循环而又不释放锁,此时其它等待获取此锁的线程获取不到就出现了饥饿问题;饥饿问题会导致服务器响应变差;详见本章序号1、7、8;
java 中锁的性能提高办法
08-31
在 Java 多线程编程中，锁是实现线程安全的关键机制。然而，不当的锁使用可能会导致性能瓶颈，甚至引发死锁等问题。以下是一些提高 Java 中锁性能的技术和策略： 1. **分离锁（Lock Segregation）**： 分离锁是指...
codinginterview:剑指offer Java实现
05-09
《CodingInterview: 剑指...《CodingInterview: 剑指Offer Java实现》中的每个题目都是对这些知识点的具体应用和实践。通过学习和解决这些题目，开发者可以巩固理论知识，提高解决问题的能力，为面试做好充分准备。
讲解Java在面试中的高频考点，分别包含Java基础、Java集合、Java多线程与并发编程、Java虚拟机、数据库、
06-02
面试中可能会涉及ArrayList、LinkedList、HashSet、HashMap等常见集合类的内部实现原理，以及它们的性能特点。面试者需要理解这些集合类的增删改查操作的时间复杂度，并能根据具体需求选择合适的集合类型。此外，...
深入解析Java并发程序中线程的同步与线程锁的使用
09-02
在Java中，`synchronized`关键字和`Lock`接口是实现线程同步的常见方式，它们主要用于解决多线程环境下的数据一致性问题，防止数据的不一致性和竞态条件。 `synchronized`关键字是Java内置的同步机制，它提供了两种...
Java中的活锁
weixin_43919497的博客
05-23 740
活锁出现在两个线程互相改变对方的结束条件，最后谁也无法结束，例如 public class TestLiveLock { static volatile int count = 10; static final Object lock = new Object(); public static void main(String[] args) { new Thread(() -> { // 期望减到 0 退出循环 while (count > 0) {
Java线程活锁
allway2的博客
01-27 367
活锁是一种递归情况，其中两个或更多线程将继续重复特定的代码逻辑。预期的逻辑通常是给其他线程机会以支持“此”线程。 当两个人在狭窄的走廊里相遇时，发生了现实生活中的活锁例子，每个人都试图通过移动到一边让对方经过而礼貌，但最终却没有任何进展就左右摇摆，因为他们都反复移动在同一时间相同的方式。 从Oracle参考文档： 一个线程通常会响应另一个线程的操作而行动。如果另一个线程的动作也是对另一个线程的动作的响应，则可能会导致活锁。与死锁一样，活锁的线程无法取得进一步的进展。但是，线程没有被阻塞-它们只..
Java中常见死锁与活锁的实例
weixin_33804990的博客
11-25 307
顺序死锁：过度加锁，导致由于执行顺序的原因，互相持有对方正在等待的锁 资源死锁：多个线程在相同的资源上发生等待 由于调用顺序而产生的死锁 public class Test { Object leftLock = new Object(); Object rightLock = new Object(); pu...
Java中的死锁与活锁
csp732171109的博客
01-03 1324
活锁与死锁 活锁 活锁同样会发生在多个相互协作的线程间，当他们为了彼此间的响应而相互礼让，使得没有一个线程能够继续前进，那么就发生了活锁。同死锁一样，发生活锁的线程无法继续执行。 相当于两个在半路相遇的人：出于礼貌他们相互礼让，避开对方的路，但是在另一条路上又相遇了。就这样，不停地一直避让下去。。。。 死锁 两个或更多线程阻塞着等待其它处于死锁状态的线程所持有的锁。死锁通常发生在多个线程同时但以不同的顺序请求同一组锁的时候，死锁会让你的程序挂起无法完成任务。 死锁的四个必要条件 在 Java 中使用多线程，
Java多线程 活锁
Java持续实践
09-13 885
文章目录活性故障活锁 (Livelock)工程中的活锁实例: 消息队列 活性故障 死锁是最常见的活跃性问题, 除了死锁外, 还有类似的问题导致程序无法顺利的执行, 统称为活跃性问题. 例如 活锁 (Livelock) 饥饿 活锁 (Livelock) 什么是活锁 活锁具有两个特点, 第一个是线程没有阻塞, 始终在运行中(所以叫活锁, 线程是活的, 运行中的. ) 第二个特点: 程序却得不到进展, 因为线程始终重复同样的无效事情. 如下图 , 两个绅士弯腰, 如果是死锁, 那么就是两个人始终一动不动, 直
[Java并发编程实战]活锁
seaicelin的博客
07-10 7343
我们都知道死锁，然而还存在一种锁叫做活锁。死锁是一直死等，活锁他不死等，它会一直执行，但是线程就是不能继续，因为它不断重试相同的操作。换句话说，就是信息处理线程并没有发生阻塞，但是永远都不会前进了。 活锁同样会发生在多个相互协作的线程间，当他们为了彼此间的响应而相互礼让，使得没有一个线程能够继续前进，那么就发生了活锁。 好比两个过于礼貌的人在半路相遇，出于礼貌他们相互礼让，避开对方的路，但是在...
【Java基础】深入理解Java中的锁
lixiaohulife的博客
01-18 586
Java中锁的常见面试问题： 了解的锁有哪些？ 自旋锁与互斥锁对比？ Synchronized底层原理？ CAS及其缺点？ 设计一个可重入锁？ 乐观锁和悲观锁？都有哪些应用？ Java中锁的分类方式： 从线程是否需要对资源加锁可以分为 悲观锁 和 乐观锁 从资源已被锁定，线程是否阻塞可以分为 自旋锁 从多个线程并发访问资源，也就是 Synchronized 可以分为 无锁、偏向锁、 轻量级锁 和 重量级锁 从锁的公平性进行区分，可以分为公平锁 和 非公平锁 从根据锁是否重复获取可以分为
【JavaWeb】JDBC&Druid&Tomcat入门使用
最新发布
lklalmq的博客
09-04 1043
预编译SQL语句并执行：预防SQL注入问题获取 PreparedStatement 对象// SQL语句中的参数值，使用？占位符替代?// 通过Connection对象获取，并传入对应的sql语句设置参数值上面的sql语句中参数使用?进行占位，在之前之前肯定要设置 这些?的值。PreparedStatement对象：setXxx(参数1，参数2)：给?赋 值Xxx：数据类型；如 setInt (参数1，参数2)参数：参数1：？的位置编号，从1 开始参数2：？的值执行SQL语句。
深入理解Java多线程：概念与实现
在Java编程中，多线程是一个关键特性，它使得程序能够同时执行多个任务，从而提高系统效率。Java提供了多种创建线程的方法，包括继承Thread类、实现Runnable接口以及使用ExecutorService。 一、线程概念 1. 进程：...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值