杰神之Java多线程与死锁

多线程卖火车票问题:

public class Demo05 {
    public static void main(String[] args) {
        newThread 买票12306=new newThread();
        newThread 黄牛=new newThread();
        newThread 手机APP=new newThread();
        买票12306.start();
        黄牛.start();
        手机APP.start();
    }
}
class newThread extends Thread{
    private static int 票数=1000;
    private Object obj=new Object();
    public void run() {
        while(true) {
                if (票数<=0) {
                    break;
                }
                try {
                    sleep(10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                票数-=1;
                System.out.println(Thread.currentThread().getName()+"    "+票数);
            }
        }
}

当多个线程同时访问一个数据时,很容易出现问题。为了避免这种情况出现,我们要保证线程同步互斥,就是指并发执行的多个线程,在同一时间内只允许一个线程访问共享数据。
Java中可以使用synchronized关键字来取得一个对象的同步锁。

// Object可以为任何对象,表示当前线程取得该对象的锁。
synchronized (Object) {
}

修改一下上面的案例,在run方法中加入同步锁:

public class Demo05 {
    public static void main(String[] args) {
        newThread 买票12306=new newThread();
        newThread 黄牛=new newThread();
        newThread 手机APP=new newThread();
        买票12306.start();
        黄牛.start();
        手机APP.start();
    }
}
class newThread extends Thread{
    private static int 票数=1000;
    private Object obj=new Object();
    public void run() {
        while(true) {
            synchronized(obj) {
                if (票数<=0) {
                    break;
                }
                try {
                    sleep(10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                票数-=1;
                System.out.println(Thread.currentThread().getName()+"    "+票数);
            }
            //让线程放弃CPU资源
            Thread.yield();
        }
    }
}

死锁

同步锁虽好,但也要科学使用,不然就会发生死锁,何为死锁,就是多个线程同时被阻塞,它们中的一个或者全部都在等待某个资源被释放。
举个栗子,两个人面对面过独木桥,甲和乙都已经在桥上走了一段距离,即占用了桥的资源,甲如果想通过独木桥的话,乙必须退出桥面让出桥的资源,让甲通过,但是乙不服,为什么让我先退出去,我还想先过去呢,于是就僵持不下,导致谁也过不了桥,这就是死锁。

public class Demo07 {
    public static void main(String[] args) {
        new Thread() {
            private boolean isTrue=true;
            @Override
            public void run() {
                while(true) {
                    if(isTrue) {
                        synchronized (LockA.LOCK_A) {
                            System.out.println("if---LockA");
                            synchronized (LockB.LOCK_B) {
                                System.out.println("if---LockB");
                            }
                        }
                    }else {
                        synchronized (LockB.LOCK_B) {
                            System.out.println("else---LockB");
                            synchronized (LockA.LOCK_A) {
                                System.out.println("else---LockA");
                            }
                        }
                    }
                    isTrue=!isTrue;
                }
            }
        }.start();
        new Thread() {
            private boolean isTrue=true;
            @Override
            public void run() {
                while(true) {
                    if(isTrue) {
                        synchronized (LockA.LOCK_A) {
                            System.out.println("if---LockA");
                            synchronized (LockB.LOCK_B) {
                                System.out.println("if---LockB");
                            }
                        }
                    }else {
                        synchronized (LockB.LOCK_B) {
                            System.out.println("else---LockB");
                            synchronized (LockA.LOCK_A) {
                                System.out.println("else---LockA");
                            }
                        }
                    }
                    isTrue=!isTrue;
                }
            }
        }.start();
    }
}
class LockA{
    private LockA() {

    }
    //定义一个常量作为锁对象 不能修改也不能创建
    public static final LockA LOCK_A=new LockA();
}
class LockB{
    private LockB() {

    }
    public static final LockB LOCK_B=new LockB();
}

第一个线程锁住了资源1(
A一部分资源),第二个线程锁住了资源2(一部分资源),线程1企图锁住资源2(A让B释放资源,B不放),进入阻塞,线程2企图锁住资源1(B让A释放资源,A不放),进入阻塞,死锁了。
死锁的产生是有规律可循的,只有同时满足以下四个条件,死锁才会产生。
* 1.互斥条件:一个资源每次只能被一个进程使用。独木桥每次只能通过一个人。
* 2.请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。

  • 3.不剥夺条件: 进程已获得的资源,在未使用完之前,不能强行剥夺。

  • 4.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

知道了死锁产生的必要条件,在开发中就很容易避免死锁问题了。

阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/lyj243719866/article/details/79274873
文章标签: Java 多线程
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

不良信息举报

杰神之Java多线程与死锁

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭