java中的多线程

在多任务系统中，每个独立执行的程序称为进程，也就是“正在进行的程序”。我们现在使用的操作系统一般都是多任务的，即能够同时执行多个应用程序，实际情况是，操作系统负责CPU等设备的资源进行分配和管理，虽然这些设备某一时刻只能做一件事，但以非常小的时间间隔交替执行多个程序，就可以给人以同时执行多个程序的感觉。


一个进程中又可以包含一个或多个线程，一个线程就是一个程序内部的一条执行线索，如果要一程序中实现多段代码同时交替运行，就需产生多个线程，并指定每个线程上所要运行的代码段，这就是多线程。






一、定义线程



1、扩展java.lang.Thread类。



此类中有个run()方法，应该注意其用法：

public void run()

如果该线程是使用独立的

Runnable

运行对象构造的，则调用该

Runnable

对象的

run

方法；否则，该方法不执行任何操作并返回。

Thread

的子类应该重写该方法。

2、实现java.lang.Runnable接口。



void run()

使用实现接口

Runnable

的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的

run

方法。


方法

run

的常规协定是，它可能执行任何所需的操作。



二、实例化线程



1、如果是扩展java.lang.Thread类的线程，则直接new即可。



2、如果是实现了java.lang.Runnable接口的类，则用Thread的构造方法：

Thread(Runnable target)

Thread(Runnable target, String name)

Thread(ThreadGroup group, Runnable target)

Thread(ThreadGroup group, Runnable target, String name)

Thread(ThreadGroup group, Runnable target, String name, long stackSize)



三、启动线程



在线程的Thread对象上调用start()方法，而不是run()或者别的方法。



在调用start()方法之前：线程处于新状态中，新状态指有一个Thread对象，但还没有一个真正的线程。



在调用start()方法之后：发生了一系列复杂的事情

启动新的执行线程（具有新的调用栈）；

该线程从新状态转移到可运行状态；

当该线程获得机会执行时，其目标run()方法将运行。



注意：对Java来说，run()方法没有任何特别之处。像main()方法一样，它只是新线程知道调用的方法名称(和签名)。因此，在Runnable上或者Thread上调用run方法是合法的。但并不启动新的线程。

在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。

对于直接继承Thread的类来说，代码大致框架是：

class 类名 extends Thread{ 
方法1; 
方法2； 
… 
public void run(){ 
// other code… 
} 
属性1； 
属性2； 
… 
  
}

例子：

/** 
 * @author Rollen-Holt 继承Thread类,直接调用run方法 
 * */
class hello extends Thread { 
  
    public hello() { 
  
    } 
  
    public hello(String name) { 
        this.name = name; 
    } 
  
    public void run() { 
        for (int i = 0; i < 5; i++) { 
            System.out.println(name + "运行     " + i); 
        } 
    } 
  
    public static void main(String[] args) { 
        hello h1=new hello("A"); 
        hello h2=new hello("B"); 
        h1.run(); 
        h2.run(); 
    } 
  
    private String name; 
}

【运行结果】：

A运行 0
A运行 1
A运行 2
A运行 3
A运行 4
B运行 0
B运行 1
B运行 2
B运行 3
B运行 4
我们会发现这些都是顺序执行的，说明我们的调用方法不对，应该调用的是start（）方法。

当我们把上面的主函数修改为如下所示的时候：

<span style="font-size:14px;">public static void main(String[] args) { 
        hello h1=new hello("A"); 
        hello h2=new hello("B"); 
        h1.start(); 
        h2.start(); 
    }</span>

然后运行程序，输出的可能的结果如下：

A运行 0
B运行 0
B运行 1
B运行 2
B运行 3
B运行 4
A运行 1
A运行 2
A运行 3
A运行 4
因为需要用到CPU的资源，所以每次的运行结果基本是都不一样的，呵呵。

注意：虽然我们在这里调用的是start（）方法，但是实际上调用的还是run（）方法的主体。

那么：为什么我们不能直接调用run（）方法呢？

我的理解是：线程的运行需要本地操作系统的支持。

如果你查看start的源代码的时候，会发现：

public synchronized void start() { 
        /** 
     * This method is not invoked for the main method thread or "system" 
     * group threads created/set up by the VM. Any new functionality added  
     * to this method in the future may have to also be added to the VM. 
     * 
     * A zero status value corresponds to state "NEW". 
         */
        if (threadStatus != 0 || this != me) 
            throw new IllegalThreadStateException(); 
        group.add(this); 
        start0(); 
        if (stopBeforeStart) { 
        stop0(throwableFromStop); 
    } 
} 
private native void start0();

注意我用红色加粗的那一条语句，说明此处调用的是start0（）。并且这个这个方法用了native关键字，次关键字表示调用本地操作系统的函数。因为多线程的实现需要本地操作系统的支持。

但是start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。

通过实现Runnable接口：

class 类名 implements Runnable{ 
方法1; 
方法2； 
… 
public void run(){ 
// other code… 
} 
属性1； 
属性2； 
… 
  
}

例子：

/** 
 * @author Rollen-Holt 实现Runnable接口 
 * */
class hello implements Runnable { 
  
    public hello() { 
  
    } 
  
    public hello(String name) { 
        this.name = name; 
    } 
  
    public void run() { 
        for (int i = 0; i < 5; i++) { 
            System.out.println(name + "运行     " + i); 
        } 
    } 
  
    public static void main(String[] args) { 
        hello h1=new hello("线程A"); 
        Thread demo= new Thread(h1); 
        hello h2=new hello("线程Ｂ"); 
        Thread demo1=new Thread(h2); 
        demo.start(); 
        demo1.start(); 
    } 
  
    private String name; 
}

【可能的运行结果】：
线程A运行 0
线程Ｂ运行 0
线程Ｂ运行 1
线程Ｂ运行 2
线程Ｂ运行 3
线程Ｂ运行 4
线程A运行 1
线程A运行 2
线程A运行 3
线程A运行 4

关于选择继承Thread还是实现Runnable接口？
其实Thread也是实现Runnable接口的：

class Thread implements Runnable { 
    //… 
public void run() { 
        if (target != null) { 
             target.run(); 
        } 
        } 
}

其实Thread中的run方法调用的是Runnable接口的run方法。不知道大家发现没有，Thread和Runnable都实现了run方法，这种操作模式其实就是代理模式。关于代理模式，我曾经写过一个小例子呵呵，大家有兴趣的话可以看一下：http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144847.html
Thread和Runnable的区别：
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

/** 
 * @author Rollen-Holt 继承Thread类，不能资源共享 
 * */
class hello extends Thread { 
    public void run() { 
        for (int i = 0; i < 7; i++) { 
            if (count > 0) { 
                System.out.println("count= " + count--); 
            } 
        } 
    } 
  
    public static void main(String[] args) { 
        hello h1 = new hello(); 
        hello h2 = new hello(); 
        hello h3 = new hello(); 
        h1.start(); 
        h2.start(); 
        h3.start(); 
    } 
  
    private int count = 5; 
}

【运行结果】：
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
大家可以想象，如果这个是一个买票系统的话，如果count表示的是车票的数量的话，说明并没有实现资源的共享。
我们换为Runnable接口：

/** 
 * @author Rollen-Holt 继承Thread类，不能资源共享 
 * */
class hello implements Runnable { 
    public void run() { 
        for (int i = 0; i < 7; i++) { 
            if (count > 0) { 
                System.out.println("count= " + count--); 
            } 
        } 
    } 
  
    public static void main(String[] args) { 
        hello he=new hello(); 
        new Thread(he).start(); 
    } 
  
    private int count = 5; 
}

【运行结果】：
count= 5
count= 4
count= 3
count= 2
count= 1

总结一下吧：
实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

/** 
 * @author Rollen-Holt  
 * 取得线程的名称 
 * */
class hello implements Runnable { 
    public void run() { 
        for (int i = 0; i < 3; i++) { 
            System.out.println(Thread.currentThread().getName()); 
        } 
    } 
  
    public static void main(String[] args) { 
        hello he = new hello(); 
        new Thread(he,"A").start(); 
        new Thread(he,"B").start(); 
        new Thread(he).start(); 
    } 
}

【运行结果】：
A
A
A
B
B
B
Thread-0
Thread-0
Thread-0
说明如果我们没有指定名字的话，系统自动提供名字。
提醒一下大家：main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。
判断线程是否启动

/** 
 * @author Rollen-Holt 判断线程是否启动 
 * */
class hello implements Runnable { 
    public void run() { 
        for (int i = 0; i < 3; i++) { 
            System.out.println(Thread.currentThread().getName()); 
        } 
    } 
  
    public static void main(String[] args) { 
        hello he = new hello(); 
        Thread demo = new Thread(he); 
        System.out.println("线程启动之前---》" + demo.isAlive()); 
        demo.start(); 
        System.out.println("线程启动之后---》" + demo.isAlive()); 
    } 
}

【运行结果】
线程启动之前---》false
线程启动之后---》true
Thread-0
Thread-0
Thread-0
主线程也有可能在子线程结束之前结束。并且子线程不受影响，不会因为主线程的结束而结束。