java中关于死锁的概念和实例操作

关于synchronize死锁的例子和避免死锁的例子

产生死锁的原因主要是：
　　（1） 因为系统资源不足。
　　（2） 进程运行推进的顺序不合适。
　　（3） 资源分配不当等。

产生死锁的四个必要条件：
　　（1） 互斥条件：一个资源每次只能被一个进程使用。
　　（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
　　（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
　　（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

死锁的解除与预防：
　　理解了死锁的原因，尤其是产生死锁的四个必要条件，就可以最大可能地避免、预防和
　　解除死锁。所以，在系统设计、进程调度等方面注意如何不让这四个必要条件成立，如何确
　　定资源的合理分配算法，避免进程永久占据系统资源。此外，也要防止进程在处于等待状态
　　的情况下占用资源。因此，对资源的分配要给予合理的规划。

那么接下来我们进入代码区域一起来看看关于死锁和解锁死锁的那些例子吧：

/*
 * @author Mr liu
 * 介绍死锁的概念然后怎样避免死锁的发生
 */
public class synchronizLock {
    public static void main(String[] args) {
        Thread T1=new Thread(new Runnable() {
            public void run() {
                synchronizLock.method1();
            }
        });
        Thread T2=new Thread(new Runnable() {
            public void run() {
                synchronizLock.method2();
            }
        });
        T1.start();
        T2.start();
        
    }
    public static void method1(){

//线程a
        synchronized (String.class) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("正在努力获取String类型的class");
            synchronized (Integer.class) {
                System.out.println("获取Integer类型的class");
            }
        }
    }
    public static void method2(){

//线程b
        synchronized (Integer.class) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("正在努力获取Integer类型的class");
            synchronized (String.class) {
                System.out.println("获取String类型的class");
            }
        }
    }

}

输出结果：

这个时候就造成了死锁的发生：堵塞（原因） 无限继续向下堵塞   线程b获取不到所需的线程a  线程a也获取不到所需的线程b

 

那么我们来看一下避免死锁的例子：

/*
 * @author Mr liu
 * 介绍死锁的概念然后怎样避免死锁的发生
 */
public class synchronizLock {
    public static void main(String[] args) {
        Thread T1=new Thread(new Runnable() {
            public void run() {
                synchronizLock.method1();
            }
        });
        Thread T2=new Thread(new Runnable() {
            public void run() {
                synchronizLock.method2();
            }
        });
        T1.start();
        T2.start();
        
    }
    public static void method1(){

//线程a
        synchronized (Integer.class) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("正在努力获取Integer类型的class");
            synchronized (String.class) {
                System.out.println("获取String类型的class");
            }
        }
    }
    public static void method2(){

//线程b
        synchronized (Integer.class) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("正在努力获取Integer类型的class");
            synchronized (String.class) {
                System.out.println("获取String类型的class");
            }
        }
    }

}

输出结果：

我们看到此时的线程a 持有 线程b需要的锁，而线程b持有线程a需要的锁的逻辑了 （同步锁一致）可以理解为锁之间的各有所需一一对应了

 

总结：上面就是我在基础自学中总结出来的结果，关于更多的锁知识的内容下次更新，各位大佬如有其它更好的方法欢迎大家评论留言。