002-线程实现方式【thread、runnable、callale、thread和runnable对比】

一、概述

1、实现方式

　　在java中对于多线程实现一定要有一个线程的主类，而这个线程的主类往往是需要操作一些资源，但是对于多线程主类的实现是：
　　继承Thread父类

　　　　从java的Thread类继承实现多线程，也是实现其run方法，然后声明实例，并调用实例的start方法启动线程。

　　实现Runnable接口（Callable接口）

　　　　使用Runnable接口实现多线程需要两个步骤，首先实现Runnable接口类，然后声明Thread实例，调用thread实例的start方法，开始执行。

2、java Thread类的主要方法介绍

Thread的实例方法：

方法定义	方法说明
public void start()	最常用的方法，顾名思义启动线程，即开始执行线程的run方法
public void run()	如果线程重写了run方法，那么执行重写的方法，否则执行线程的Runnable接口中定义的run方法
public final void setName(String)	设置线程的名称
public final void setPriority(int)	设置线程的优先级（范围在1-10包含1，10）
public final void setDeamon(boolean)	设置线程是否是后台线程
public final void join(long)	在另外一个线程中调用当前线程的join方法，会导致当前线程阻塞，直到另一线程执行完毕，或者超过参数指定毫秒数
public void interrupt()	中断线程
public final boolean isAlive()	线程是否处于存活状态，线程在启动和结束之前都处于存活状态

Thread类的常用静态方法：

方法定义	方法说明
public static void yield()	使当前运行线程相同优先级的线程获得执行机会，类似sleep，但是只会将cpu让给相同优先级的线程
public static void sleep(long)	使当前线程休眠指定毫秒的时间
public static boolean holdsLock(Object x)	判断当前线程是否拥有对象的锁
public static Thread currentThread()	获得当前线程实例
public static void dumpStack()	打印当前线程的执行堆栈，这对多线程程序的调试很有帮助

二、继承Thread类

java.lang.Thread,子类继承Thread，之后覆写run方法，线程主方法

class MyThread extends Thread {
    private String name;
    public MyThread(String name) {
        this.name = name;
    }
    @Override
    public void run() {// 主方法
        for (int i = 0; i < 10; i++) {
            System.out.println(this.name + " i:" + i);
        }
    }
}

　　需要注意，所有线程都是编发执行，在某个时间段上会有多个线程交替执行。所以为了达到这样的目的，绝对不能够直接调用run方法，而是调用线程对象中的start方法

        MyThread mt1 = new MyThread("线程A");
        MyThread mt2 = new MyThread("线程B");
        MyThread mt3 = new MyThread("线程C");
        //mt1.run()  此时 就是方法调用顺序执行
        mt1.start();
        mt2.start();
        mt3.start();

思考？为什么多线程启动不用run，而用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();

源码解析：
1、throw new IllegalThreadStateException(); //异常说明

　　

　　是Runtime异常，多次启动会抛出
2、start0()
　　调用native的本机操作系统函数

　　

　　由于线程启动需要牵扯操作系统中资源的分配问题，所以具体的线程的启动需要根据不同操作系统有不同的实现，而JVM相当于根据系统中定义的start0()方法来根据不同的操作系统进行该方法的实现，这样在多线程的层次上start0()方法名称不变，而不同的操作系统上有不同的实现。
　　结论：只有Thread类的start()方法才能够进行操作系统的资源分配，所以启动多线程的方式永远就是调用thread类的start来实现。

三、实现Runnable接口

　　设计过程中尽量少继承普通类，出现单继承。尽量实现接口或者抽象类。

　　继承Thread类会产生单继承的局限操作，所以现在最好做法利用接口实现。

　　使用Runnable接口实现。Runnable接口的结构：　　

@FunctionalInterface
public interface Runnable {
    public abstract void run();//接口定义的抽象方法
}

　　此时的代码使用的是函数式接口，可以利用lambda表达式完成

1、常规实现

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(this.name + " i:" + i);
        }
    }
}

　　如果启动多线程只能依靠Thread类中的start方法，之前继承thread可以使用，现在继承Runnable接口没有此方法。
　　查看Thread类中的构造方法：public Thread(Runnable target)

        MyThread2 mt21 = new MyThread2("线程A");
        MyThread2 mt22 = new MyThread2("线程B");
        MyThread2 mt23 = new MyThread2("线程C");
        new Thread(mt21).start();
        new Thread(mt22).start();
        new Thread(mt23).start();

2、匿名内部类实现

        String name = "线程对象";//以前必须加上finall，由于lamdba，可以不适用
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(name + " i:" + i);
                }
            }
        }).start();

3、lamda实现【jdk1.8】

由于Runnable接口是函数式接口

        String name = "线程对象";//以前必须加上finall，由于lamdba，可以不适用
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(name + " i:" + i);
            }
        }).start();

　　结论：只要给出的是函数式接口基本上就可以使用lamda表达式或者是方法引用

四、实现Callable接口【jdk1.5之后】

　　Runnable执行完毕，不能回调

　　从JDK1.5之后，对于多线程的实现多了一个Callable接口，在这个接口里面比Runnable接口唯一的强大之处，可以返回执行结果。此接口定义在package java.util.concurrent;包中。

　　定义：

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

　　这个泛型表示的是返回值类型，call（）方法就相当于run（）方法。
　　使用：

class MyThread5 implements Callable<String> {
    private int taket=5;
    @Override
    public String call() {// 主方法
        for (int i = 0; i < 10; i++) {
            if(taket>0)
                System.out.println("卖票 i:" + taket);
        }
        return "票卖完了！";
    }
}

　　问题：现在Thread类中并没有提供接口Callable接口对象的操作。现在如何启动多线程？？

　　　　为了分析启动的操作，需要分析继承结构

　　　　首先来观察java.util.concurrent.FutureTask<V>结构

　　　　

　　方法调用　　　　

        Callable<String> callable = new MyThread5();
        //取得执行结果
        FutureTask<String> task = new FutureTask<>(callable);
        Thread thread = new Thread(task);
        thread.start();
        System.out.println(task.get());

　　对于此种方式没有特殊要求。一般使用Runnable方式

总结：
　　1.Thread有单继承局限。但是所有线程独享一定要通过Thread中的start启动。
　　2.Runnable可以避免单继承局限，建议使用
　　3.Callable比run唯一好处多了返回值的数据。但是使用复杂一些。

五、对于继承Thread方式和实现Runnable接口对比

1、区别和联系

　　1.多线程需要一个线程的主类，这个类要么继承Thread类，要么实现Runnable接口

　　2.使用Runnable接口可以比Thread类更好的实现数据共享的操作，并且利用Runnable接口可以避免单继承局限问题

2、分析

　　两种模式本质上来讲，一定使用Runnable接口实现，这样可以避免单继承局限，除了使用原则之外，还需要知道两种实现方式的联系：

1.Thread类的定义结构：

　　public class Thread implements Runnable

2.代码分析

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(this.name + " i:" + i);
        }
    }
}

main方法

        MyThread2 mt21 = new MyThread2("线程A");
        MyThread2 mt22 = new MyThread2("线程B");
        MyThread2 mt23 = new MyThread2("线程C");
        new Thread(mt21).start();
        new Thread(mt22).start();
        new Thread(mt23).start();

　　

　　分析代码结构，整个代码的操作中使用的就是一个代理设计模式的结构，但是与传统的代理结构有差别。如果按照传统代理模式，现在要想启动多线程，理论上应该是run()方法，但是实质上调用的是start()方法，名称不符合。之所以这样是因为长期发展的产物，以前设计模式不成熟。2000年以后设计模式快速发展。

　　除了以上继承关联之外，还有一些区别：Runnable接口实现的多线程要比Thread类实现的多线更方便表示出数据共享的概念。

3.数据共享示例

示例：希望有三个线程卖票。

thread实现

class MyThread3 extends Thread {
    private int taket=5;
    @Override
    public void run() {// 主方法
        for (int i = 0; i < 10; i++) {
            if(taket>0)
                System.out.println("卖票 i:" +taket);
        }
    }
}

main方法

        MyThread3 mt31 = new MyThread3();
        MyThread3 mt32 = new MyThread3();
        MyThread3 mt33 = new MyThread3();
        mt31.start();
        mt32.start();
        mt33.start();

每个线程各自卖各自的票，数据没有被共享

Runnable实现

class MyThread4 implements Runnable {
    private int taket=5;
    @Override
    public void run() {// 主方法
        for (int i = 0; i < 10; i++) {
            if(taket>0)
                System.out.println("卖票 i:" + taket);
        }
    }
}

main方法实现

        MyThread4 mt = new MyThread4();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();