线程的三种实现方法。

多线程创建的三种方式：

一，创建线程第一种方式（继承Thread）：

* 1，自定义一个类，继承java.lang包下的Thread类

* 2，重写run方法

* 3，将要在线程中执行的代码编写在run方法中

* 4，创建上面自定义类的对象

* 5，调用start方法启动线程。

class MyThread extends Thread{

//2，重写run方法

@Override

    public void run() {

//3，将要在线程中执行的代码编写在run方法中

    for (int i = 0; i < 10; i++) {

System.out.println("hello");

        }

    }

}

public class ThreadTest01 {

public static void main(String[] args) {

//	4，创建上面自定义类的对象

MyThread mt = new MyThread();

//	5，调用start方法启动线程。

mt.start();

for (int i = 0; i < 10; i++) {

System.out.println("2019");

        }

    }

}

二，创建线程第二种方式（实现Runnable接口）：

* 1,自定义一个类，实现java.lang包下的Runnable接口

* 2,重写run方法

* 3,将要在线程中执行的代码编写在run方法中

* 4,创建上面自定义类的对象

* 5,创建Thread对象并将上面自定义类的对象作为参数传递给Thread的构造方法中。

* 6,调用start方法启动线程

//1,自定义一个类，实现java.lang包下的Runnable接口

class MyRunnable implements Runnable{

//2,重写run方法

@Override

public void run() {

//	3,将要在线程中执行的代码编写在run方法中

for (int i = 0; i < 100; i++) {

System.out.println("hello");

        }

    }

}

public class ThreadTest02 {

public static void main(String[] args) {

//4,创建上面自定义类的对象

MyRunnable mr = new MyRunnable();

//5,创建Thread对象并将上面自定义类的对象作为参数传递给Thread的构造方法中。

Thread t = new Thread(mr);

//	6,调用start方法启动线程

t.start();

for (int i = 0; i < 100; i++) {

System.out.println("2019");

        }

    }

}

三，创建线程第三种方式（实现Callable接口）：

* 1,自定义一个类实现java.util.concurrent包下的Callable接口。

* 2，重写Call方法。

* 3，将要在线程中执行的代码编写在call方法中

* 4，创建ExecutorSercice线程池.

* 5,将自定义的对象放入线程池中。

* 6，获取线程返回结果。

* 7，关闭线程，不在接受新的线程，未执行的完的线程不会被关闭。

//1,自定义一个类实现java.util.concurrent包下的Callable接口。

class MyCallable implements Callable<Integer>{

private int count;

public MyCallable(int count) {

    this.count = count;

    }

//2，重写Call方法。

@Override

public Integer call() throws Exception {

//3，将要在线程中执行的代码编写在call方法中

    int sum = 1;

    if (count == 0) {

    sum = 0;

        }else {
    
for (int i = 1; i <= count; i++) {

    sum *= i;

            }

        }

return sum;

    }

}

public class ThreadTest03 {

public static void main(String[] args) throws InterruptedException, ExecutionException {

//4，创建ExecutorSercice线程池.

//ExecutorService es = Executors.newFixedThreadPool(2);

//自动分配线程

    ExecutorService es = Executors.newCachedThreadPool();

//5,将自定义的对象放入线程池中。

    Future<Integer> f1 = es.submit(new MyCallable(5));

    Future<Integer> f2 = es.submit(new MyCallable(3));

//6，获取线程返回结果。

//	System.out.println(f1.get());

//	System.out.println(f2.get());

//判断线程中的任务是否执行完毕

if (f1.isDone()) {

    System.out.println(f1.get());

        }else {

    System.out.println("f1线程未执行完毕！");

        }

if (f2.isDone()) {

    System.out.println(f2.get());

        }else {

    System.out.println("f2线程未执行完毕！");

        }

//7，关闭线程，不在接受新的线程，未执行的完的线程不会被关闭。

    es.shutdown();

    }

}

三种方式的对比：

继承Thread

*    优点:可以直接使用Thread类中的方法,代码简单

*    缺点:继承Thread类之后就不能继承其他的类

实现Runnable接口

*    优点:即使自定义类已经有父类了也不受影响，因为可以实现多个接口

*    缺点: 在run方法内部需要获取到当前线程的Thread对象后才能使用Thread中的方法

实现Callable接口

*    优点：可以获取返回值，可以抛出异常

*    缺点：代码编写较为复杂

使用哪一种视情况而定！