Java多线程(1)

3、具体内容

         从多线程开始，Java正式进入到应用部分，而对于多线程的开发，从Java EE上表现的并不是特别多，但是在Android开发之中使用较多，并且需要提醒的是，笔试或面试的过程之中，多线程所问到的问题是最多的。

3.1、多线程的基本概念

         如果要想解释多线程，那么首先应该从单进程开始讲起，最早的DOS系统有一个最大的特征：一旦电脑出现了病毒，电脑会立刻死机，因为传统DOS系统属于单进程的处理方式，即：在同一个时间段上只能有一个程序执行。后来到了windows时代，电脑即使（非致命）存在了病毒，那么也可以正常使用，只是慢一些而已，因为windows属于多进程的处理操作，但是这个 时候的资源依然只有一块，所以在同一个时间段上会有多个程序共同执行，而在一个时间点上只能有一个程序在执行，多线程是在一个进程基础之上的进一步划分， 因为进程的启动所消耗的时间是非常长的，所以在进程之上的进一步的划分就变得非常重要，而且性能也会有所提高。

 

         所有的线程一定要依附于进程才能够存在，那么进程一旦消失了，线程也一定会消失，但是反过来不一定。而Java是为数不多的支持多线程的开发语言之一。

3.2、多线程的实现（重点）

         在Java之中，如果要想实现多线程的程序，那么就必须依靠一个线程的主体类（就好比主类的概念一样，表示的是一个线程的主类），但是这个线程的主体类在定义的时候也需要有一些特殊的要求，这个类可以继承Thread类或实现Runnable接口来完成定义。

3.2.1 、继承Thread类实现多线程

         java.lang.Thread是一个负责线程操作的类，任何的类只需要继承了Thread类就可以成为一个线程的主类，但是既然是主类必须有它的使用方法，而线程启动的主方法是需要覆写Thread类中的run()方法才可以。

范例：定义一个线程的主体类

class MyThread extends Thread { // 线程的主体类

    private String title;

    public MyThread(String title) {

        this.title = title;

    }

    @Override

    public void run() { // 线程的主方法

        for (int x = 0; x < 50; x++) {

            System.out.println(this.title + "运行，x = " + x);

        }

    }

}

         现在按照道理来讲，已经出现了线程类，并且里面也存在了相应的操作方法，那么就应该产生对象并调用里面的方法，自然下面编写出了下的程序。

public class TestDemo {

    public static void main(String[] args) throws Exception {

        MyThread mt1 = new MyThread("线程A") ;

        MyThread mt2 = new MyThread("线程B") ;

        MyThread mt3 = new MyThread("线程C") ;

        mt1.run() ;

        mt2.run() ;

        mt3.run() ;

    }

}

         但是以上的操作实话而言并没有真正的启动多线程，因为多个线程彼此之间的执行一定是交替的方式运行，而此时是顺序执行，即：每一个对象的代码执行完之后才向下继续执行。如果要想在程序之中真正的启动多线程，必须依靠Thread类的一个方法：public void start()，表示真正启动多线程，调用此方法后会间接调用run()方法。

public class TestDemo {

    public static void main(String[] args) throws Exception {

        MyThread mt1 = new MyThread("线程A") ;

        MyThread mt2 = new MyThread("线程B") ;

        MyThread mt3 = new MyThread("线程C") ;

        mt1.start() ;

        mt2.start() ;

        mt3.start() ;

    }

}

         此时可以发现，多个线程之间彼此交替执行，但是每次的执行结果肯定是不一样的。通过以上的代码就可以得出结论：要想启动线程必须依靠Thread类的start()方法执行，线程启动之后会默认调用了run()方法。

疑问？为什么线程启动的时候必须调用start()而不是直接调用run()？

         发现调用了start()之后，实际上它执行的还是覆写后的run()方法，那为什么不直接调用run()方法呢？那么为了解释此问题，下面打开Thread类的源代码，观察一下start()方法的定义。

    public synchronized void start() {

        if (threadStatus != 0)

            throw new IllegalThreadStateException();

        group.add(this);

        boolean started = false;

        try {

            start0();

            started = true;

        } finally {

            try {

                if (!started) {

                    group.threadStartFailed(this);

                }

            } catch (Throwable ignore) {

            }

        }

    }

    private native void start0();

         打开此方法的实现代码首先可以发现方法会抛出一个“IllegalThreadStateException”异常。按照之前所学习的方式来讲，如果一个方法之中使用了throw抛出一个异常对象，那么这个异常应该使用try…catch捕获，或者是方法的声明上使用throws抛出，但是这块都没有，因为这个异常类是属于运行时异常（RuntimeException）的子类。

java.lang.Object

         |- java.lang.Throwable

                   |- java.lang.Exception

                            |- java.lang.RuntimeException

                                     |- java.lang.IllegalArgumentException

                                               |- java.lang.IllegalThreadStateException

         当一个线程对象被重复启动之后会抛出此异常，即：一个线程对象只能启动唯一的一次。在start()方法之中有一个最为关键的部分就是start0()方法，而且这个方法上使用了一个native关键字的定义。

         native关键字指的是Java本地接口调用（Java Native Interface），即：是使用Java调用本机操作系统的函数功能完成一些特殊的操作，而这样的代码开发在Java之中几乎很少出现，因为Java的最大特点是可移植性，如果一个程序只能在固定的操作系统上使用，那么可移植性就将彻底的丧失，所以，此操作一般只作为兴趣使用。

         多线程的实现一定需要操作系统的支持，那么以上的start0()方法实际上就和抽象方法很类似没有方法体，而这个方法体交给JVM去实现，即：在windows下的JVM可能使用A方法实现了start0()，而在linux下的JVM可能使用了B方法实现了start0()，但是在调用的时候并不会去关心具体是何方式实现了start0()方法，只会关心最终的操作结果，交给JVM去匹配了不同的操作系统。

         所以在多线程操作之中，使用start()方法启动多线程的操作是需要进行操作系统函数调用的。

3.2.2 、实现Runnable接口实现多线程

         使用Thread类的确是可以方便的进行多线程的实现，但是这种方式最大的缺点就是单继承的问题，为此，在java之中也可以利用Runnable接口来实现多线程，而这个接口的定义如下：

public interface Runnable {

    public void run();

}

分享：如何区分新老接口？

         在JDK之中，由于其发展的时间较长，那么会出现一些新的接口和老的接口，这两者有一个最大的明显特征：所有最早提供的接口方法里面都不加上public，所有的新接口里面都有public。

范例：通过Runnable接口实现多线程

class MyThread implements Runnable { // 线程的主体类

    private String title;

    public MyThread(String title) {

        this.title = title;

    }

    @Override

    public void run() { // 线程的主方法

        for (int x = 0; x < 50; x++) {

            System.out.println(this.title + "运行，x = " + x);

        }

    }

}

         这个时候和之前的继承Thread类区别不大，但是唯一的好处就是避免了单继承局限，不过现在问题也就来了。刚刚解释过，如果要想启动多线程依靠Thread类的start()方法完成，之前继承Thread类的时候可以将此方法直接继承过来使用，但现在实现的是Runable接口，没有这个方法可以继承了，为了解决这个问题，还是需要依靠Thread类完成，在Thread类中定义了一个构造方法：public Thread(Runnable target)，接收Runnable接口对象。

范例：利用Thread类启动多线程

public class TestDemo {

    public static void main(String[] args) throws Exception {

        MyThread mt1 = new MyThread("线程A");

        MyThread mt2 = new MyThread("线程B");

        MyThread mt3 = new MyThread("线程C");

        new Thread(mt1).start();

        new Thread(mt2).start();

        new Thread(mt3).start();

    }

}

         这个时候就实现了多线程的启动，而且没有了单继承局限。

3.2.3 、Thread类和Runnable接口实现多线程的区别（面试题）

         现在Thread类和Runnable接口都可以做为同一功能的方式来实现多线程，那么这两者如果从Java的实际开发而言，肯定使用Runnable接口，因为可以有效的避免单继承的局限，那么除了这些之外，这两种方式是否还有其他联系呢？

         为了解释这两种方式的联系，下面可以打开Thread类的定义：

public class Thread extends Object implements Runnable

         发现Thread类也是Runnable接口的子类，而如果真的是这样，那么之前程序的结构就变为了以下形式。

 

         这个时候所表现出来的代码模式非常类似于代理设计模式，但是它并不是严格意义上代理设计模式，因为从严格来讲代理设计模式之中，代理主题所能够使用的方法依然是接口中定义的run()方法，而此处代理主题调用的是start()方法，所以只能够说形式上类似于代理设计模式，但本质上还是有差别的。

         但是除了以上的联系之外，对于Runnable和Thread类还有一个不太好区分的区别：使用Runnable接口可以更加方便的表示出数据共享的概念。

范例：通过继承Thread类实现卖票程序

package cn.mldn.demo;

class MyThread extends Thread { // 线程的主体类

    private int ticket = 5; // 一共5张票

    @Override

    public void run() { // 线程的主方法

        for (int x = 0; x < 50; x++) {

            if (this.ticket > 0) {

                System.out.println("卖票，ticket = " + this.ticket --);

            }

        }

    }

}

public class TestDemo {

    public static void main(String[] args) throws Exception {

        MyThread mt1 = new MyThread();

        MyThread mt2 = new MyThread();

        MyThread mt3 = new MyThread();

        mt1.start() ;

        mt2.start() ;

        mt3.start() ;

    }

}

         现在的结果是一共买出了15张票，等于是每一个线程对象各自卖各自的5张票，这个时候的内存关系图如下：

 

范例：利用Runnable来实现多线程

package cn.mldn.demo;

class MyThread implements Runnable { // 线程的主体类

    private int ticket = 5; // 一共5张票

    @Override

    public void run() { // 线程的主方法

        for (int x = 0; x < 50; x++) {

            if (this.ticket > 0) {

                System.out.println("卖票，ticket = " + this.ticket--);

            }

        }

    }

}

public class TestDemo {

    public static void main(String[] args) throws Exception {

        MyThread mt = new MyThread();

        new Thread(mt).start();

        new Thread(mt).start();

        new Thread(mt).start();

    }

}

    现在使用继承Thread类也可以实现同样的功能。

package cn.mldn.demo;

class MyThread extends Thread { // 线程的主体类

    private int ticket = 5; // 一共5张票

    @Override

    public void run() { // 线程的主方法

        for (int x = 0; x < 50; x++) {

            if (this.ticket > 0) {

                System.out.println("卖票，ticket = " + this.ticket--);

            }

        }

    }

}

public class TestDemo {

    public static void main(String[] args) throws Exception {

        MyThread mt = new MyThread();

        new Thread(mt).start();

        new Thread(mt).start();

        new Thread(mt).start();

    }

}

面试题：请解释多线程的两种实现方式及区别？分别编写程序以验证两种实现方式。

         · 多线程的两种实现方式都需要一个线程的主类，而这个类可以实现Runnable接口或继承Thread类，不管使用何种方式都必须在子类之中覆写run()方法，此方法为线程的主方法；

         · Thread类是Runnable接口的子类，而且使用Runnable接口可以避免单继承局限，以及更加方便的实现数据共享的概念。