一个死锁的例子

深藏阁楼爱情的钟 2022-05-18 07:58 271阅读 0赞

## 死锁: ##

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

## 死锁的四个必要条件： ##

**互斥**条件(Mutual exclusion)：资源不能被共享，只能由一个进程使用。  
请求与保持条件(Hold and wait)：已经得到资源的进程可以**再次申请**新的资源。  
非剥夺条件(No pre-emption)：已经分配的资源**不能**从相应的进程中**被强制地剥夺**。  
循环等待条件(Circular wait)：系统中若干进程组成环路，该环路中每个进程都在等待相邻进程正占用的资源。

## 避免死锁 ##

a、按同一顺序访问对象。

b、避免事务中的用户交互。

c、保持事务简短并处于一个批处理中。

d、使用较低的隔离级别。

## 一个死锁的例子: ##

package ArtOfjavaConcurrency;
        /** * @author zd */
        public class DeadLockDemo { 
        private static String A = "A";
        private static String B = "B";
    
        public static void main(String[] args) {
                new DeadLockDemo().deadLock();
        }
    
        private void deadLock() {
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (A) {
                        try {
                            System.out.println("1");
                            Thread.currentThread().sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        synchronized (B) {
                            System.out.println("11");
                        }
                    }
                }
            });
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (B) {
                        System.out.println("21");
                        synchronized (A) {
                            System.out.println("22");
                        }
                    }
                }
            });
            t1.start();
            t2.start();
        }
    }

第二个死锁的例子:

class DeadLockTask implements Runnable{
        private Object locka = new Object();
        private Object lockb = new Object();
        public boolean flag = true;
    
        @Override
        public void run() {
            if(flag){
                while(true){
                    synchronized (locka) {
                        System.out.println("if .... locka");//同步嵌套情况，如果此时t1持locka运行至此，而t2持lockb运行至下处，那么就会出现争夺锁（资源）的情况，就会产生死锁。
                        synchronized (lockb) {
                            System.out.println("if .... lockb");
                        }
                    }
                }
            }else{
                while(true){
                    synchronized (lockb) {
                        System.out.println("else .... lockb");//t2持lockb运行至此；
                        synchronized (locka) {
                            System.out.println("else .... locka");
                        }
                    }
                }
            }
        }
    }
    public class DeadLockDemo { 
        public static void main(String[] args) throws InterruptedException {
            DeadLockTask dlt = new DeadLockTask();
            Thread t1= new Thread(dlt);
            Thread t2= new Thread(dlt);
            // 启动线程
            t1.start(); 
            // t1是启动了，但是并不能马上运行，t1进不去if模块，为了让t1执行，进入if模块，我们必须让main线程睡眠一会
            Thread.sleep(1);
            // 修改标记，让t2进入else模块，让他们进入不同的模块，才会出现争夺资源的情况。
            dlt.flag = false;
            t2.start();
        }
    }