多线程创建的三种方式：
1，创建线程第一种方式（继承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");
}
}
}
2，创建线程第二种方式（实现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");
}
}
}
3，创建线程第三种方式（实现Callable接口）：
* 1,自定义一个类实现java.util.concurrent包下的Callable接口。
* 2，重写Call方法。
* 3，将要在线程中执行的代码编写在call方法中
* 4，创建ExecutorSercice线程池.
* 5,将自定义的对象放入线程池中。
* 6，获取线程返回结果。
* 7，关闭线程，不在接受新的线程，未执行的完的线程不会被关闭。
//1,自定义一个类实现java.util.concurrent包下的Callable接口。
class MyCallable implements Callable
{ 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
f1 = es.submit(new MyCallable(5)); Future
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接口
* 优点：可以获取返回值，可以抛出异常
* 缺点：代码编写较为复杂
使用哪一种视情况而定！