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

湖州民生建设有限公司网站营销型网站建设推荐

wzjs 2025/8/6 19:03:25
湖州民生建设有限公司网站,营销型网站建设推荐,大型电子商务网站开发,网站开发运营经理死锁 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程 都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能 会发生“死锁&quo…

死锁

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

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

练习代码

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;}@Overridepublic 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;}@Overridepublic 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();@Overridepublic 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);@Overridepublic 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 > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）

http://www.dtcms.com/wzjs/244171.html

相关文章：

  • 李佳琦网络营销方式长安网站优化公司
  • flashfxp 网站石家庄网站建设seo
  • 网站开发工具 晴天娃娃聊城今日头条最新
  • 公司网站工商备案怎么做seo是做什么工作的
  • 北仑seo排名优化技术宁波seo搜索优化费用
  • 遵义湘江投资建设有限责任公司门户网站站长之家排行榜
  • 如何做网站推广方法泉州seo技术
  • 鹤壁做网站的联系方法地推十大推广app平台
  • 深圳商标设计公司vi设计重庆企业站seo
  • 日本樱花网站怎么做百度的营销推广模式
  • 青海网站开发太原seo公司
  • 新乡网站制作产品推广软文范文
  • 我想带货怎么找货源锦绣大地seo
  • 电商网站建设实训总结韩国热搜榜
  • 网站优化费用怎么做会计分录宁波网站推广公司价格
  • 做淘宝网站规范 百度知道软文发布推广平台
  • 网络营销从网站建设开始今日头条网站推广
  • 建设淘宝优惠券网站站长工具怎么关闭
  • 毕业设计做视频网站好做么站长之家音效素材
  • 个人学做网站百度 指数
  • 丰台做网站广州私人做网站
  • 上海建设工程管理网站上海推广系统
  • 苏州技术馆网站建设深圳网络推广平台
  • 临朐网站开发百度网站首页
  • 免费商用自媒体图片网站开发一个网站的步骤流程
  • 岳阳汨罗网站建设百家号seo怎么做
  • 南宁网站制作知乎关键词排名
  • java网站开发主流框架搜索网站大全
  • 电商网站开发技术免费使用seo软件
  • 建网站收费吗本地推广平台有哪些