死锁：

概念：

所谓死锁： 是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。 由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象：死锁。

死锁发生的条件：

1.互斥条件：一个资源每次只能被一个线程使用

2.不可抢占条件（不剥夺条件）：当前进程锁获得的资源，在未结束前，不能强行剥夺

3.占有且申请条件（请求与保持条件）：一个进程已拥有一定的资源，又想申请别的资源，但对自己的资源又不放弃

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

一般什么时候出现？  同步中嵌套同步

造一个死锁出来:

class Test2 implements Runnable
{
    private boolean flag;
    Test2(boolean flag )
    {
        this.flag = flag;
    }
    @Override
    public void run()
    {
        // TODO Auto-generated method stub
        if (flag)
        {
            synchronized (MyLock.locka)
            {
                System.out.println(Thread.currentThread().getName()+" if locka");
                synchronized (MyLock.lockb)
                {
                    System.out.println(Thread.currentThread().getName()+" if lockb");
                }
            }
        }
        else
        {
            synchronized (MyLock.lockb)
            {
                System.out.println(Thread.currentThread().getName()+" else lockb");
                synchronized (MyLock.locka)
                {
                    System.out.println(Thread.currentThread().getName()+" else locka");
                }
            }
        }
    }
}

class MyLock
{
    static Object locka = new Object();
    static Object lockb = new Object();
}

public class DieLockTest
{
    public static void main(String[] args)
    {
        Thread t1 = new Thread(new Test2(true));
        Thread t2 = new Thread(new Test2(false));

        t1.start();
        t2.start();

    }
}

将之前验证同步函数的锁是this的程序也弄成死锁：

class Test1 implements Runnable
{
    private static int num = 500;
    Object obj = new Object();
    boolean flag = true;
    public  void run ()
    {
        if (flag)
        {
            while (true)
            {
                synchronized (obj)//锁是obj
                {
                    show ();//锁是this
                }
            }
        }
        else
        {
            while (true)
            {
                show();
            }
        }
    }
    public  synchronized void show ()//  锁是 this
    {
        synchronized (obj)//锁是 obj
        {
            if (num >= 0)
            {
                try
                {
                    Thread.sleep(20);
                }
                catch (Exception e)
                {
                    // TODO: handle exception
                    System.out.println(e.toString());
                }
                System.out.println(Thread.currentThread().getName()+">>--code-- "+num--);
            }
        }
    }
}


public class DieLock
{
    public static void main (String[] args)
    {
        Test1 t = new Test1();
        Thread a = new Thread(t);
        Thread b = new Thread(t);


        a.start();
        try
        {
            Thread.sleep(20);
        }
        catch (Exception e)
        {
            // TODO: handle exception
        }
        t.flag = false;
        b.start();

    }
}

死锁的预防：

死锁的预防是保证系统不进入死锁状态的一种策略。

知道了死锁发生的条件，要避免死锁就要从打破条件入手。

点击打开链接

Java---16---多线程---死锁