Java中线程的实现

在Java中要想实现多线程操作有两种方法：
（1） 继承Thread类
（2） 实现Runnable接口
一． 继承Thread类
Thread类是在java.lang包中定义的，一个类只要继承了Thread类，此类就称为多线程实现类。在Thread子类中，必须明确的覆写Thread类中的run方法，此方法为线程的主体。下面进行多线程的实现
【继承Thread类实现多线程】

class MyThread extends Thread {    private String name;    public MyThread(String name) {        this.name = name;    }    @Override    public void run() { // 覆写Thread类中的run()方法        for (int i = 0; i < 10; i++) {            System.out.println(name + "运行，i=" + i);        }    }};public class TreadDemo01 {    public static void main(String[] args) {        MyThread mt1 = new MyThread("线程A");        MyThread mt2 = new MyThread("线程B");        mt1.start();        mt2.start();    }}

运行的结果：

线程A运行，i=0线程B运行，i=0线程B运行，i=1线程B运行，i=2线程B运行，i=3线程B运行，i=4线程B运行，i=5线程B运行，i=6线程A运行，i=1线程B运行，i=7线程A运行，i=2线程B运行，i=8线程A运行，i=3线程A运行，i=4线程B运行，i=9线程A运行，i=5线程A运行，i=6线程A运行，i=7线程A运行，i=8线程A运行，i=9

编译运行的结果可以看出两个线程对象是交错运行的，哪个线程对象抢到CPU资源，哪个线程就可以运行，所以程序每次运行的结果是不同的，在线程启动时调用的start()方法，但是实际上调用的是run()方法定义的主题。
注意：一个线程对象不能重复调用start()方法，否则会异常。

如果一个类只能靠继承Thread类才能实现多线程，则必定会受到单继承局限的影响，所以，一般要想实现多线程，还可以通过实现Runnable接口来完成。
二． 实现Runnable接口
在Java中也可以通过实现Runnable接口的方式来实现多线程，Runnable接口中定义了一个抽象方法：
public void run()
使用Runnable接口实现多线程：

class MyThread2 implements Runnable {    private String name;    public MyThread2(String name) {        this.name = name;    }    @Override    public void run() {        for (int i = 0; i < 10; i++) {            System.out.println(name + "运行，i=" + i);        }    }}

以上代码时通过Runnable接口来实现多线程的，但是从前面的代码中可以知道，一个线程必须通过Thread类中的start()方法开启。如果继承了Thread类，则可以直接调用此方法，但是在实现Runnable接口时，此接口中并没有start()方法，那么该如何启动多线程？实际上，此时还是依靠Thread类完成的。
【使用Thread类来启动线程】

class MyThread2 implements Runnable {    private String name;    public MyThread2(String name) {        this.name = name;    }    @Override    public void run() {        for (int i = 0; i < 10; i++) {            System.out.println(name + "运行，i=" + i);        }    }}public class RunnableDemo01 {    public static void main(String[] args) {        MyThread2 mt1 = new MyThread2("线程A");        MyThread2 mt2 = new MyThread2("线程B");        Thread th1 = new Thread(mt1);        Thread th2 = new Thread(mt2);        th1.start();        th2.start();    }}

运行结果为：

线程A运行，i=0线程B运行，i=0线程B运行，i=1线程B运行，i=2线程B运行，i=3线程B运行，i=4线程B运行，i=5线程B运行，i=6线程B运行，i=7线程B运行，i=8线程B运行，i=9线程A运行，i=1线程A运行，i=2线程A运行，i=3线程A运行，i=4线程A运行，i=5线程A运行，i=6线程A运行，i=7线程A运行，i=8线程A运行，i=9

以上两种方法可以发现，无论使用哪种方式，最终都必须依靠Thread类才能启动多线程。
三． Thread类和Runnable接口
通过Thread类和Runnable接口都可以实现多线程，那么两者有哪些联系和区别呐？下面观察Thread类的定义
public class Thread extends Object implements Runnable
从Thread类的定义可以发现，Thread类也是Runnable接口的子类，但在Thread类中并没有完全地实现Runnable接口中的run()方法。
Thread类的定义：

*/publicclass Thread implements Runnable {    /* Make sure registerNatives is the first thing <clinit> does. */    private static native void registerNatives();    static {        registerNatives();    }    public void run(){    if(target!=null){        target.run;    }}

从定义中可以发现，在Thread类中的run()方法调用的Runnable接口中的run()方法，也就是说此方法是由Runnable子类完成的，所以如果要通过Thread类实现多线程，则必须覆写run()方法。
实际上Thread类和Runnable接口也是有区别的，如果一个类继承Thread类，则不适合于多个线程共享资源，而实现Runnable接口，就可以直接实现资源的共享。
【继承thread类而不能共享资源】

class MyThread extends Thread{  // 继承Thread类，作为线程的实现类    private int ticket = 5 ;        // 表示一共有5张票    public void run(){  // 覆写run()方法，作为线程 的操作主体        for(int i=0;i<100;i++){            if(this.ticket>0){                System.out.println("卖票：ticket = " + ticket--) ;            }        }    }};public class ThreadDemo04{    public static void main(String args[]){        MyThread mt1 = new MyThread() ;  // 实例化对象        MyThread mt2 = new MyThread() ;  // 实例化对象        mt1.start() ;   // 调用线程主体        mt2.start() ;   // 调用线程主体    }};

运行结果：

卖票：ticket=5卖票：ticket=5卖票：ticket=4卖票：ticket=3卖票：ticket=2卖票：ticket=1卖票：ticket=4卖票：ticket=3卖票：ticket=2卖票：ticket=1

以上程序通过Thread类实现多线程，程序中实现了2个线程，但是两个线程分别买了各自的5张票，并没有达到资源共享的目的。
【实现Runnable接口可以资源共享】

class MyThread2 implements Runnable {    private int ticket = 5;    @Override    public void run() {        for (int i = 0; i < 100; i++) {            if (ticket > 0) {                System.out.println("卖票：ticket=" + ticket--);            }        }    }}public class RunnableDemo01 {    public static void main(String[] args) {        MyThread2 mt1 = new MyThread2();        new Thread(mt1).start();        new Thread(mt1).start();        new Thread(mt1).start();    }}

运行结果：
卖票：t这里写代码片icket=5
卖票：ticket=4
卖票：ticket=2
卖票：ticket=3
卖票：ticket=1
从程序的运行结果可以发现，虽然启动了线程，但是3个线程一共才卖5张票，即ticket属性被所有属性被所有的行程对象共享。
可见，实现Runable接口相对于继承Thread类说，有如下显著的优势：
（1） 适合多个相同程序代码的线程去处理同一个资源的情况
（2） 可以避免由于Java单继承特性带来的局限
（3） 增强了程序的健壮性，代码能够被多个线程共享，代码与数据都是相互独立的
所以，在开发中建议使用Runnable接口实现多线程。