java多线程的实现方式

java多线程的实现方式有3种，分别是继承Thread类、实现Runnable接口、实现Callable接口，其中前两种比较常用。

第一种，通过继承Thread类创建线程类

通过继承Thread类来创建并启动多线程的步骤如下：

1、定义一个类继承Thread类，并重写Thread类的run()方法，run()方法的方法体就是线程要完成的任务，因此把run()称为线程的执行体；

2、创建该类的实例对象，即创建了线程对象；

3、调用线程对象的start()方法来启动线程；

代码实例：
public class ExtendThread extends Thread {
    private int i;
    public static void main(String[] args) {
        for(int j = 0;j < 50;j++) { 
            //调用Thread类的currentThread()方法获取当前线程
            System.out.println(Thread.currentThread().getName() + " " + j);
            if(j == 10) {
                //创建并启动第一个线程
                new ExtendThread().start();
                //创建并启动第二个线程
                new ExtendThread().start();
            }
        }
    }
 
    public void run() {
        for(;i < 100;i++) {
            //当通过继承Thread类的方式实现多线程时，可以直接使用this获取当前执行的线程
            System.out.println(this.getName() + " "  + i);
        }
    }
}
代码相关：

1、上述的getName()方法是返回当前线程的名字，也可以通过setName()方法设置当前线程的名字；

2、当JAVA程序运行后，程序至少会创建一个主线程（自动），主线程的线程执行体不是由run()方法确定的，而是由main()方法确定的；

3、在默认情况下，主线程的线程名字为main，用户创建的线程依次为Thread—1、Thread—2、....、Thread—3；

说明：
     调用start方法后并不意味着会立刻执行run方法里面的代码，只是使该线程处于可运行状态了，具体什么时候执行，要由系统来决定。

第二种，通过实现Runnable接口创建线程类

这种方式创建并启动多线程的步骤如下：

1、定义一个类实现Runnable接口；

2、创建该类的实例对象obj；

3、将obj作为构造器参数传入Thread类实例对象，这个对象才是真正的线程对象；

4、调用线程对象的start()方法启动该线程；

代码实例：

public class ImpRunnable implements Runnable {
    private int i;
    @Override
    public  void run() {
        for(;i < 50;i++) {    
            //当线程类实现Runnable接口时，要获取当前线程对象只有通过Thread.currentThread()获取
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
 
    public static void main(String[] args) {
        for(int j = 0;j < 30;j++) {
            System.out.println(Thread.currentThread().getName() + " " + j);
            if(j == 10) {
                ImpRunnable thread_target = new ImpRunnable();
                //通过new Thread(target,name)的方式创建线程
                new Thread(thread_target,"线程1").start();
                new Thread(thread_target,"线程2").start();
            }
        }
    }
}

代码相关：

1、实现Runnable接口的类的实例对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅仅作为线程执行体，而实际的线程对象依然是Thread实例，这里的Thread实例负责执行其target的run()方法；

2、通过实现Runnable接口来实现多线程时，要获取当前线程对象只能通过Thread.currentThread()方法，而不能通过this关键字获取；

3、从JAVA8开始，Runnable接口使用了@FunctionlInterface修饰，也就是说Runnable接口是函数式接口，可使用lambda表达式创建对象，使用lambda表达式就可以不像上述代码一样还要创建一个实现Runnable接口的类，然后再创建类的实例。

说明：
     该方式是实现接口的方式，限制较小，没有第一种方式的继承的问题，所以推荐使用这种方式。

第三种，通过Callable和Future接口创建线程

通过这两个接口创建线程，你要知道这两个接口的作用，下面我们就来了解这两个接口：通过实现Runnable接口创建多线程时，Thread类的作用就是把run()方法包装成线程的执行体，那么，是否可以直接把任意方法都包装成线程的执行体呢？从JAVA5开始，JAVA提供提供了Callable接口，该接口是Runnable接口的增强版，Callable接口提供了一个call()方法可以作为线程执行体，但call()方法比run()方法功能更强大，call()方法的功能的强大体现在：

1、call()方法可以有返回值；

2、call()方法可以声明抛出异常；

从这里可以看出，完全可以提供一个Callable对象作为Thread的target，而该线程的线程执行体就是call()方法。但问题是：Callable接口是JAVA新增的接口，而且它不是Runnable接口的子接口，所以Callable对象不能直接作为Thread的target。还有一个原因就是：call()方法有返回值，call()方法不是直接调用，而是作为线程执行体被调用的，所以这里涉及获取call()方法返回值的问题。

于是，JAVA5提供了Future接口来代表Callable接口里call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该类实现了Future接口，并实现了Runnable接口，所以FutureTask可以作为Thread类的target，同时也解决了Callable对象不能作为Thread类的target这一问题。

在Future接口里定义了如下几个公共方法来控制与它关联的Callable任务：

1、boolean cancel(boolean mayInterruptIfRunning)：试图取消Future里关联的Callable任务；

2、V get()：返回Callable任务里call()方法的返回值，调用该方法将导致程序阻塞，必须等到子线程结束以后才会得到返回值；

3、V get(long timeout, TimeUnit unit)：返回Callable任务里call()方法的返回值。该方法让程序最多阻塞timeout和unit指定的时间，如果经过指定时间后，Callable任务依然没有返回值，将会抛出TimeoutException异常；

4、boolean isCancelled()：如果Callable任务正常完成前被取消，则返回true；

5、boolean isDone()：如果Callable任务已经完成， 则返回true；

这种方式创建并启动多线程的步骤如下：

1、创建Callable接口实现类，并实现call()方法，该方法将作为线程执行体，且该方法有返回值，再创建Callable实现类的实例；

2、使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值；

3、使用FutureTask对象作为Thread对象的target创建并启动新线程；

4、调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

代码实例：

public class ThirdThreadImp {
    public static void main(String[] args) {
        //这里call()方法的重写是采用lambda表达式，没有新建一个Callable接口的实现类
        FutureTask<Integer> task =  new FutureTask<Integer>((Callable<Integer>)()->{
            int i = 0;
            for(;i < 50;i++) {
                System.out.println(Thread.currentThread().getName() + 
                        "  的线程执行体内的循环变量i的值为：" + i);    
            }
            //call()方法的返回值
            return i;
        });
        
        for(int j = 0;j < 50;j++) {
            System.out.println(Thread.currentThread().getName() + 
                    " 大循环的循环变量j的值为：" + j);
            if(j == 20) {
                new Thread(task,"有返回值的线程").start();
            }
        }
        try {
            System.out.println("子线程的返回值：" + task.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
代码相关：

1、上述代码没有使用创建一个实现Callable接口的类，然后创建一个实现类实例的做法。因为，从JAVA8开始可以直接使用Lambda表达式创建Callable对象，所以上面的代码使用了Lambda表达式；

2、call()方法的返回值类型与创建FutureTask对象时<>里的类型一致。

说明：
      Callable和Runnable功能差不多，但是相比Runnable来说还是有很多区别的，主要体现在以下3点：
     （1）、Callable的call方法有返回值并且可以抛异常，而Runnable的run方法就没有返回值也没有抛异常。
     （2）、Callable运行后可以拿到一个Future对象，这个对象表示异步计算结果，可以从通过Future的get方法获取到call方法返回的结果。但要注意调用Future的get方法时，当前线程会阻塞，直到call方法返回结果。
     （3）、Runnable是作为线程的构造参数运行的，Callable是作为线程池的submit方法的参数运行的。

三种创建方式对比

通过继承Thread类实现多线程：

优点：

1、实现起来简单，而且要获取当前线程，无需调用Thread.currentThread()方法，直接使用this即可获取当前线程；

缺点：

1、线程类已经继承Thread类了，就不能再继承其他类；

2、多个线程不能共享同一份资源（如前面分析的成员变量 i ）；

通过实现Runnable接口或者Callable接口实现多线程：

优点：

1、线程类只是实现了接口，还可以继承其他类；

2、多个线程可以使用同一个target对象，适合多个线程处理同一份资源的情况。

缺点：

1、通过这种方式实现多线程，相较于第一类方式，编程较复杂；

2、要访问当前线程，必须调用Thread.currentThread()方法。