线程：Lock接口和死锁

     1.Lock接口
    java.utils.concurrent包是jdk1.5新增的，用来处理多线程。实现java.util.concurrent.locks.Lock接口的类具有与synchronized关键字同样的功能，但是它更加强大一些。java.utils.concurrent.locks.ReentrantLock是较常用的实现了Lock接口的类。下面是ReentrantLock类的一个应用实例：

1. package edu.hust.test;
3. import java.util.concurrent.locks.ReentrantLock;
5. public class ThreadLock extends ReentrantLock {
6.     private static final long serialVersionUID = 1L;
8.     public void execute_lock1() {
9.         this.lock();
10.         try {
11.             for (int i = 0; i < 5; i++) {
12.                 System.out.println(Thread.currentThread().getName() + " 位于/"同步块/"中 " + i);
13.                 Thread.sleep(999999999);
14.             }
15.         } catch (InterruptedException e) {
16.             System.out.println("谁把我吵醒了.....");
17.         } finally {
18.             this.unlock();
19.         }
20.     }
21.     
22.     public synchronized void execute_lock2() {
23.         //lock.lock();
24.         try {
25.             for (int i = 0; i < 5; i++)
26.                 System.out.println(Thread.currentThread().getName() + " 位于/"同步块/"中 " + i);
27.         } finally {
28.             //lock.unlock();
29.         }
30.     }
31.     
32.     public static void main(String[] args) {
33.         final ThreadLock threadLock = new ThreadLock();
34.         
35.         Thread thread1 = new Thread(new Runnable() {
36.             public void run() {
37.                 threadLock.execute_lock1();
38.             }
39.         }, "红薯Thread");
40.         
41.         Thread thread2 = new Thread(new Runnable() {
42.             public void run() {
43.                 threadLock.execute_lock1();
44.             }
45.         }, "土豆Thread");
46.         
47.         Thread thread3 = new Thread(new Runnable() {
48.             public void run() {
49.                 threadLock.execute_lock2();
50.             }
51.         }, "青菜Thread");
52.         
53.         thread1.start();
54.         thread2.start();
55.         thread3.start();
56.     }
57.     /*
58.      * 输出结果：
59.      * 红薯Thread 位于"同步块"中 0
60.      * 青菜Thread 位于"同步块"中 0
61.      * 青菜Thread 位于"同步块"中 1
62.      * 青菜Thread 位于"同步块"中 2
63.      * 青菜Thread 位于"同步块"中 3
64.      * 青菜Thread 位于"同步块"中 4
65.      * */
66. }

    lock()方法用于锁定对象，unlock()方法用于释放对对象的锁定，他们都是在Lock接口中定义的方法。位于这两个方法之间的代码在被执行时，效果等同于被放在synchronized同步块中。 一般用法是将需要在lock()和unlock()方法之间执行的代码放在try{}块中，并且在finally{}块中调用unlock()方法，这样就可以保证即使在执行代码抛出异常的情况下，对象的锁也总是会被释放，否则的话就会为死锁的产生增加可能。
     和synchronized关键字不同，lock只把当前方法锁定，其他的方法(不论是同步还是非同步的)并没有被锁定。

    2.死锁
    死锁就是一个进程中的每个线程都在等待这个进程中的其他线程释放所占用的资源，从而导致所有线程都无法继续执行的情况。死锁是多线程编程中一个隐藏的陷阱，它经常发生在多个线程共用资源的时候。在实际开发中，死锁一般隐藏的较深，不容易被发现。程序中必须同时满足以下四个条件才会引发死锁：
    (1)互斥（Mutual exclusion）：线程所使用的资源中至少有一个是不能共享的，它在同一时刻只能由一个线程使用。
    (2)持有与等待（Hold and wait）：至少有一个线程已经持有了资源，并且正在等待获取其他的线程所持有的资源。
    (3)非抢占式（No pre-emption）：如果一个线程已经持有了某个资源，那么在这个线程释放这个资源之前，别的线程不能把它抢夺过去使用。
    (4)循环等待（Circular wait）：假设有N个线程在运行，第一个线程持有了一个资源，并且正在等待获取第二个线程持有的资源，而第二个线程正在等待获取第三个线程持有的资源，依此类推……第N个线程正在等待获取第一个线程持有的资源，由此形成一个循环等待。

1. package edu.hust.test;
3. /**
4.  * @author Forrest He
5.  * created on 2008-11-17
6.  */
7. public class DeadLockDemo implements Runnable {
8.     int i; //用于判断线程是否被占用
9.     
10.     /*
11.      * 必须是static的, static表示锁住的是Object类; 而非static锁住的是Object的对象, 在这里不符合要求.
12.      * */
13.     private static Object print_one = new Object(); //第一台打印机
14.     private static Object print_two = new Object(); //第二台打印机
15.     
16.     public void run() {
17.         if (i == 0) { //先占用print_one, 并等待print_two
18.             synchronized (print_one) {
19.                 System.out.println("print_one已被占用, 正等待print_two");
20.                 try {
21.                     Thread.sleep(1000);
22.                 } catch (InterruptedException e) {
23.                     System.err.println("谁把我吵醒了！！！");
24.                 }
25.                 synchronized (print_two) {
26.                     System.out.println("已获取print_two, 任务完成");
27.                 }
28.             }
29.         } else if (i == 1) { //先占用print_two, 并等待print_one
30.             synchronized (print_two) {
31.                 System.out.println("print_two已被占用, 正等待print_one");
32.                 try {
33.                     Thread.sleep(1000);
34.                 } catch (InterruptedException e) {
35.                     System.err.println("谁把我吵醒了！！！");
36.                 }
37.                 synchronized (print_one) {
38.                     System.out.println("已获取print_one, 任务完成");
39.                 }
40.             }
41.         }
42.     }
43.     
44.     public static void main(String[] args) {
45.         DeadLockDemo deadLock_one = new DeadLockDemo();
46.         DeadLockDemo deadLock_two = new DeadLockDemo();
47.         deadLock_one.i = 0;
48.         deadLock_two.i = 1;
49.         new Thread(deadLock_one).start();
50.         new Thread(deadLock_two).start();
51.     }
53. }