死锁

2019-05-22  本文已影响0人  Auncle_

1.什么是死锁

在编写多线程的时候,必须要注意资源的使用问题,如果两个或多个线程分别拥有不同的资源,
而同时又需要对方释放资源才能继续运行时,就会发生死锁。

简单来说:死锁就是当一个或多个进程都在等待系统资源,而资源本身又被占用时,所产生的一种状态。

造成死锁的原因
多个线程竞争共享资源,由于资源被占用,资源不足或进程推进顺序不当等原因造成线程处于永久阻塞状态,从而引发死锁

2.死锁产生的条件

当然死锁的产生是必须要满足一些特定条件的:

  1. 互斥条件:进程对于所分配到的资源具有排它性,即一个资源只能被一个进程占用,直到被该进程释放
  2. 请求和保持条件:一个进程因请求被占用资源而发生阻塞时,对已获得的资源保持不放。
  3. 不剥夺条件:任何一个资源在没被该进程释放之前,任何其他进程都无法对他剥夺占用
  4. 循环等待条件:当发生死锁时,所等待的进程必定会形成一个环路(类似于死循环),造成永久阻塞

3.死锁代码

package com.auncle.test;

import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.metadata.BaseRowModel;
import com.alibaba.excel.metadata.Sheet;
import com.alibaba.excel.support.ExcelTypeEnum;
import com.auncle.bean.UserBean;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created by 杨海涛
 *
 * @project:test
 * @date:2019/4/22
 */
public class Auncle {

    public static void main(String[] args) {
        DeadLockThread deadlock1 = new DeadLockThread();
        DeadLockThread deadlock2 = new DeadLockThread();
        deadlock1.flag = true;
        deadlock2.flag = false;
        Thread thread1 = new Thread(deadlock1);
        Thread thread2 = new Thread(deadlock2);
        thread1.start();
        thread2.start();

    }

    static class DeadLockThread implements Runnable {
        private static final Object objectA = new Object();
        private static final Object objectB = new Object();
        private boolean flag;

        @Override
        public void run() {
            String threadName = Thread.currentThread().getName();
            System.out.println("当前线程 为:" + threadName + "\tflag = " + flag);
            if (flag) {
                synchronized (objectA) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(threadName + "已进入同步代码块objectA,准备进入objectB");
                    synchronized (objectB) {
                        System.out.println(threadName + "已经进入同步代码块objectB");
                    }
                }

            } else {
                synchronized (objectB) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(threadName + "已进入同步代码块objectB,准备进入objectA");
                    synchronized (objectA) {
                        System.out.println(threadName + "已经进入同步代码块objectA");
                    }
                }
            }
        }
    }
}

4.避免死锁

要预防和避免死锁的发生,只需将上面所讲到的4个条件破坏掉其中之一即可。

三种用于避免死锁的技术:

  1. 加锁顺序(线程按照一定的顺序加锁)
  2. 加锁时限(线程尝试获取锁的时候加上一定的时限,超过时限则放弃对该锁的请求,并释放自己占有的锁)
  3. 死锁检测
上一篇 下一篇

猜你喜欢

热点阅读