学到多线程了，可对于多线程的应用理解很模糊，总感觉用不到，换种说法就是多线程在实际开发中怎么用？如果可以的话，还请各位大神举个具体的例子，百分感谢呐！

理解多线程，我感觉最经典的例子就是生产者与消费者的问题  所以 给你把代码贴出来 你看看吧

1. public class Threadtest {
   
2.         public static void main(String[] args) {
   
3.                 Factory fac = new Factory();
   
4.                 Producer p = new Producer(fac);
   
5.                 Consumer c = new Consumer(fac);
   
6.                 Thread tp = new Thread(p);
   
7.                 Thread tc = new Thread(c);
   
8.                 tp.start();
   
9.                 tc.start();
   
10.         }
    
11. }
    
12. 
    
13. class Goods {
    
14.         private int id;
    
15.         public int length;
    
16. 
    
17.         Goods(int id) {
    
18.                 this.id = id;
    
19.         }
    
20. 
    
21.         public String toString() {
    
22.                 return "Goods :" + id;
    
23.         }
    
24. }
    
25. 
    
26. class Factory {
    
27.         Goods goods[] = new Goods[10];
    
28.         int index = 0;
    
29. 
    
30.         public synchronized void push(Goods gs) {
    
31.                 try {
    
32.                         while (index == goods.length) {
    
33.                                 System.out.println("仓库满了,停止生产。。。。");
    
34.                                 this.wait();
    
35.                         }
    
36.                         this.notify();
    
37.                 } catch (InterruptedException e) {
    
38.                         e.printStackTrace();
    
39.                 } catch (IllegalMonitorStateException e) {
    
40.                         e.printStackTrace();
    
41.                 }
    
42. 
    
43.                 goods[index] = gs;
    
44.                 index++;
    
45.                 System.out.println("生产了：" + gs + " 共有" + index + "个产品");
    
46.         }
    
47. 
    
48.         public synchronized Goods pop() {
    
49.                 try {
    
50.                         while (index == 0) {
    
51.                                 System.out.println("仓库东西已经消费光了。。。。");
    
52.                                 this.wait();
    
53.                         }
    
54.                         this.notify();
    
55.                 } catch (InterruptedException e) {
    
56.                         e.printStackTrace();
    
57.                 } catch (IllegalMonitorStateException e) {
    
58.                         e.printStackTrace();
    
59.                 }
    
60.                 index--;
    
61.                 System.out.println("消费了：---------" + goods[index] + " 共有" + index
    
62.                                 + "个产品");
    
63.                 return goods[index];
    
64.         }
    
65. }
    
66. 
    
67. class Producer implements Runnable {
    
68.        
    
69.         Factory fac = new Factory();
    
70.         Producer(Factory fac) {
    
71.                 this.fac = fac;
    
72.         }
    
73. 
    
74.         public void run() {
    
75.                 for (int i = 0; i < 10; i++) {
    
76.                         Goods gs = new Goods(i);
    
77.                         fac.push(gs);
    
78.                         try {
    
79.                                 Thread.sleep((int) (Math.random() * 500));
    
80.                         } catch (InterruptedException e) {
    
81.                                 e.printStackTrace();
    
82.                         }
    
83.                 }
    
84.         }
    
85. }
    
86. 
    
87. class Consumer implements Runnable {
    
88.        
    
89.         Factory fac = new Factory();
    
90.         Consumer(Factory fac) {
    
91.                 this.fac = fac;
    
92.         }
    
93. 
    
94.         public void run() {
    
95.                 for (int i = 0; i < 10; i++) {
    
96.                         fac.pop();
    
97.                         try {
    
98.                                 Thread.sleep((int) (Math.random() * 1000));
    
99.                         } catch (InterruptedException e) {
    
100.                                 e.printStackTrace();
     
101.                         }
     
102.                 }
     
103.         }
     
104. }

复制代码

拿360来说，你可以一边杀毒一边清理垃圾一边清理插件，如果只有一个线程，那么你只能一个做完再做另一个，如果是多线程，那么就可以同时做了。多线程什么时候用，就看你开发的程序是一个步骤一个步骤按顺序操作，还是几个步骤可以一起操作

李润根 发表于 2013-5-30 14:33
拿360来说，你可以一边杀毒一边清理垃圾一边清理插件，如果只有一个线程，那么你只能一个做完再做另一个， ...

额  一句话惊醒梦中人呐  我发现自己有些钻牛角尖了。。。  多谢啦

王永贺 发表于 2013-5-30 12:40
理解多线程，我感觉最经典的例子就是生产者与消费者的问题  所以 给你把代码贴出来 你看看吧 ...

多谢哈   这确实是个经典的例子    要好好研究一下   谢谢啦