Thread线程中的死锁

死锁的产生原理

假如就两个线程 ： 线程1 已拥有资源a 又去请求资源b
线程2 已拥有资源b 又去请求资源a
线程1 等待 线程2 释放资源b，而线程2 等待 线程2 释放资源a
这样就产生了死锁

代码如下

package com.hp.thread4;

/**
 * 死锁
 */
public class DeadLock implements Runnable {
    private int flag; //定义全局变量,用来决定线程走向
    private static Object obj1 = new Object(); //Object对象必须是静态的
    private static Object obj2 = new Object(); //Object对象必须是静态的

    public DeadLock(int flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if (flag == 1) {
            //线程1
            //synchronized 同步
            synchronized (obj1) {
                System.out.println(Thread.currentThread().getName() + "已获取到资源obj1,正在请求obj2");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //synchronized 同步
                synchronized (obj2) {
                    System.out.println("线程1又获取到资源obj2");
                }
            }

        } else {
            //线程2
            //synchronized 同步
            synchronized (obj2) {
                System.out.println(Thread.currentThread().getName() + "已获取到资源obj2,正在请求obj1");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //synchronized 同步
                synchronized (obj1) {
                    System.out.println("线程2又获取到资源obj1");
                }
            }
        }
    }
}

package com.hp.thread4.test;

import com.hp.thread4.DeadLock;

public class DeadLockTest {
    public static void main(String[] args) {
        new Thread(new DeadLock(1),"线程1").start();
        new Thread(new DeadLock(2),"线程2").start();
    }
}