死锁的定义：
1、一般的死锁
一般的死锁是指多个线程的执行必须同时拥有多个资源，由于不同的线程需要的资源被不同的线程占用，最终导致僵持的状态，这就是一般死锁的定义。
package com.cxt.thread;
public class TestDeadLock extends Thread{
boolean b;
DeadLock lock;
public TestDeadLock(boolean b, DeadLock lock) {
super();
this.b = b;
this.lock = lock;
}
public static void main(String[] args) {
DeadLock lock = new DeadLock();
TestDeadLock t1 = new TestDeadLock(true, lock);
TestDeadLock t2 = new TestDeadLock(false, lock);
t1.start();
t2.start();
}
@Override
public void run() {
if(this.b){
lock.m1();
}
else
lock.m2();
}
}
class DeadLock {
Object o1 = new Object();
Object o2 = new Object();
void m1(){
synchronized(o1){
System.out.println("m1 Lock o1 first");
synchronized(o2){
System.out.println("m1 Lock o2 second");
}
}
}
void m2(){
synchronized(o2){
System.out.println("m2 Lock o2 first");
synchronized(o1){
System.out.println("m2 Lock o1 second");
}
}
}
}
如代码所示我们可知：线程t1,t2都需要对象o1,o2才能正常地完成功能，但是由于他们所持的对象与要获得的对象刚好相反，使得两条线程一直僵持，
最终导致死锁。
解决方法：等其中一条线程完全执行完之后再执行另外一条线程。
推广到多条线程，按一定的顺序执行多条线程。
另外一种方法就是设置优先级，如果运行多条线程出现死锁，优先级低的回退，优先级高的先执行这样即可解决死锁问题。
2、嵌套管程锁死
线程1获得A对象的锁。
线程1获得对象B的锁（同时持有对象A的锁）。
线程1决定等待另一个线程的信号再继续。
线程1调用B.wait()，从而释放了B对象上的锁，但仍然持有对象A的锁。 线程2需要同时持有对象A和对象B的锁，才能向线程1发信号。
线程2无法获得对象A上的锁，因为对象A上的锁当前正被线程1持有。
线程2一直被阻塞，等待线程1释放对象A上的锁。 线程1一直阻塞，等待线程2的信号，因此，不会释放对象A上的锁，
而线程2需要对象A上的锁才能给线程1发信号……
看代码：
package com.cxt.Lock; import com.cxt.thread.Synchronizer;
import com.cxt.thread.TestLock; //lock implementation with nested monitor lockout problem
/**
* 一个坑爹的嵌套管程锁死，区别于死锁
*/
public class Lock {
protected MonitorObject monitorObject = new MonitorObject();
protected boolean isLocked = false; public static void main(String[] args) {
Lock l = new Lock();
l.isLocked = true; MyRunnable r1 = new MyRunnable(l, );
MyRunnable r2 = new MyRunnable(l, );
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
/*
* 時而鎖住，時而釋放，因為另外兩條線程沒有有时捕捉不到isLocked = false
*/
// for (int i = 0; i < 100; i++) {
// l.isLocked = false;
// try {
// Thread.sleep(10);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// }
// } public void lock() throws InterruptedException {
// 当执行这个方法时，isLocked=true时,其他方法无论执行lock方法还是执行Unlock方法都会导致管程死锁
// 只有手动将isLocked 设置为false才能解决死锁，设置为false时必须让其他线程检测到，所以必须设置时间长一点
synchronized (this) {
while (isLocked) {
synchronized (this.monitorObject) {
this.monitorObject.wait();
}
}
isLocked = true;
}
} public void unlock() {
synchronized (this) {
this.isLocked = false;
synchronized (this.monitorObject) {
this.monitorObject.notify();
}
}
} static class MyRunnable implements Runnable {
Lock l = null;
int i; public MyRunnable(Lock l, int i) {
this.l = l;
this.i = i;
} @Override
public void run() {
try {
if (i % == ) {
this.l.lock();
} else {
this.l.unlock();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
} }
}
我们观察lock()方法,执行lock（）时，当isLocked 为true时，问题就来了，执行monitorObject的方法块，
但是monitorObject变成了等待状态，但是这是外面的this锁还是被此线程持有的，如果有其他线程要执行lock（）
或者unLock（）,此时都会产生无限等待的状态，此线程也因此永远处于无限带等待其他线程来唤醒monitorObject的状态，
最终就一直僵持着。
解决方法手动将isLocked设为false.
这一种较坑，编代码时别没事找事做。
3、重入锁死
package com.cxt.Lock;
public class Lock2{
private boolean isLocked = false;
public static void main(String[] args) {
Lock2 lock = new Lock2();
MyRunnable r1 = new MyRunnable(lock, true);
MyRunnable r2 = new MyRunnable(lock, false);
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
// t2.start();
}
public synchronized void lock()
throws InterruptedException{
while(isLocked){
wait();
}
isLocked = true;
}
public synchronized void unlock(){
isLocked = false;
notify();
}
static class MyRunnable implements Runnable{
Lock2 l = null;
boolean flag = false;
public MyRunnable(Lock2 l, boolean flag) {
this.l = l;
this.flag = flag;
}
@Override
public void run() {
if(flag == true)
try {
// 如果连续执行两次lock(),就会产生系统无限等待的状态
// 解决方法就是在两次中间执行一次unLock()方法
l.lock();
System.out.println("Lock!");
// l.unlock();
// System.out.println("Unlock!");
l.lock();
System.out.println("Lock!");
} catch (InterruptedException e) {
e.printStackTrace();
}
else
l.unlock();
}
}
}
当连续执行两次lock()时会出现：
第一次，isLocked为false，执行完把isLocked设为true.
第二次，isLocked为true，此时就会处于无限等待的状态。
解决方法，两个lock（）中间执行一次unLock方法，或者由另外一条线程来执行一次unLock（）方法。
【重入锁】
package com.text;
public class Lock2{
private boolean isLocked = false;
public static void main(String[] args) {
Lock2 lock = new Lock2();
MyRunnable r1 = new MyRunnable(lock, true);
MyRunnable r2 = new MyRunnable(lock, false);
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
// t2.start();
}
public synchronized void lock()
throws InterruptedException{
while(isLocked){
System.out.println("synchronized wait()!");
unlock();
wait();
}
isLocked = true;
System.out.println("synchronized lock!");
}
public synchronized void unlock(){
isLocked = false;
notify();
System.out.println("synchronized unlock!");
}
static class MyRunnable implements Runnable{
Lock2 l = null;
boolean flag = false;
public MyRunnable(Lock2 l, boolean flag) {
this.l = l;
this.flag = flag;
}
@Override
public void run() {
if(flag == true)
try {
// 如果连续执行两次lock(),就会产生系统无限等待的状态
// 解决方法就是在两次中间执行一次unLock()方法
l.lock();
System.out.println("Lock!");
l.lock();
// l.unlock(); //注释了
System.out.println("Lock!");
} catch (InterruptedException e) {
e.printStackTrace();
}
else
l.unlock();
}
}
}
输出：
synchronized lock!
Lock!
synchronized wait()!
synchronized unlock!
在一个synchronized方法/块的内部调用本类的其他synchronized方法/块时，是永远可以获得锁的。
package com.text;
public class Lock2{
private boolean isLocked = false;
public static void main(String[] args) {
Lock2 lock = new Lock2();
MyRunnable r1 = new MyRunnable(lock, true);
MyRunnable r2 = new MyRunnable(lock, false);
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
// t2.start();
}
public synchronized void lock()
throws InterruptedException{
while(isLocked){
System.out.println("synchronized wait()!");
wait();
}
isLocked = true;
System.out.println("synchronized lock!");
}
public synchronized void unlock(){
isLocked = false;
notify();
System.out.println("synchronized unlock!");
}
static class MyRunnable implements Runnable{
Lock2 l = null;
boolean flag = false;
public MyRunnable(Lock2 l, boolean flag) {
this.l = l;
this.flag = flag;
}
@Override
public void run() {
if(flag == true)
try {
// 如果连续执行两次lock(),就会产生系统无限等待的状态
// 解决方法就是在两次中间执行一次unLock()方法
l.lock();
System.out.println("Lock!");
l.lock();
l.unlock(); //取消注释了
System.out.println("Lock!");
} catch (InterruptedException e) {
e.printStackTrace();
}
else
l.unlock();
}
}
}
输出：
synchronized lock!
Lock!
synchronized wait()!
因为连续两个lock方法，导致在第二次时形成死锁，第三次的unlock由于不是在synchronized方法/块内调用的，所以无法获取锁，