Java多线程编程基础之线程对象

核心提示：在进入java平台的线程对象之前，基于基础篇(一)的一些问题，Java多线程编程基础之线程对象，我先插入两个基本概念，[线程的并发与并行]在单CPU系统中，class R implements Runnable{private int x = 0;public void run(){for(int i=0;i<1

　　在进入java平台的线程对象之前，基于基础篇(一)的一些问题，我先插入两个基本概念。

　　[线程的并发与并行]

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

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

　　[JAVA线程对象]

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

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

　　将Runable实例传给一个Thread实例然后调用它的start()方法。

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

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

class MyThread extends Thread{
　public int x = 0;
　public void run(){
　　for(int i=0;i<100;i++){
　 　　try{
　　 　　Thread.sleep(10);
　 　　}catch(Exception e){}
　 　　System.out.PRintln(x++);
　　}
　}
}
　　假如我们生成MyThread的一个实例，然后调用它的start()方法，那么就产生了这个实例对应的线程:

public class Test {
　public static void main(String[] args) throws Exception{
　　MyThread mt = new MyThread();
　　mt.start();
　}
}
　　不用说，最终会打印出0到99，现在我们稍微玩一点花样:

public class Test {
　public static void main(String[] args) throws Exception{
　　MyThread mt = new MyThread();
　　mt.start();
　　System.out.println(101);
　}
}
　　也不用说，在基础篇(一)中我们知道由于单CPU的原因，一般会先打印101，然后打印0到99。不过我们可以控制线程让它按我们的意思来运行:

public class Test {
　public static void main(String[] args) throws Exception{
　　MyThread mt = new MyThread();
　　mt.start();
　　mt.join();
　　System.out.println(101);
　}
}
　　好了，我们终于看到，mt实例对应的线程(假如我有时说mt线程请你不要怪我，不过我尽量不这么说)。在运行完成后，主线程才打印101。因为我们让当前线程(这里是主线程)等待mt线程的运行结束。"在线程对象a上调用join()方法，就是让当前正在执行的线程等待线程对象a对应的线程运行完成后才继续运行。" 请大家一定要深刻理解并熟记这句话，而我这里引出这个知识点的目的是为了让你继续看下面的例子:

public class Test {
　public static void main(String[] args) throws Exception{
　　MyThread mt = new MyThread();
　　mt.start();
　　mt.join();
　　Thread.sleep(3000);
　　mt.start();
　}
}
　　当线程对象mt运行完成后，我们让主线程休息一下，然后我们再次在这个线程对象上启动线程。结果我们看到:

　　Exception in thread "main" java.lang.IllegalThreadStateException

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

public synchronized void start() {
　if (started)
　　throw new IllegalThreadStateException();
　　started = true;
　　group.add(this);
　　start0();
　}
　　一个Thread的实例一旦调用start()方法，这个实例的started标记就标记为true，事实中不管这个线程后来有没有执行到底，只要调用了一次start()就再也没有机会运行了，这意味着:

　　[通过Thread实例的start()，一个Thread的实例只能产生一个线程]

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

class R implements Runnable{
　private int x = 0;
　public void run(){
　　for(int i=0;i<100;i++){
　 　　try{
　　 　　Thread.sleep(10);
　 　　}catch(Exception e){}
　 　　System.out.println(x++);
　　}
　}
}
　　正如它的名字一样，Runnable的实例是可运行的，但它自己并不能直接运行，它需要被Thread对象来包装才行运行: