★ 死锁的两种情况：
简单的说下单块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() )！
◎ 在持有锁的时候，不要对其它对象调用方法。（如果做到，可以消除最常见的死锁源头。）
★ 同步概述
◎同步的原理：将需要同步的代码进行封装，并在该代码上加了一个锁。
◎同步的好处：解决多线程的安全问题。
◎同步的弊端：会降低性能。
◎同步的前提：必须要保证有多个线程且它们在同步中使用的是同一个锁。