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

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

来源于：转载自dev2dev网友axman的go deep into java专栏。

　在进入实战篇以前,我们简单说一下多线程编程的一般原则。

　　[安全性]是多线程编程的首要原则
如果两个以上的线程访问同一对象时，一个线程会损坏另一个线程的数据，这就是违反了安全性原则，这样的程序是不能进入实际应用的。

　　安全性的保证可以通过设计安全的类和程序员的手工控制。如果多个线程对同一对象访问不会危及安全性，这样的类就是线程安全的类，在JAVA中比如String类就被设计为线程安全的类。而如果不是线程安全的类，那么就需要程序员在访问这些类的实例时手工控制它的安全性。

　　[可行性]是多线程编程的另一个重要原则
如果仅仅实现了安全性，程序却在某一点后不能继续执行或者多个线程发生死锁，那么这样的程序也不能作为真正的多线程程序来应用。

　　相对而言安全性和可行性是相互抵触的，安全性越高的程序，可性行会越低。要综合平衡。

　　[高性能] 多线程的目的本来就是为了增加程序运行的性能，
如果一个多线程完成的工作还不如单线程完成得快。那就不要应用多线程了。

　　高性能程序主要有以下几个方面的因素：

　　数据吞吐率，在一定的时间内所能完成的处理能力。

　　响应速度，从发出请求到收到响应的时间。

　　容量，指同时处理相同任务的数量。

　　安全性和可行性是必要条件，如果达到不这两个原则那就不能称为真正的多线程程序。而高性是多线程编程的目的，也可以说是充要条件。否则，为什么采用多线程编程呢？

[生产者与消费者模式]

　　首先以一个生产者和消费者模式来进入实战篇的第一节。

　　生产者和消费者模式中保护的是谁？

　　多线程编程都在保护着某些对象，这些个对象是"紧俏资源"，要被最大限度地利用，这也是采用多线程方式的理由。在生产者消费者模式中，我们要保护的是"仓库"，在我下面的这个例子中，

就是桌子(table)。

　　我这个例子的模式完全是生产者-消费者模式，但我换了个名字。厨师-食客模式，这个食堂中只有1张桌子，同时最多放10个盘子，现在有4个厨师做菜，每做好一盘就往桌子上放(生产者将产品往仓库中放)，而有6个食客不停地吃(消费者消费产品，为了说明问题，他们的食量是无限的)。

　　一般而言，厨师200-400ms做出一盘菜，而食客要400-600ms吃完一盘。当桌子上放满了10个盘子后，所有厨师都不能再往桌子上放，而当桌子是没有盘子时，所有的食客都只好等待。

　　下面我们来设计这个程序：

　　因为我们不知道具体是什么菜，所以叫它food：

1. class Food{}

　　然后是桌子，因为它要有序地放而且要有序地取(不能两个食客同时争取第三盘菜)，所以我们扩展LinkedList，或者你用聚合把一个LinkedList作为属性也能达到同样的目的，例子中我是用

继承，从构造方法中传入一个可以放置的最大值。

1. class Table extends java.util.LinkedList{
2.   int maxSize;
3.   public Table(int maxSize){
4.     this.maxSize = maxSize;
5.   }
6. }

现在我们要为它加两个方法，一是厨师往上面放菜的方法，一是食客从桌子上拿菜的方法。

放菜：因为一张桌子由多个厨师放菜，所以厨师放菜的要被同步，如果桌子上已经有十盘菜了。所有厨师就要等待：

1.   public synchronized void putFood(Food f) {
2.     while (this.size() >= this.maxSize) {
3.       try {
4.         this.wait();
5.       } catch (Exception e) {
6.       }
7.     }
8.     this.add(f);
9.     notifyAll();
10.   }

拿菜：同上面，如果桌子上一盘菜也没有，所有食客都要等待：

1.   public synchronized Food getFood() {
2.     while (this.size() <= 0) {
3.       try {
4.         this.wait();
5.       } catch (Exception e) {
6.       }
7.     }
8.     Food f = (Food) this.removeFirst();
9.     notifyAll();
10.     return f;
11.   }

厨师类：

　　由于多个厨师要往一张桌子上放菜，所以他们要操作的桌子应该是同一个对象，我们从构造方法中将桌子对象传进去以便控制在主线程中只产生一张桌子。

厨师做菜要用一定的时候，我用在make方法中用sleep表示他要消耗和时候，用200加上200的随机数保证时间有200-400ms中。做好后就要往桌子上放。

这里有一个非常重要的问题一定要注意，就是对什么范围同步的问题，因为产生竞争的是桌子，所以所有putFood是同步的，而我们不能把厨师自己做菜的时间也放在同步中，因为做菜是各自做的。同样食客吃菜的时候也不应该同步，只有从桌子中取菜的时候是竞争的，而具体吃的时候是各自在吃。所以厨师类的代码如下：

1. class Chef extends Thread {
2.   Table t;
3.   Random r = new Random(12345);
4.   public Chef(Table t) {
5.     this.t = t;
6.   }
7.   public void run() {
8.     while (true) {
9.       Food f = make();
10.       t.putFood(f);
11.     }
12.   }
13.   private Food make() {
14.     try {
15.       Thread.sleep(200 + r.nextInt(200));
16.     } catch (Exception e) {
17.     }
18.     return new Food();
19.   }
20. }

同理我们产生食客类的代码如下：

1. class Eater extends Thread {
2.   Table t;
3.   Random r = new Random(54321);
4.   public Eater(Table t) {
5.     this.t = t;
6.   }
7.   public void run() {
8.     while (true) {
9.       Food f = t.getFood();
10.       eat(f);
11.     }
12.   }
13.   private void eat(Food f) {
14.     try {
15.       Thread.sleep(400 + r.nextInt(200));
16.     } catch (Exception e) {
17.     }
18.   }
19. }

完整的程序在这儿：

1. package debug;
2. import java.util.regex.*;
3. import java.util.*;
5. class Food {
6. }
8. class Table extends LinkedList {
9.   int maxSize;
10.   public Table(int maxSize) {
11.     this.maxSize = maxSize;
12.   }
13.   public synchronized void putFood(Food f) {
14.     while (this.size() >= this.maxSize) {
15.       try {
16.         this.wait();
17.       } catch (Exception e) {
18.       }
19.     }
20.     this.add(f);
21.     notifyAll();
22.   }
23.   public synchronized Food getFood() {
24.     while (this.size() <= 0) {
25.       try {
26.         this.wait();
27.       } catch (Exception e) {
28.       }
29.     }
30.     Food f = (Food) this.removeFirst();
31.     notifyAll();
32.     return f;
33.   }
34. }
36. class Chef extends Thread {
37.   Table t;
38.   String name;
39.   Random r = new Random(12345);
40.   public Chef(String name, Table t) {
41.     this.t = t;
42.     this.name = name;
43.   }
44.   public void run() {
45.     while (true) {
46.       Food f = make();
47.       System.out.println(name + " put a Food:" + f);
48.       t.putFood(f);
49.     }
50.   }
51.   private Food make() {
52.     try {
53.       Thread.sleep(200 + r.nextInt(200));
54.     } catch (Exception e) {
55.     }
56.     return new Food();
57.   }
58. }
60. class Eater extends Thread {
61.   Table t;
62.   String name;
63.   Random r = new Random(54321);
64.   public Eater(String name, Table t) {
65.     this.t = t;
66.     this.name = name;
67.   }
68.   public void run() {
69.     while (true) {
70.       Food f = t.getFood();
71.       System.out.println(name + " get a Food:" + f);
72.       eat(f);
73.     }
74.   }
75.   private void eat(Food f) {
76.     try {
77.       Thread.sleep(400 + r.nextInt(200));
78.     } catch (Exception e) {
79.     }
80.   }
81. }
83. public class Test {
84.   public static void main(String[] args) throws Exception {
85.     Table t = new Table(10);
86.     new Chef("Chef1", t).start();
87.     new Chef("Chef2", t).start();
88.     new Chef("Chef3", t).start();
89.     new Chef("Chef4", t).start();
90.     new Eater("Eater1", t).start();
91.     new Eater("Eater2", t).start();
92.     new Eater("Eater3", t).start();
93.     new Eater("Eater4", t).start();
94.     new Eater("Eater5", t).start();
95.     new Eater("Eater6", t).start();
96.   }
97. }

这一个例子中，我们主要关注以下几个方面：

　　1.同步方法要保护的对象，本例中是保护桌子，不能同时往上放菜或同时取菜。

　　假如我们把putFood方法和getFood方法在厨师类和食客类中实现，那么我们应该如此：

(以putFood为例)

1. class Chef extends Thread {
2.   Table t;
3.   String name;
4.   public Chef(String name, Table t) {
5.     this.t = t;
6.     this.name = name;
7.   }
8.   public void run() {
9.     while (true) {
10.       Food f = make();
11.       System.out.println(name + " put a Food:" + f);
12.       putFood(f);
13.     }
14.   }
15.   private Food make() {
16.     Random r = new Random(200);
17.     try {
18.       Thread.sleep(200 + r.nextInt());
19.     } catch (Exception e) {
20.     }
21.     return new Food();
22.   }
23.   public void putFood(Food f) {// 方法本身不能同步,因为它同步的是this.即Chef的实例
24.     synchronized (t) {// 要保护的是t
25.       while (t.size() >= t.maxSize) {
26.         try {
27.           t.wait();
28.         } catch (Exception e) {
29.         }
30.       }
31.       t.add(f);
32.       t.notifyAll();
33.     }
34.   }
35. }

　　2.同步的范围，在本例中是放和取两个方法，不能把做菜和吃菜这种各自不相干的工作放在受保护的范围中。

　　3.参与者与容积比

　　 对于生产者和消费者的比例，以及桌子所能放置最多菜的数量三者之间的关系是影响性能的重要因素，如果是过多的生产者在等待，则要增加消费者或减少生产者的数据，反之则增加生产者或减少消费者的数量。

　　另外如果桌子有足够的容量可以很大程序提升性能，这种情况下可以同时提高生产者和消费者的数量，但足够大的容时往往你要有足够大的物理内存。