多线程并发之死锁

  死锁的必要条件
  
  1)互斥条件
  
  进程对所分配到的资源进行排他性的使用,即在一段时间内某个资源只由一个进程占用,如果此时还有其他进程请求资源,那么请求者只能等待,直到占用资源的进程将资源释放。
  
  2)请求和保持条件
  
  进程已经保持了至少一个资源,但又提出了新的资源请求,而该资源已被其他进程占有。此时,请求进程阻塞,但又对自己已获得的其他资源保持不放。
  
  3)不剥夺条件
  
  进程已获得资源,在未使用完之前,不能被剥夺,只能在使用完后,自己释放相应的资源。
  
  4)环路等待条件
  
  存在一种进程资源的循环等待链,链中每一个进程已获得的资源同时被 链中下一个进程所请求。
  
  死锁示例代码如下:

package io.binghe.concurrency.example.deadlock;

import lombok.extern.slf4j.Slf4j;

/**
 * @author binghe
 * @version 1.0.0
 * @description 一个简单的死锁类
 *              当DeadLock类的对象flag==1时(td1),先锁定o1,睡眠500毫秒
 *              而td1在睡眠的时候另一个flag==0的对象(td2)线程启动,先锁定o2,睡眠500毫秒
 *              td1睡眠结束后需要锁定o2才能继续执行,而此时o2已被td2锁定;
 *              td2睡眠结束后需要锁定o1才能继续执行,而此时o1已被td1锁定;
 *              td1、td2相互等待,都需要得到对方锁定的资源才能继续执行,从而死锁。
 */
@Slf4j
public class DeadLock implements Runnable{
    public int flag = 1;
    //静态对象是类的所有对象共享的
    private static Object o1 = new Object(), o2 = new Object();
    @Override
    public void run() {
        log.info("flag:{}", flag);
        if (flag == 1) {
            synchronized (o1) {
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (o2) {
                    log.info("1");
                }
            }
        }
        if (flag == 0) {
            synchronized (o2) {
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (o1) {
                    log.info("0");
                }
            }
        }
    }
    public static void main(String[] args) {
        DeadLock td1 = new DeadLock();
        DeadLock td2 = new DeadLock();
        td1.flag = 1;
        td2.flag = 0;
        //td1,td2都处于可执行状态,但JVM线程调度先执行哪个线程是不确定的。
        //td2的run()可能在td1的run()之前运行
        new Thread(td1).start();
        new Thread(td2).start();
    }
}

  
  处理死锁的方法
  
  预防死锁:通过设置某些限制条件,去破坏产生死锁的四个必要条件中的一个或几个条件,来防止死锁的发生。
  
  避免死锁:在资源的动态分配过程中,用某种方法去防止系统进入不安全状态,从而避免死锁的发生。
  
  检测死锁:允许系统在运行过程中发生死锁,但可设置检测机构及时检测死锁的发生,并采取适当措施加以清除。
  
  解除死锁:当检测出死锁后,便采取适当措施将进程从死锁状态中解脱出来。
  
  多线程并发最佳实践
  
  (1)使用本地变量
  
  尽量使用本地变量,而不是创建一个类或实例的变量
  
  (2)使用不可变类
  
  比如:String、基础类型的包装类等,一旦创建就不会改变,不可变类可以降低代码中需要的同步数量。
  
  (3)最小化锁的作用域范围:S=1/(1-a+a/n)
  
  a:并行计算部分所占的比例
  
  n:并行处理的节点个数
  
  S:加速比
  
  当 a=1 时,没有串行,只有并行,此时,S=n
  
  当 a=0 时,只有串行,没有并行,此时,S=1
  
  当 n 趋向于无穷大时,S 趋向于 1/(1-a),这也是加速比 S 的上限
  
  S=1/(1-a+a/n) 公式也叫做:阿姆达尔定律或者安达尔定理。
  
  (4)使用线程池的 Executor,而不是直接 new Thread 执行
  
  (5)宁可使用同步也不要使用线程的 wait 和 notify
  
  (6)使用 BlockingQueue 实现生产 - 消费模式
  
  (7)使用并发集合而不是加了锁的同步集合
  
  (8)使用 Semaphore 创建有界的访问
  
  (9)宁可使用同步代码块,也不使用同步的方法
  
  (10)避免使用静态变量

评论

暂无评论