死锁的两种情况：

简单的说下单块cpu运行多线程的情况：

大家可能平时玩电脑，可以同时挂QQ啊，玩游戏啊，打开文本啊，等等。这里，我们假设是单块cpu。也就是俗称的单核cpu。
大家可能会觉得这些软件，这些线程是同时运行的，
其实不然，其实在任何一种情况下，电脑都只运行一个线程！
只是因为这个单块的cpu内部为我们划分了很多很多的时间块，
而这个时间的划分是以纳秒为单位的，也就是说，这个10纳秒我运行这个线程，下个10纳秒运行另外一个线程（或者又被上一个线程抢到了（只是被上一个线程抢到的概率小，这是cpu调度器的算法决定了的），它会慢慢平衡的，不可能一直让某一个线程一直抢占cpu调度器资源），所以说，它运行并不是连续的，只是间隔时间太短，我们感觉不出来而已！！！

第一种情况：

1）多个线程共用同一个对象锁，互相等待。
两个线程共用一个锁，一个线程拿着锁来调用另外一个线程，于是出现了死锁情况！

package thread.deadLock.lock1;
/**
 * 简单的类
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class S {
    public int a = 0 ;
}

package thread.deadLock.lock1;
/**
 * 含有main方法的类
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class DeadLock1 {
    public static void main(String[] args) {
        S s = new S();
        Thread b = new Thread(new ThreadB(s));
        Thread a = new Thread(new ThreadA(s,b));
        a.start();
        b.start();
    }


}

package thread.deadLock.lock1;
/**
 * ThreadB类
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class ThreadB implements Runnable{
    private S s = null;


    public ThreadB(S s) {
        this.s = s;
    }


    @Override
    public  void run() {
        System.out.println("线程B在等待锁s！");
        synchronized (s) {
            System.out.println("线程B拿到锁s！");
            s.a=100;
            System.out.println("线程B  s.a = " + s.a);
        }
    }

}

package thread.deadLock.lock1;
/**
 * ThreadA类
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class ThreadA implements Runnable{
    private S s = null;
    private Thread b = null;

    public ThreadA(S s,Thread b) {
        this.b = b;
        this.s = s;
    }


    @Override
    public  void run() {
        System.out.println("线程A在等待锁s！");
        synchronized (s) {
            System.out.println("线程A拿到锁s！");
            try {
                //调用b线程的运行代码。
                //但是此时的锁在a线程手里，b拿不到锁。
                //所以出现了，b等待a给锁，a就拿着锁等待b运行，所以出现了死锁！
                b.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("s.a = " + s.a);
        }
    }

}

运行结果只有一种情况，一定锁死！

第二种情况：

2）互相持有对方所需的资源（即每个线程都需要同时拿到多个资源才能继续执行，而多个线程都处于：各持有一部分，在等待另一部分。）

package thread.deadLock.lock2;
/**
 * 资源类1
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class S1 {
    public int a =0;
}

package thread.deadLock.lock2;
/**
 * 资源类2
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class S2 {
    public int a =1;
}

package thread.deadLock.lock2;
/**
 * 
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class DeadLock2 {

    public static void main(String[] args) {
        //如果要解决这种多资源出现的死锁，可以把多个资源打包成一个综合资源，
        //把综合资源变成一个对象锁,哪个线程一拿到锁就有全部资源了
        //在设计阶段就应该考虑到----把多线程中的每个线程所用的互斥资源图画出来
        //--从图中看出哪些线程存在共享互斥资源，然后分析是否可能存在死锁
        //这个死锁存在随机性！！！

        S1 s1 = new S1();
        S2 s2 = new S2();

        Thread a = new Thread(new ThreadA(s1,s2));
        Thread b = new Thread(new ThreadB(s1,s2));

        a.start();
        b.start();

    }

}

package thread.deadLock.lock2;
/**
 * ThreadA---a线程运行代码类
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class ThreadA implements Runnable{
    private S1 s1 = null;
    private S2 s2 = null;


    public ThreadA(S1 s1, S2 s2) {
        this.s1 = s1;
        this.s2 = s2;
    }


    @Override
    public void run() {
        System.out.println("线程a在等待锁s1!");
        synchronized (s1) {//拿到了锁s1
            System.out.println("s1.a=" + s1.a);
            System.out.println("线程a拿到了锁s1");
            System.out.println("线程a在等待锁s2");
            synchronized (s2) {//拿到锁s2
                System.out.println("线程a拿到了锁s2");
                System.out.println("s2.a=" + s2.a);
            }//释放锁s2
            System.out.println("线程a释放了锁s2");
        }//释放锁s1


    }

}

package thread.deadLock.lock2;
/**
 * ThreadB---b线程运行代码类
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class ThreadB implements Runnable{
    private S1 s1 = null;
    private S2 s2 = null;



    public ThreadB(S1 s1, S2 s2) {
        this.s1 = s1;
        this.s2 = s2;
    }



    @Override
    public void run() {
        System.out.println("线程b在等待锁s2!");
        synchronized (s2) {//拿到了锁s2
            System.out.println("s2.a=" + s2.a);
            System.out.println("线程b拿到了锁s2");
            System.out.println("线程b在等待锁s1");
            synchronized (s1) {//拿到锁s1
                System.out.println("线程b拿到了锁s1");
                System.out.println("s1.a=" + s1.a);
            }//释放锁s1
            System.out.println("线程b释放了锁s1");
        }//释放锁s2


    }

}

这个情况下的死锁会出现2中情况：：

第一种：没有死锁：
这种情况的出现是因为可能a线程或者b线程抢到了cpu资源，一次就全部运行完了，这样，就不会出现死锁！

第二种：出现了死锁：
假如a线程拿到了s1的锁，还没有拿到s2的锁，
这个时候s2的锁被b线程拿到了，b线程就开始等待s1锁，而s1锁在a线程手上，a线程就等s2锁啊，b线程就等s1锁，，，于是，出现了死锁！

大家可以看到，这个死锁的情况下，程序并没有停止运行的，那个程序运行的红方块标志还亮着呢！
前面那图没有出现死锁的情况下，程序运行一下就输出完了，红方块是暗的！

总结：

死锁的解决
(死锁并没有解决的方案，只能从源头上去避免！)
要从设计方面去解决避免，即在设计时就考虑不能出现死锁。
罗列出所有临界资源，画分布图，从图中观察其中的死锁情况，改变其中线程的(临界)资源的获取方式。
设计原则：尽量让程序中少出现临界资源。

wait/notify 和 sleep方法

wait和notify只能在它们被调用的实例的同步块内使用，而sleep()到处都可以用。
wait()和sleep()最大的区别：sleep()不释放对象锁，而wait()会释放，因此从效率方面考虑wait()方法更好。

同步设计的基本原则
◎ 同步块中(synchronized修饰)的代码越小越好！
◎ 同步块中不要写阻塞性代码(如，InputStream.read() )！
◎ 在持有锁的时候，不要对其它对象调用方法。（如果做到，可以消除最常见的死锁源头。）

同步概述
◎同步的原理：将需要同步的代码进行封装，并在该代码上加了一个锁。
◎同步的好处：解决多线程的安全问题。
◎同步的弊端：会降低性能。
◎同步的前提：必须要保证有多个线程且它们在同步中使用的是同一个锁。