java多线程编程 - 基础篇 （二）

转自:http://www.java2000.net/p8563

程的并发与并行]

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

　　在单CPU系统中，系统调度在某一时刻只能让一个线程运行，虽然这种调试机制有多种形式(大多数是时间片轮巡为主)，但无论如何，要通过不断切换需要运行的线程让其运行的方式就叫并发(concurrent)。而在多CPU系统中，可以让两个以上的线程同时运行，这种可以同时让两个以上线程同时运行的方式叫做并行(parallel)。

　　在上面包括以后的所有论述中，请各位朋友谅解，我无法用最准确的词语来定义储如并发和并行这类术语，但我以我的经验能通俗地告诉大家它是怎么一回事，如果您看到我说的一些"标准"文档上说的不一样，只要意思一致，那您就不要挑刺了。
[JAVA线程对象]

　　现在我们来开始考察JAVA中线程对象。

　　在JAVA中，要开始一个线程，有两种方式。一是直接调用Thread实例的start()方法，二是
将Runable实例传给一个Thread实例然后调用它的start()方法。

　　在前面已经说过，线程对象和线程是两个完全不同的概念。这里我们再次深入一下，生成一个线程的实例，并不代表启动了线程。而启动线程是说在某个线程对象上启动了该实例对应的线程，当该线程结束后，并不会就立即消失。

　　对于从很多书籍上可以看到的基础知识我就不用多说了。既然是基础知识，我也着重于从普通文档上读不到的内容。所以本节我重点要说的是两种线程对象产生线程方式的区别。

1. class MyThread extends Thread{
2.   public int x = 0;
3.   
4.   public void run(){
5.     
6.     for(int i=0;i<100;i++){
7.       try{
8.         Thread.sleep(10);
9.       }catch(Exception e){}
10.       System.out.println(x++);
11.       
12.     }
13.   }
14. }

如果我们生成MyThread的一个实例，然后调用它的start()方法，那么就产生了这个实例对应的线程：

 

1. public class Test {
2.   public static void main(String[] args) throws Exception{
3.     MyThread mt = new MyThread();
4.     mt.start();
5.   }
6. }

　不用说，最终会打印出0到99，现在我们稍微玩一点花样：

 

1. public class Test {
2.   public static void main(String[] args) throws Exception{
3.     MyThread mt = new MyThread();
4.     mt.start();
5.     System.out.println(101);
6.   }
7. }

也不用说，在基础篇（一）中我们知道由于单CPU的原因，一般会先打印101，然后打印0到99。不过我们可以控制线程让它按我们的意思来运行：

 

1. public class Test {
2.   public static void main(String[] args) throws Exception{
3.     MyThread mt = new MyThread();
4.     mt.start();
5.     mt.join();
6.     System.out.println(101);
7.   }
8. }

好了，我们终于看到，mt实例对应的线程(假如我有时说mt线程请你不要怪我，不过我尽量不这么说)。在运行完成后，主线程才打印101。因为我们让当前线程(这里是主线程)等待mt线程的运行结束。"在线程对象a上调用join()方法，就是让当前正在执行的线程等待线程对象a对应的线程运行完成后才继续运行。" 请大家一定要深刻理解并熟记这句话，而我这里引出这个知识点的目的是为了让你继续看下面的例子：

 

1. public class Test {
2.   public static void main(String[] args) throws Exception{
3.     MyThread mt = new MyThread();
4.     mt.start();
5.     mt.join();
6.     Thread.sleep(3000);
7.     mt.start();
8.   }
9. }

 

当线程对象mt运行完成后，我们让主线程休息一下，然后我们再次在这个线程对象上启动线程。结果我们看到：

　　Exception in thread "main" java.lang.IllegalThreadStateException

　　也就是这种线程对象一时运行一次完成后，它就再也不能运行第二次了。我们可以看一下它有具体实现:

1.     public synchronized void start() {
2.         if (started)
3.             throw new IllegalThreadStateException();
4.         started = true;
5.         group.add(this);
6.         start0();
7.     }

一个Thread的实例一旦调用start()方法，这个实例的started标记就标记为true，事实中不管这个线程后来有没有执行到底，只要调用了一次start()就再也没有机会运行了，这意味着：
[通过Thread实例的start()，一个Thread的实例只能产生一个线程]

　　那么如果要在一个实例上产生多个线程(也就是我们常说的线程池)，我们应该如何做呢？这就是Runnable接口给我们带来的伟大的功能。

 

1. class R implements Runnable{
2.   private int x = 0;
3.   public void run(){
5.     for(int i=0;i<100;i++){
6.       try{
7.         Thread.sleep(10);
8.       }catch(Exception e){}
9.       System.out.println(x++);
11.     }
12.   }
13. }

正如它的名字一样，Runnable的实例是可运行的，但它自己并不能直接运行，它需要被Thread对象来包装才行运行：

1. public class Test {
2.   public static void main(String[] args) throws Exception{
3.     new Thread(new R()).start();
4.   }
5. }

 

当然这个结果和mt.start()没有什么区别。但如果我们把一个Runnable实例给Thread对象多次包装，我们就可以看到它们实际是在同一实例上启动线程：

1. public class Test {
2.   public static void main(String[] args) throws Exception{
3.     R r = new R();
4.     for(int i=0;i<10;i++)
5.       new Thread(r).start();
6.   }
7. }

 

x是实例对象，但结果是x被加到了999，说明这10个线程是在同一个r对象上运行的。请大家注意，因为这个例子是在单CPU上运行的，所以没有对多个线程同时操作共同的对象进行同步。这里是为了说明的方便而简化了同步，而真正的环境中你无法预知程序会在什么环境下运行，所以一定要考虑同步。

　　到这里我们做一个完整的例子来说明线程产生的方式不同而生成的线程的区别：

1. package debug;
3. import java.io.*;
4. import java.lang.Thread;
7. class MyThread extends Thread{
8.   public int x = 0;
10.   public void run(){
11.     System.out.println(++x);
12.   }
13. }
15. class R implements Runnable{
16.   private int x = 0;
17.   public void run(){
18.     System.out.println(++x);
19.   }
20. }
22. public class Test {
23.   public static void main(String[] args) throws Exception{
24.     
25.     for(int i=0;i<10;i++){
26.       Thread t = new MyThread();
27.       t.start();
28.     }
29.     Thread.sleep(10000);//让上面的线程运行完成
30.     R r = new R();
31.     for(int i=0;i<10;i++){
32.       Thread t = new Thread(r);
33.       t.start();
34.     }
35.   }
36. }

 

上面10个线程对象产生的10个线程运行时打印了10次1。下面10个线程对象产生的10个线程运行时打印了1到10。我们把下面的10个线程称为同一实例(Runnable实例)的多个线程。

　　下节我们将研究线程对象方法，还是那句话，一般文档中可以读到的内容我不会介绍太多
请大家自己了解。