Java中的并发安全问题：如何避免死锁与活锁

于 2024-08-12 19:38:00 发布
阅读量754 收藏 16
点赞数 10
文章标签： java 安全 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44409190/article/details/141140158
版权

Java中的并发安全问题：如何避免死锁与活锁

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们来探讨一下Java中的并发安全问题，特别是如何避免常见的死锁和活锁问题。

一、并发编程中的安全问题

并发编程允许多个线程同时执行，提高了程序的效率和响应速度。然而，并发编程也带来了复杂的安全问题，尤其是死锁（Deadlock）和活锁（Livelock）。这些问题可能导致程序挂起，甚至完全失去响应，影响系统的稳定性。

二、什么是死锁？

死锁是指两个或多个线程相互等待对方释放资源，导致所有线程都无法继续执行的情况。举个例子，线程A占用了资源1，等待资源2；同时线程B占用了资源2，等待资源1。由于双方都在等待对方释放资源，最终导致死锁。

import cn.juwatech.deadlock.*;

public class DeadlockExample {
    static class Resource {
        private final String name;

        public Resource(String name) {
            this.name = name;
        }

        public synchronized void lock(Resource other) {
            System.out.println(Thread.currentThread().getName() + " locked " + this.name);
            try {
                Thread.sleep(50); // 模拟操作延迟
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            other.use();
        }

        public synchronized void use() {
            System.out.println(Thread.currentThread().getName() + " is using " + this.name);
        }
    }

    public static void main(String[] args) {
        Resource resource1 = new Resource("Resource1");
        Resource resource2 = new Resource("Resource2");

        Thread threadA = new Thread(() -> resource1.lock(resource2), "Thread-A");
        Thread threadB = new Thread(() -> resource2.lock(resource1), "Thread-B");

        threadA.start();
        threadB.start();
    }
}

在这个示例中，Thread-A和Thread-B分别锁住了Resource1和Resource2，然后尝试获取对方的资源。由于双方都无法释放自己持有的资源，这种相互等待的情况就形成了死锁。

三、如何避免死锁

为了避免死锁，可以采用以下几种方法：

  1. 资源有序分配法
    定义资源的获取顺序，所有线程必须按照这个顺序申请资源。这样可以避免循环等待的情况，从而避免死锁。

    import cn.juwatech.deadlock.*;

public class DeadlockAvoidance {
    static class Resource {
        private final String name;

        public Resource(String name) {
            this.name = name;
        }

        public void lock(Resource other) {
            synchronized (this) {
                System.out.println(Thread.currentThread().getName() + " locked " + this.name);
                synchronized (other) {
                    System.out.println(Thread.currentThread().getName() + " locked " + other.name);
                }
            }
        }
    }

    public static void main(String[] args) {
        Resource resource1 = new Resource("Resource1");
        Resource resource2 = new Resource("Resource2");

        Thread threadA = new Thread(() -> resource1.lock(resource2), "Thread-A");
        Thread threadB = new Thread(() -> resource1.lock(resource2), "Thread-B");

        threadA.start();
        threadB.start();
    }
}

    通过在所有线程中统一资源获取顺序，避免了循环等待，从而解决了死锁问题。

  2. 超时机制
    在资源获取操作中加入超时机制，线程在等待资源超时后会主动放弃并重试。

    import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;
import cn.juwatech.deadlock.*;

public class DeadlockTimeout {
    static class Resource {
        private final Lock lock = new ReentrantLock();
        private final String name;

        public Resource(String name) {
            this.name = name;
        }

        public boolean lock(Resource other) {
            try {
                if (lock.tryLock(100, TimeUnit.MILLISECONDS)) {
                    System.out.println(Thread.currentThread().getName() + " locked " + this.name);
                    if (other.lock.tryLock(100, TimeUnit.MILLISECONDS)) {
                        System.out.println(Thread.currentThread().getName() + " locked " + other.name);
                        return true;
                    } else {
                        lock.unlock();
                        System.out.println(Thread.currentThread().getName() + " released " + this.name);
                    }
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return false;
        }

        public void unlock() {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Resource resource1 = new Resource("Resource1");
        Resource resource2 = new Resource("Resource2");

        Thread threadA = new Thread(() -> {
            while (!resource1.lock(resource2)) {
                try {
                    Thread.sleep(50); // 重试前休眠
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            resource1.unlock();
            resource2.unlock();
        }, "Thread-A");

        Thread threadB = new Thread(() -> {
            while (!resource2.lock(resource1)) {
                try {
                    Thread.sleep(50); // 重试前休眠
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            resource2.unlock();
            resource1.unlock();
        }, "Thread-B");

        threadA.start();
        threadB.start();
    }
}

    通过设置超时机制，避免了线程无限期地等待资源，从而避免死锁。

四、什么是活锁？

活锁是指两个或多个线程不断地改变状态或相互响应，但没有一个能够继续执行任务。换句话说，活锁的线程虽然不会陷入死锁，但也无法取得进展，导致程序无法完成预期任务。

五、如何避免活锁

避免活锁的关键在于减少或消除线程间的相互干扰。可以通过以下几种方式来避免活锁：

  1. 随机等待时间
    在尝试获取资源时，引入随机等待时间，避免线程之间频繁冲突。

    import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;
import cn.juwatech.livelock.*;

public class LivelockExample {
    static class Resource {
        private final Lock lock = new ReentrantLock();
        private final String name;

        public Resource(String name) {
            this.name = name;
        }

        public boolean lock() {
            try {
                if (lock.tryLock(50 + (int) (Math.random() * 100), TimeUnit.MILLISECONDS)) {
                    System.out.println(Thread.currentThread().getName() + " locked " + this.name);
                    return true;
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return false;
        }

        public void unlock() {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Resource resource1 = new Resource("Resource1");
        Resource resource2 = new Resource("Resource2");

        Thread threadA = new Thread(() -> {
            while (!resource1.lock()) {
                try {
                    Thread.sleep(50); // 重试前休眠
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            resource1.unlock();
        }, "Thread-A");

        Thread threadB = new Thread(() -> {
            while (!resource2.lock()) {
                try {
                    Thread.sleep(50); // 重试前休眠
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            resource2.unlock();
        }, "Thread-B");

        threadA.start();
        threadB.start();
    }
}

    通过在锁定资源时引入随机等待时间，可以减少线程之间的冲突，避免活锁的发生。

总结

死锁和活锁是并发编程中常见的安全问题。通过合理设计资源获取顺序、引入超时机制和随机等待时间，可以有效避免这些问题，提高程序的稳定性和响应速度。在编写并发程序时，理解和应用这些技巧至关重要。

本文著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！

省赚客app开发者
关注
Java开发之——线程面试篇：死锁和如何避免死锁？
成都汇智动力的博客
01-13 842
在面试的时候在问起线程锁的部分，经常被问到“什么是死锁”、“怎么避免死锁”之类的问题，甚至开发中在使用锁的时候因为逻辑不严谨导致出现程序无法正确终止或者执行的情况，这些都跟死锁有着不可分割的联系，这篇文章我们就来说说死锁的问题。 什么是死锁 死锁就是当两个或两个以上的线程因竞争相同资源而处于无限期的等待，这样就导致了多个线程的阻塞，出现程序无法正常运行和终止的情况。 举个例子说明下死锁的现象：小明和小张要玩一个玩具，这个玩具有两部分组成必须两部分组装起来才能玩，小明拿了第一部分，小张拿了第二部分；这时.
java并发之死锁
weixin_40161962的博客
11-04 135
死锁编码以及定位分析 产生死锁的原因 死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种相互等待的现象，如果无外力的干涉那它们都将无法推进下去，如果系统的资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。 代码 public class DeadLockDemo { public static void main(String...
Java 并发（多线程）超详细
热门推荐
qq_42689380的博客
06-27 1万+
超级详细解析了 Java 多线程的应用等
Java死锁范例以及如何分析死锁
qi20088的专栏
04-08 607
http://www.importnew.com/9668.html
Java中，如何避免死锁？
weixin_44099583的博客
01-04 1035
使用工具或JVM内置功能（如JConsole）来监控和检测系统中的死锁，然后进行相应的处理。将大的锁分割成几个小的锁，如果可能的话，使得不同的线程可以同时访问不同的资源。方法来请求锁，它允许线程等待锁一定的时间后放弃，从而避免死锁。尽量避免一个线程在持有一个锁的同时去请求另一个锁。确保所有线程以相同的顺序请求和释放锁。
Java避免死锁的几个常见方法(有测试代码和分析过程)
liuruiaaa的博客
04-14 2234
Java避免死锁的几个常见方法(有测试代码和分析过程)
Java中的死锁及如何避免
最新发布
q1054261752的博客
08-05 311
搜索。
如何避免Java线程中的死锁？
最佳 Java 编程
06-10 1455
如何避免Java死锁？ 是Java面试中最受欢迎的问题之一，也是本季多线程的风格，主要是在高层提出，并带有很多后续问题。 尽管问题看起来很基础，但是一旦您开始深入研究，大多数Java开发人员就会陷入困境。 面试问题始于“什么是僵局？” 当两个或多个线程正在等待彼此释放所需的资源（锁定）并无限期陷入困境时，答案很简单，这种情况称为死锁。 它只会在多任务 或多线程的情况下发生。 如何...
Java中常见死锁与活锁的实例详解
08-26
Java 中常见死锁与活锁的实例详解 Java 中的死锁和活锁是一种常见的并发编程问题，它们可能会导致程序崩溃或性能下降。在 Java 中，死锁和活锁的实例详解是指在多线程编程中，多个线程在访问共享资源时，可能会...
【面试：并发篇21：多线程：活跃性】死锁、活锁、饥饿
m0_71229547的博客
07-22 244
死锁两个线程t1t2，两把锁AB，t1持有A锁t2持有B锁，此时t1想要再获得B锁t2想要再获得A锁，但是它们都不释放自己所持有的锁，最终导致死锁。活锁两个线程互相改变对方的结束条件，导致最后谁也没办法结束饥饿多个线程中有一个线程t，由于线程之间的冲突导致t线程分的时间片低，导致t线程基本不运行，这种情况下t线程就处于饥饿。...
死锁与活锁：并发编程中的常见问题与解决方案
在并发编程中，常常会遇到一些常见的问题，比如竞态条件、死锁、活锁、资源争用等。这些问题需要我们认识到并发编程的特点和难点，结合合适的解决方案来应对这些问题。 以上就是第一章的内容，介绍了并
并发编程中的死锁、活锁和饥饿现象分析与解决
# 1. 引言 ## 1.1 什么是并发编程 并发编程是指程序在同一时间段...在并发编程中，会面临诸如死锁、活锁和饥饿现象等问题。这些问题会影响程序的稳定性和性能，因此需要合理的并发编程解决方案来解决这些问题。 # 2.
java 如何解决并发问题吗_JAVA如何解决并发问题
weixin_34746715的博客
03-01 570
并发问题的根源在哪首先，我们要知道并发要解决的是什么问题？并发要解决的是单进程情况下硬件资源无法充分利用的问题。而造成这一问题的主要原因是CPU-内存-磁盘三者之间速度差异实在太大。如果将CPU的速度比作火箭的速度，那么内存的速度就像火车，而最惨的磁盘，基本上就相当于人双腿走路。这样造成的一个问题，就是CPU快速执行完它的任务的时候，很长时间都会在等待磁盘或是内存的读写。计算机的发展有一部分就是如...
java并发问题
weixin_38328444的博客
04-07 209
并发存在的问题: 可见性：要求一个线程对变量的操作改变对另外一个线程要是可以看见的。例如：当线程1读取主内存中变量到工作内存，线程2也读取并在工作内存改变其值，返回主内存，但线程1还是默认自己工作内存中的值。 原子性：在一次或多次操作中，要么所有的操作都执行不受其他干扰，要么所有的操作都不执行。 有序性：程序中代码的执行顺序，java编译和执行时会对代码进行优化，可能执行顺序与我们编写顺序不一致 java内存模型： 解决原子性问题：synchronized保证只有一个线程拿到锁，能够进入代码
Java并发问题
Tom_kobe的博客
08-30 687
并发问题
Java中的并发问题
Lecheng_的博客
03-22 474
Java 集合中的快速失败机制 有线程在遍历集合的同时，有另外线程进行了集合结构的修改，则会引发异常，异常是告知遍历集合的线程当前集合已经发生了改变[modcount++]，要求重新获取遍历器迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出 任 何 硬 性 保 证 。 快 速 失 败 迭 代 器 会 尽 最 大 努 力 抛 出ConcurrentModificationException，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法：迭代器的快速失败行为
java避免死锁_java避免死锁的方法
weixin_39731916的博客
02-26 179
* 避免死锁最好的办法，就是避免锁的交叉使用，在已经拥有锁的情况下，尽可能不要去申请别的锁如果一定要这样做，可以使用Lock.tryLock()方法避免死锁```public class DeadLockTest {public static final Lock lock1 = new ReentrantLock();public static final Lock lock2 = new Re...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值