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类的定义：

*/
public
class 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接口实现多线程。