Java多线程实现的三种方式

一、继承Thread类实现多继承

不足：单继承局限

 java.long.Thread 是一个线程操作的核心类，新建一个线程最简单的方法就是继承Thread，然后腹泻Thread类下的run方法，run方法是线程的主体，它包含了要执行的线程的内容。

步骤一：定义线程主体类

class MyThread extends Thread{
    private String title;
    public MyThread(String title){
        this.title=title;
    }
    public void run(){
        for (int i=0;i<10;i++) {
            System.out.println(this.title + ",i=" + i);
        }
    }
}

步骤二：调用Thread类中的start（）方法正确启动多线程 

public class TestDemo {
    public static void main(String[] args) {
        MyThread myThread1=new MyThread("thread1");
        MyThread myThread2=new MyThread("thread2");
        MyThread myThread3=new MyThread("thread3");
        myThread1.start();
        myThread2.start();
        myThread3.start();
       }
}

注意：不能直接调用run（）方法，要通过调用start()方法来调用run()方法

现象：观察调用run()方法，你会发现，只是做了一个顺序打印，和多线程一点关系都没有；调用start()方法，发现所有的线程对象变成了交替执行。

理由：start()方法启动线程后，整个线程处于就绪状态，等待虚拟机调度，然后通过Thread类调用方法run()来完成其运行操作，期间虚拟机分时间段轮番调用各个线程体，run()方法结束，此线程终止。

            而直接调用run()方法，run()方法就会被当成普通方法，虚拟机不进行线程调度，会执行这个方法直到结束后自动退出，也就有了上面现象中所描述的顺序打印。

Java线程创建的调用流程图：结合源码进行了解

二、Runnable()接口实现多线程

优点：解决了单继承局限问题

需要解决的问题：没有start()方法被继承了，该怎么启动线程

解决方法：关注Thread类的构造方法 public Thread(Runnable targ）

步骤一：利用Runnable接口实现线程主体类

class MyThread implements Runnable{
    private String title;
    public MyThread(String title){
        this.title=title;
    }
    public void run(){
        for (int i=0;i<10;i++) {
            System.out.println(this.title + ",i=" + i);
        }
    }
}

步骤二：启动多线程（多线程的启动永远都是Thread类的start()方法）

public class TestDemo {
    public static void main(String[] args) {
        MyThread myThread1=new MyThread("thread1");
        MyThread myThread2=new MyThread("thread2");
        MyThread myThread3=new MyThread("thread3");
        new Thread(myThread1).start();
        new Thread(myThread2).start();
        new Thread(myThread3).start();
    }
}

注意：对于此时的Runnable接口对象可以采用匿名内部类或者Lambda表达式来定义

（1）使用匿名内部类进行Runnable对象创建

public class TestDemo {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World");
            }
        }).start();
    }
}

  （2）使用Lamdba表达式进行Runnable对象创建

public class TestDemo {
    public static void main(String[] args) {
        Runnable runnable = () -> System.out.println("Hello World");
        new Thread(runnable).start();
    }
}

三、Callable实现多线程

       Runnable中的run()方法没有返回值，它的设计也遵循了主方法的设计原则：线程开始了就别回头。但是很多时候
需要一些返回值，例如某些线程执行完成后可能带来一些返回结果，这种情况下就只能利用Callable来实现多线
程。

步骤一：使用Callable定义线程主体类

class MyThread implements Callable<String>{
    private int ticket=10;
    @Override
    public String call() throws Exception {
        while(ticket>0){
            System.out.println(Thread.currentThread().getName()+"买票，还剩"+--this.ticket+"张票");
        }
        return "票卖完了，下次吧";
    }
}

步骤二：启动线程

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class Mytick {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> task1=new FutureTask<>(new MyThread());
        FutureTask<String> task2=new FutureTask<>(new MyThread());
        new Thread(task1).start();
        new Thread(task2).start();
        System.out.println(task1.get());
        System.out.println(task2.get());

    }
}

Callable实现多线程：