一 線程的基本概念

線程是一個程序內部的順序控制流.一個進程相當于一個任務,一個線程相當于一個任務中的一條執行路徑.；多進程:在操作系統中能同時運行多個任務(程序)；多線程:在同一個應用程序中有多個順序流同時執行；Java的線程是通過java.lang.Thread類來實現的；JVM啟動時會有一個由主方法(public static void main(){})所定義的線程；可以通過創建Thread的實例來創建新的線程；每個線程都是通過某個特定Thread對象所對應的方法run()來完成其操作的,方法run()稱為線程體，通過調用Thread類的start()方法來啟動一個線程。

二 線程的創建和啟動

可以有兩種方式創建新的線程:
***種:
     1.定義線程類實現Runnable接口
     2.Thread myThread = new Thread(target);   //target為Runnable接口類型
     3.Runnable中只有一個方法:public void run();用以定義線程運行體
     4.使用Runnable接口可以為多個線程提供共享的數據
     5.在實現Runnable接口的類的run()方法定義中可以使用Thread的靜態方法public static Thread currentThread();獲取當前線程的引用
   
第二種:
      1.可以定義一個Thread的子類并重寫其run方法如:
          class MyThread extends Thread {   
              public void run() {...}
            
          }   
     2.然后生成該類的對象:
         MyThread myThread = new MyThread();

三 線程控制的基本方法

isAlive():判斷線程是否還"活"著
getPriority():獲得線程的優先級數值
setPriority():設置線程的優先級數值
Thread.sleep():將當前線程睡眠指定毫秒數
join():調用某線程的該方法,將當前線程與該線程"合并",即等待該線程結束,再恢復當前線程的運行
yield():讓出cpu,當前線程進入就緒隊列等待調度
wait():當前線程進入對象的wait pool
notify()/notifyAll():喚醒對象的wait pool中的一個/所有等待線程

四 線程同步

實現生產者消費者問題來說明線程問題,舉例如下所示:

1. /**  
2. * 生產者消費者問題  
3. */ 
4. package com.basic.thread;  
6. /**  
7. * @author johnston678  
8. *  
9. * @version 2009-05-06  
10. */ 
11. public class ProducerConsumer {  
13.      /**  
14.       * @param args  
15.       */ 
16.      public static void main(String[] args) {          
17.          ProductBox pb = new ProductBox();  
18.          Producer p = new Producer(pb);  
19.          Consumer c = new Consumer(pb);  
20.           
21.          Thread pThread = new Thread(p);  
22.          Thread cThread = new Thread(c);  
23.          pThread.setPriority(Thread.MAX_PRIORITY);  
24.           
25.          pThread.start();  
26.          cThread.start();  
27.      }  
29. }  
31. /**  
32. * 產品對象  
33. * @author johsnton678  
34. */ 
35. class Product {  
36.      int id;  
38.      public Product(int id) {  
39.          super();  
40.          this.id = id;  
41.      }  
42.       
43.      public String toString(){  
44.          return "Product:" + id;  
45.      }  
46. }  
48. /**  
49. * 產品盒對象  
50. * @author johnston678  
51. */ 
52. class ProductBox {  
54.      Product[] productbox = new Product[6];  
55.      int index = 0;  
56.      public ProductBox() {  
57.          super();          
58.      }  
59.       
60.      public synchronized void push(Product p) {  
61.          while (index == productbox.length) {  
62.              try {  
63.                  this.wait();  
64.              } catch (InterruptedException e) {  
65.                  // TODO Auto-generated catch block  
66.                  e.printStackTrace();  
67.              }  
68.          }  
69.          this.notify();          
70.          productbox[index] = p;  
71.          index ++;  
72.      }  
73.       
74.      public synchronized Product pop() {  
75.          while (index == 0) {  
76.              try {  
77.                  this.wait();  
78.              } catch (InterruptedException e) {  
79.                  // TODO Auto-generated catch block  
80.                  e.printStackTrace();  
81.              }  
82.          }  
83.          this.notify();  
84.          index --;  
85.          return productbox[index];  
86.           
87.      }  
88. }  
90. /**  
91. * 生產者  
92. * @author johnston678  
93. */ 
94. class Producer implements Runnable {  
96.      ProductBox productbox = null;  
97.       
98.      public Producer(ProductBox productbox) {  
99.          super();  
100.          this.productbox = productbox;  
101.      }  
103.      @Override 
104.      public void run() {  
105.          // TODO Auto-generated method stub  
106.          for (int i=0; i<10; i++) {  
107.              Product p = new Product(i);  
108.              productbox.push(p);  
109.              System.out.println("produce:" + p);  
110.               
111.              try {  
112.                  Thread.sleep((int)(Math.random() * 200));  
113.              } catch (InterruptedException e) {  
114.                  e.printStackTrace();  
115.              }  
116.          }  
117.      }  
118.       
119. }  
121. /**  
122. * 消費者  
123. * @author johnston678  
124. */ 
125. class Consumer implements Runnable {  
127.      ProductBox productbox = null;  
128.       
129.      public Consumer(ProductBox productbox) {  
130.          super();  
131.          this.productbox = productbox;  
132.      }  
134.      @Override 
135.      public void run() {  
136.          // TODO Auto-generated method stub  
137.          for (int i=0; i<10; i++) {  
138.              Product p = productbox.pop();  
139.              System.out.println("consume:" + p);  
140.               
141.              try {  
142.                  Thread.sleep((int)(Math.random() * 1000));  
143.              } catch (InterruptedException e) {  
144.                  e.printStackTrace();  
145.              }  
146.          }  
147.      }  
148.       
149. }