Java中多线程实现的方式

在Java中多线程实现的方式有 

①、继承Thread类

②、实现Runnable接口（常用，优点多）

③、实现Callable接口

比较：
实现Runnable和Callable接口的类只能当作一个可以在线程中运行的target，不是真正意义上的线程，最后还需要Thread来调用。
在Runnable中，实现类的run方法作为线程的执行体，实际的线程对象依然是Thread实例。Callable接口与Runnable相比，Callable可以有返回值，返回值通过FutureTask进行封装,Callable还可以向上抛出异常。

更倾向于实现接口，因为：java不支持多重继承，继承了Thread就不能继承别的了，类可能只要求可执行就行，继承整个Thread类开销大。

一、继承Tread类

Thread类实现了Runnable接口，在java.long包下。

创建执行线程方法一：将类继承Thread类，重写Thread类的run方法。接下来就可以分配并启动该子类的实例。

具体步骤：

①、继承Thread类
②、重写run方法
③、将执行的代码写在run方法中
④、创建Thread类的子类对象
⑤、使用start方法开启线程。
注意：调用run方法不能开启多线程。

只有调用了start()方法，才会表现出多线程的特性，不同线程的run()方法里面的代码交替执行。

如果只是调用run()方法，那么代码还是同步执行的，必须等待一个线程的run()方法里面的代码全部执行完毕之后，另外一个线程才可以执行其run()方法里面的代码。

一个线程不能多次开启是非法的

下面就按照上述继承Tread类实现多线程的例子

/**
 * @ Author zhangsf
 * @CreateTime 2019/9/21 - 8:26 AM
 */
package com.bjut.Multithreading;

public class ThreadTest {
    public static void main(String[] args) {
        //4，创建Thread类的子类对象
        MyThread mt = new MyThread();
        //5，使用start方法开启线程
        mt.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("main方法：" + i);
        }
    }
}
//1.继承Thread类
class  MyThread extends  Thread{
    //2，重写run方法
    @Override
    public void run(){
        //3，将执行的代码写在run方法中
        for (int i = 0; i <5; i++) {
            System.out.println("MyThread的run方法："+i);
        }
    }
}

举一个返利就是在调用Thread类的子对象的时候，调用的run()方法来执行的话，这个重新的run方法也是一个普通的方法

输出就只能是runmain

只有调用了start方法才是启动了多线程，输出就是固定为mainrun（因为run方法中有休眠的时刻，多线程main语句就已经执行了）

方法二：实现Runnable接口

声明实现Runnable接口的类，实现Runnable接口中仅有的run方法，然后分配实例对象，在创建Thread时作为一个参数来传递并启动。具体步骤如下

①、定义类实现Runnable接口
②、在该类中实现Runnable接口中的run()方法
③、线程中具体要执行的东西写在run()方法中

④、创建自定义Runnable实现类对象
⑤、创建Thread类的对象，并在该对象中传入该实现Runnable接口的对象作参数
⑥、Thread类的对象调用start()方法开启新线程，其内部会自动的调用run方法

/**
 * @ Author zhangsf
 * @CreateTime 2019/9/21 - 8:41 AM
 */
package com.bjut.Multithreading;
public class RunnableTest {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable(); //④、创建自己定义的Runnable实现类的对象
        Thread thread = new Thread(mr); //⑤、创建Thread类的对象，并将自定义Runnable实现类的对象作为参数传递给Thread的构造函数
        thread.start(); //⑥使用thread类的start方法开启线程。
        for (int i = 0; i < 5; i++) {
            System.out.println("main方法中：" + i);
        }
    }
}
     //①、定义一个Runnable实现类
class MyRunnable implements Runnable {
    //②、实现Runnable接口中的抽象方法
    @Override
    public void run() {
        //③、在run方法中写入要使用多线程的具体方法
        for (int i = 0; i < 5; i++) {
            System.out.println("MyRunnable的方法中" + i);
        }
    }
}

使用匿名内部类的方式来实现继承Thread类和实现Runnable接口的方法来实现多线程

/**
 * @ Author zhangsf
 * @CreateTime 2019/9/21 - 8:52 AM
 */
package com.bjut.Multithreading;
public class AnonymousThread {
    public static void main(String[] args) {
        // 继承Thread类实现多线程
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("继承Thread类实现多线程"+Thread.currentThread().getName() + "--" + i);
                }
            }
        }.start();
        // 实现Runnable接口实现多线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("实现Runnable接口实现多线程"+Thread.currentThread().getName() + "--" + i);
                }
            }
        }) {
        }.start();
    }
}

多线程的两种实现方式（实现Runnable接口、和继承Thread类）的区别

源码中的区别
继承Thread类方式：由于子类重写了Thread类的run()，当调用start()时，直接找子类的run()方法(Java虚拟机自动完成)
实现Runnable方式：构造函数中传入了Runnable的引用，传给了Thread类中的成员变量，start()调用了run()方法时的内部判断成员变量Runnable的引用是否为空，若不为空，编译时看的是Runnable的run()，运行时执行的是具体实现类中的run()
优缺点：
继承Thread类方式
好处：可以直接使用Thread类中的方法，代码简单
弊端：同样也是面向对象中的继承的缺点：如果该具体类已经有了其他的父类，那么就不能多重继承Thread类，就不能使用这种方法。此时面向接口编程的优势脱颖而出。
实现Runnable接口方式
好处：即继承的弊端：即使自己定义的线程类有了其他父类也可以实现该Runnable接口。Java中的接口是多实现的，继承是单继承，比较有局限性。
弊端：不能直接使用Thread类中的方法，需要先把Runnable具体实现类对象传递给Thread类并获取到线程对象后，才能得到Thread类的方法，代码相对复杂

方式三：实现Callable接口

步骤：
创建实体类，实现Callable接口
实现接口中的call()方法
利用 ExecutorService线程池对象 的 <T> Future<T> submit(Callable<T> task()方法提交该Callable接口的线程任务。

• 实现callable接口，提交给ExecutorService返回值是异步执行的。
• 该方式的优缺点：
  • 优点：
  • 有返回值
  • 可以抛出异常
  • 缺点：
  • 代码较复杂，需要利用线程池

/**
 * @ Author zhangsf
 * @CreateTime 2019/9/21 - 8:15 AM
 */
package com.bjut.Multithreading;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 * Callable是一个接口，里面只有一个方法：call，此方法有返回值。
 */
public class CallableDemo implements Callable {
    @Override
    public String call() throws Exception {    //可以有返回值
        return Thread.currentThread().getName();
    }
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        CallableDemo cd=new CallableDemo();
        FutureTask ft=new FutureTask(cd);
        FutureTask ft1=new FutureTask(cd);
        Thread td=new Thread(ft);
        Thread td1=new Thread(ft1);
        td.setName("张三");
        td1.setName("李四");
        td.start();
        td1.start();
        System.out.println(ft.get());    //通过get方法获取返回值
        System.out.println(ft1.get());
    }
}