控制java多线程同步

1. **
2.  * 一段模拟龟兔赛跑的多线程代码。<br>
3.  * 兔子比乌龟快5倍，但休息的时间长10倍。
4.  * 
5.  * @author 赵学庆，Java世纪网(java2000.net)
6.  * 
7.  */
8. public class T {
10.   public static void main(String[] args) {
11.     TortoiseRace a = new TortoiseRace();
12.     Thread runner1 = new Thread(a);
13.     RabbitRace b = new RabbitRace();
14.     Thread runner2 = new Thread(b);
15.     runner1.start();
16.     runner2.start();
17.     while (ready < 2) {
18.       try {
19.         Thread.sleep(1);
20.       } catch (InterruptedException e) {
21.         e.printStackTrace();
22.       }
23.     }
24.     synchronized (lock) {
25.       lock.notifyAll();
26.     }
27.   }
29.   static Object lock = new Object();
30.   static int ready = 0;
31. }
33. class TortoiseRace implements Runnable {
34.   public void run() {
35.     synchronized (T.lock) {
36.       T.ready++;
37.       try {
38.         T.lock.wait();
39.       } catch (InterruptedException e1) {
40.         e1.printStackTrace();
41.       }
42.     }
43.     int TortoiseDistance = 0;
44.     for (int i = 0; TortoiseDistance <= 1000; i++) {
45.       TortoiseDistance++;
46.       System.out.println("乌龟跑了1米!");
47.       try {
48.         Thread.sleep(1);
49.       } catch (InterruptedException e) {
50.       }
51.     }
52.     System.out.println("乌龟已经跑完了比赛路程!");
54.   }
55. }
57. class RabbitRace implements Runnable {
58.   public void run() {
59.     T.ready++;
60.     synchronized (T.lock) {
61.       try {
62.         T.lock.wait();
63.       } catch (InterruptedException e1) {
64.         e1.printStackTrace();
65.       }
66.     }
67.     int RabbitDistance = 0;
68.     for (int j = 0; RabbitDistance <= 1000; j++) {
69.       RabbitDistance += 5;
70.       System.out.println("兔子跑了5米!");
71.       try {
72.         Thread.sleep(10);
73.       } catch (InterruptedException e) {
74.       }
75.     }
76.     System.out.println("兔子跑完了比赛路程!");
78.   }
79. }

以上程序是用多进程实现的龟兔赛跑程序:

吸取汁水:

   定义2static 变量来实现线程的同步

1.   static Object lock = new Object();
2.   static int ready = 0; 

    定义ready是为了在主进程执行完前,能保证所有的进程的run方法被调用.

    lock用作监视器,用来控制进程的同步.各进程的run方法被调用后在执行真正功能前被阻塞起来.

  当主进程执行lock.notifyAll(); 各阻塞进程就有了同等的执行机率以此来取得多线程的同步.