多线程的几种创建方法

最近回顾复习一下线程这一部分知识，这一块怎么也搞不明白（也不算搞不明白，不知道怎么使用），所以写下来，以便以后观看。

线程的四种创建方式

1、继承Thread类（重要）

创建一个类通过extends关键字继承Thread类，然后在主方法中重写Thread类中的run()方法，创建子类对象，通过此对象调用start()方法。

public class ThreadTest{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName()+":-------");
        }
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+i);
            }
        }
    }
}

那问题来了

1、为什么不能直接调用run()方法，非得使用子类对象调用start()方法。

原因是：

用run()方法只是java中简单的对象调用方法的作用，只有主程序一条执行路径
而通过调用Thread类的 start()方法来启动一个线程，此线程处于就绪（可运行）状态，并没有运行，然后多个线程相互争夺cpu时间片，一旦得到cpu时间片，就开始执行run()方法，这也是为什么多线程执行结果参差不齐

2、线程可以多次调用start()方法多次启动线程吗

No 绝对不可以，当已经调用start()方法后，再次调用会报*IllegalThreadStateException()*异常
原因是：当线程调用start()方法后，会首先进行判断线程状态，当已经调用过此方法后，不满足条件，因此会报异常

2、实现Runnable接口（推荐）

创建一个实现Runnable接口的类，实现Runnable中的run()方法，创建实现类对象并作为参数传递到Thread类的构造方法中，通过Thread类的对象调用start()方法，代码如下

public class ThreadTest2 {
    public static void main(String[] args) {
        MyThread1 myThread1 = new MyThread1();
        new Thread(myThread1).start();
        for (int i = 0; i < 100; i++) {
            System.out.println("======================");
        }
    }
}
class MyThread1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+"-------------"+i);
            }
        }
    }
}

两种方法的联系与区别

区别：
extends关键字是单继承，一个类只能继承一个父类，而实现方法解决了单继承性的局限性
实现方法更适合处理含有共享资源的多线程情况
联系：
本质上Thread类实现的也是Runnable接口，都需要重写run()方法

3、实现Callable接口（进阶）

首先创建一个Callable接口的实现类，实现Callable中call()方法。创建Callable实现类的对象，并作为参数传递到FutureTask构造器中，并创建FutureTask对象，并将该对象作为参数传递到Thread构造器中，创建对象，调用start()方法，最后获取call()方法的返回值。。。（疯狂套娃）

public class ThreadTest3 implements Callable {
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            System.out.println(i);
            sum+=i;
        }
        return sum;
    }
}
class MyThread3{
    public static void main(String[] args) {
        ThreadTest3 threadTest3 = new ThreadTest3();
        FutureTask futureTask = new FutureTask(threadTest3);
        new Thread(futureTask).start();
        try {
            //get()返回值即为call()的返回值
            Object o = futureTask.get();
            System.out.println("总和为："+o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

Callable与Runnable比较

1. call()方法具有返回值
2. call()方法可以抛出异常
3. Callable支持泛型
4. 需要借助FutureTask类
   FutureTask是Future接口的唯一实现类，而Future接口可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等

4、线程池

class MyThread4 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //1.创建指定数量的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        //2.执行线程操作，提供实现Runnable或Callable接口的对象
        executorService.execute(new MyThread4());//适用于Runnable
//        executorService.submit();//适用于Callable
        //关闭连接池
        executorService.shutdown();
    }
}

好处：

提高响应速度
降低资源消耗
便于线程管理

最后，奉上一些常用的方法：

方法	说明
start()	启动当前线程，调用run()方法
currentThread()	返回当前执行的线程
getName()	获取当前线程的名字
setName()	设置当前线程的名字
yield()	释放当前cpu的执行权
join()	使正在执行的线程进入阻塞状态，直到join的线程执行完成，才会结束阻塞状态
sleep()	在指定时间内，当前线程使阻塞状态，单位毫秒
isAlive()	判断当前线程是否存活

如有错误之处，感谢评论指出，虚心请教，共同学习