Java中的死锁问题

死锁问题：

　　例如有两个线程, 线程1与线程2.

　　线程1在执行的过程中, 要锁定对象1, 2才能完成整个操作, 首先锁定对象1, 再锁定对象2.

　　线程2在执行的过程中, 要锁定对象2, 1才能完成整个操作, 首先锁定对象2, 再锁定对象1.

　　某时刻, 线程1已经拥有对象1的锁, 要是再拥有对象2的锁就能完成整个操作, 可惜了, 你等待着的对象2的锁已经被别人拥有了, 执行不下去了.

　　此时刻, 线程2已经拥有对象2的锁, 要是再拥有对象1的锁就能完成整个操作, 可惜了, 你等待着的对象1的锁已经被别人拥有了, 执行不下去了.

　　两个对象都已经锁了, 腰都要求对象放锁, 不可能, 那就都等着吧............

死锁例程：

public class DeadLock implements Runnable{
	public int flag ;
	static Object o1 = new Object();
	static Object o2 = new Object();
	@Override
	public void run() {
		System.out.println("flag: "+flag);
		if(flag == 1) {
			synchronized(o1){
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			synchronized(o2){
				System.out.println("1");
			}
		}
		if(flag == 0){
			synchronized(o2){
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			synchronized(o1){
				System.out.println("0");
			}
		}
	}
	public static void main(String[] args) {
		DeadLock de1 = new DeadLock();
		DeadLock de2 = new DeadLock();
		de1.flag = 1;
		de2.flag = 0;
		Thread t1 = new Thread(de1);
		Thread t2 = new Thread(de2);
		t1.start();
		t2.start();
	}
}

Demo_1:

public class TT1 implements Runnable {
	public int b;
	public synchronized void m1() throws Exception { // 只是方法锁定而已, 别的线程无法执行它
		b = 1000;                                    // 其他的线程无法再调用它(方法里面的东西(语句))
		Thread.sleep(5000);
		System.out.println("b = "+b);
	}
	public void m2() {
		System.out.println(b);
	}
	@Override
	public void run() {
		try {
			m1();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public static void main(String[] args) throws Exception{
		TT1 tt1 = new TT1();
		Thread t = new Thread(tt1);
		t.start();
		Thread.sleep(1000);
		tt1.m2();
	}
}

运行结果：

1000
b = 1000

Demo_2:

public class TT2 implements Runnable {
	public int b = 100;
	public synchronized void m1() throws Exception { // 互斥, 在某一时刻, 保证只有一个线程进入我们这个方法里面
		b = 1000;                                    // 但是, 不保证其他的线程是不是能够进入到另外一个方法里面
		Thread.sleep(5000);
		System.out.println("b = "+b);
	}
	public void m2() throws Exception {
		Thread.sleep(2500);
		b = 2000;
	}
	@Override
	public void run() {
		try {
			m1();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public static void main(String[] args) throws Exception{
		TT2 tt = new TT2();
		Thread t = new Thread(tt);
		t.start();
		tt.m2();
	}
}

运行结果：

b = 2000

　　在Demo_2中, 如果在 m2() 的方法也加 synchronized. 同时在主方法中的 tt.m2() 后面加一句: System.out.println(tt.b);

则, 运行结果为：

1000

b = 1000 // 这句话执行得比较快.

【注】：当某个对象调用了同步方法时, 该对象上的其它同步方法必须等待该同步方法执行完毕后, 才能被执行.

【注】：其实, 写一个同步的东西是挺困难的. 因为每一个方法要不要同步, 你要考虑得非常清楚.如果一个方法

　　　　做了同步, 另外一个方法没有做同步, 那么你要记住一点: 别的线程可以自由得访问那个非同步的方法,

　　　　并且可能会对你那个同步的方法产生影响, 所以你要保护好某一个类里面的某一个对象的话, 或者说你

　　　　要保护好需要同步的那个对象的话, 你必须对访问这个对象的所有方法仔细考虑, 加不加同步, 加了同

　　　　步, 很有可能效率很低, 不加同步, 有可能产生数据不一致的现象.