java 线程（一）

创建Java线程

在Java程序中创建线程有几种方法。每个Java程序至少包含一个线程：主线程。

可以有两种方式创建新的线程:
第一种:
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();

当我们讨论Java程序中的线程时，也许会提到两个相关实体：完成工作的实际线程或代表线程的Thread对象。正在运行的线程通常是由操作系统创建的；Thread对象是由JavaVM创建的，作为控制相关线程的一种方式。

创建线程和启动线程并不相同

在一个线程对新线程的Thread对象调用start()方法之前，这个新线程并没有真正开始执行。Thread对象在其线程真正启动之前就已经存在了，而且其线程退出之后仍然存在。这可以让您控制或获取关于已创建的线程的信息，即使线程还没有启动或已经完成了。

通常在构造器中通过start()启动线程并不是好主意。这样做，会把部分构造的对象暴露给新的线程。如果对象拥有一个线程，那么它应该提供一个启动该线程的start()或init()方法，而不是从构造器中启动它。

结束Java线程

Java线程会以以下三种方式之一结束：

Java线程到达其run()方法的末尾。

Java线程抛出一个未捕获到的Exception或Error。

另一个Java线程调用一个弃用的stop()方法。弃用是指这些方法仍然存在，但是您不应该在新代码中使用它们，并且应该尽量从现有代码中除去它们。

当Java程序中的所有线程都完成时，程序就退出了。

加入Java线程

ThreadAPI包含了等待另一个线程完成的方法：join()方法。当调用Thread.join()时，调用线程将阻塞，直到目标线程完成为止。

Thread.join()通常由使用线程的程序使用，以将大问题划分成许多小问题，每个小问题分配一个线程。本章结尾处的示例创建了十个线程，启动它们，然后使用Thread.join()等待它们全部完成。

Java线程调度

除了何时使用Thread.join()和Object.wait()外，线程调度和执行的计时是不确定的。如果两个线程同时运行，而且都不等待，您必须假设在任何两个指令之间，其它线程都可以运行并修改程序变量。如果线程要访问其它线程可以看见的变量，如从静态字段（全局变量）直接或间接引用的数据，则必须使用同步以确保数据一致性。

休眠

ThreadAPI包含了一个sleep()方法，它将使当前线程进入等待状态，直到过了一段指定时间，或者直到另一个线程对当前线程的Thread对象调用了Thread.interrupt()，从而中断了线程。当过了指定时间后，线程又将变成可运行的，并且回到调度程序的可运行线程队列中。

如果线程是由对Thread.interrupt()的调用而中断的，那么休眠的线程会抛出InterruptedException，这样线程就知道它是由中断唤醒的，就不必查看计时器是否过期。

Thread.yield()方法就象Thread.sleep()一样，但它并不引起休眠，而只是暂停当前线程片刻，这样其它线程就可以运行了。在大多数实现中，当较高优先级的线程调用Thread.yield()时，较低优先级的线程就不会运行。

守护程序线程

我们提到过当Java程序的所有线程都完成时，该程序就退出，但这并不完全正确。隐藏的系统线程，如垃圾收集线程和由JVM创建的其它线程会怎么样？我们没有办法停止这些线程。如果那些线程正在运行，那么Java程序怎么退出呢？

这些系统线程称作守护程序线程。Java程序实际上是在它的所有非守护程序线程完成后退出的。

任何线程都可以变成守护程序线程。可以通过调用Thread.setDaemon()方法来指明某个线程是守护程序线程。您也许想要使用守护程序线程作为在程序中创建的后台线程，如计时器线程或其它延迟的事件线程，只有当其它非守护程序线程正在运行时，这些线程才有用。

实现生产者消费者问题来说明线程问题,举例如下所示:

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