java多线程编程 - 实战篇（二）

 

java多线程编程 - 实战篇（二）

来源于：转载自dev2dev网友axman的go deep into java专栏。 　发布时间：2007-12-10 16:58:24

　　本节继续上一节的讨论。

　　 [一个线程在进入对象的休息室(调用该对象的wait()方法)后会释放对该对象的锁]，基于这个原因。在同步中，除非必要，否则你不应用使用Thread.sleep(long l)方法，因为sleep方法并不释放对象的锁。

　　这是一个极其恶劣的品德，你自己什么事也不干，进入sleep状态，却抓住竞争对象的监视锁不让其它需要该对象监视锁的线程运行，简单说是极端自私的一种行为。但我看到过很多程序员仍然有在同步方法中调用sleep的代码。

　　看下面的例子：

1. class SleepTest {
2.   public synchronized void wantSleep() {
3.     try {
4.       Thread.sleep(1000 * 60);
5.     } catch (Exception e) {
6.     }
7.     System.out.println("111");
8.   }
9.   public synchronized void say() {
10.     System.out.println("123");
11.   }
12. }
14. class T1 extends Thread {
15.   SleepTest st;
16.   public T1(SleepTest st) {
17.     this.st = st;
18.   }
19.   public void run() {
20.     st.wantSleep();
21.   }
22. }
24. class T2 extends Thread {
25.   SleepTest st;
26.   public T2(SleepTest st) {
27.     this.st = st;
28.   }
29.   public void run() {
30.     st.say();
31.   }
32. }
34. public class Test {
35.   public static void main(String[] args) throws Exception {
36.     SleepTest st = new SleepTest();
37.     new T1(st).start();
38.     new T2(st).start();
39.   }
40. }

　　我们看到，线程T1的实例运行后，当前线程抓住了st实例的锁，然后进入了sleep。直到它睡满60秒后才运行到System.out.println("111");然后run方法运行完成释放了对st的监视锁，线程T2的实例才得到运行的机会。

　　而如果我们把wantSleep方法改成：

1.   public synchronized void wantSleep(){
2.     try{
3.       //Thread.sleep(1000*60);
4.       this.wait(1000*60);
5.     }catch(Exception e){}
6.     System.out.println("111");
7.   }

　　我们看到，T2的实例所在的线程立即就得到了运行机会，首先打印了123，而T1的实例所在的线程仍然等待，直到等待60秒后运行到System.out.println("111");方法。

　　所以，调用wait(long l)方法不仅达到了阻塞当前线程规定时间内不运行，而且让其它有竞争需求的线程有了运行机会，这种利人不损己的方法，何乐而不为？这也是一个有良心的程序员应该遵循的原则。

　　当一个线程调用wait(long l)方法后，线程如果继续运行，你无法知道它是等待时间完成了还是在wait时被其它线程唤醒了，如果你非常在意它一定要等待足够的时间才执行某任务，而不希望是中途被唤醒，这里有一个不是非常准确的方法：

1. long l = System.System.currentTimeMillis();
3. wait(1000);//准备让当前线程等待1秒
4. while((System.System.currentTimeMillis() - l) < 1000)//执行到这里说明它还没有等待到1秒
5.                              //是让其它线程给闹醒了
7.     wait(1000-(System.System.currentTimeMillis()-l));//继续等待余下的时间.

　　这种方法不是很准确，但基本上能达到目的。

　　所以在同步方法中，除非你明确知道自己在干什么，非要这么做的话，你没有理由使用sleep，wait方法足够达到你想要的目的。而如果你是一个很保守的人，看到上面这段话后，你对sleep方法深恶痛绝，坚决不用sleep了，那么在非同步的方法中(没有和其它线程竞争的对象)，你想让当前线程阻塞一定时间后再运行，应该如何做呢？(这完全是一种卖弄，在非同步的方法中你就应该合理地应用sleep嘛，但如果你坚决不用sleep，那就这样来做吧)

1.     public static mySleep(long l){
2.         Object o = new Object();
3.         synchronized(o){
4.             try{
5.                 o.wait(l);    
6.             }catch(Exception e){}
7.         }
8.     }

　　放心吧，没有人能在这个方法外调用o.notify[All]，所以o.wait(l)会一直等到设定的时间才会运行完成。
[虚拟锁的使用]

　　虚拟锁简单说就是不要调用synchronized方法(它等同于synchronized(this))和不要调用synchronized(this)，这样所有调用在这个实例上的所有同步方法的线程只能有一个线程可以运行。也就是说：

　　如果一个类有两个同步方法 m1，m2，那么不仅是两个以上线调用m1方法的线程只有一个能运行，就是两个分别调用m1，m2的线程也只有一个能运行。当然非同步方法不存在任何竞争，在一个线程获取该对象的监视锁后这个对象的非同步方法可以被任何线程调用。

　　而大多数时候，我们可能会出现这种情况，多个线程调用m1时需要保护一种资源，而多个线程调用M2时要保护的是另一种资源，如果我们把 m1,m2都设成同步方法。两个分别调用这两个方法的线程其实并不产生冲突，但它们都要获取这个实例的锁(同步方法是同步this)而产生了不必要竞争。

　　所以这里应该采用虚拟锁。

　　即将m1和m2方法中各自保护的对象作为属性a1,a2传进来，然后将同步方法改为方法的同步块分别以a1,a2为参数，这样到少是不同线程调用这两个不同方法时不会产生竞争，当然如果m1,m2方法都操作同一受保护对象则两个方法还是应该作为同步方法。这也是应该将方法同步还是采用同步块的理由之一。 
   

1. package debug;
3. class SleepTest{
6.   public synchronized void m1(){
8.     System.out.println("111");
9.     try{
10.       Thread.sleep(10000);
11.     }catch(Exception e){}
12.   }
13.   
14.   public synchronized void m2(){
15.     System.out.println("123");
16.     
17.   }
18. }
20. class T1 extends Thread{
21.   SleepTest st;
22.   public T1(SleepTest st){
23.     this.st = st;
24.   }
25.   public void run(){
26.     st.m1();
27.   }
28. }
30. class T2 extends Thread{
31.   SleepTest st;
32.   public T2(SleepTest st){
33.     this.st = st;
34.   }
35.   public void run(){
36.     st.m2();
37.   }
38. }
41. public class Test {
42.     public static void main(String[] args) throws Exception{
43.       SleepTest st = new SleepTest();
44.       new T1(st).start();
45.       new T2(st).start();
46.     }
47. }

　　这个例子可以看到两个线程分别调用st实例的m1和m2方法却因为都要获取st的监视锁而产生了竞争。T2实例要在T1运行完成后才能运行(间隔了10秒)。而假设m1方法要操作操作一个文件 f1，m2方法要操作一个文件f2，当然我们可以在方法中分别同步f1,f2，但现在还不知道 f2,f2是否存在，如果不存在我们就同步了一个null对象，那么我们可以使用虚拟锁： 
  

1. package debug;
3. class SleepTest{
5.   String vLock1 = "vLock1";
6.   String vLock2 = "vLock2";
7.   public void m1(){
8.     synchronized(vLock1){
9.       System.out.println("111");
10.       try {
12.         Thread.sleep(10000);
13.       }
14.       catch (Exception e) {}
15.       //操作f1
16.     }
17.   }
18.   
19.   public void m2(){
20.      synchronized(vLock2){
21.        System.out.println("123");
22.        //操作f2
23.      }    
24.   }
25. }
27. class T1 extends Thread{
28.   SleepTest st;
29.   public T1(SleepTest st){
30.     this.st = st;
31.   }
32.   public void run(){
33.     st.m1();
34.   }
35. }
37. class T2 extends Thread{
38.   SleepTest st;
39.   public T2(SleepTest st){
40.     this.st = st;
41.   }
42.   public void run(){
43.     st.m2();
44.   }
45. }
48. public class Test {
49.     public static void main(String[] args) throws Exception{
50.       SleepTest st = new SleepTest();
51.       new T1(st).start();
52.       new T2(st).start();
53.     }
54. }

　　我们看到两个分别调用m1和m2的线程由于它们获取不同对象的监视锁，它们没有任何竞争就正常运行，只有这两个线程同时调用m1或m2才会产生阻塞。