Java创建线程的四种方式

      在JDK5之前，可以使用继承Thread类和实现Runable接口来创建一个进程。而在JDK5之后，又新增了两种，实现Callable接口和使用线程池创建线程。

方式一：继承Thread类

使用步骤:

1. 定义子类继承Thread类。
2. 子类中重写Thread类中的run()方法。
3. 创建Thread子类对象，即创建了线程对象。
4. 调用线程对象start方法：启动线程，调用run()方法。

class MyThread extends Thread {
    public MyThread(String name) {
        super(name); // 调用父类的有参构造给线程起名字
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread("myThread");
        myThread.start(); // start 方法启动线程
    }
}

方式二：实现Runnable接口

使用接口避免单继承的局限性。
使用步骤：

1. 定义子类，实现Runnable接口
2. 子类中重写Runnable接口中run()方法。
3. 通过Thread类含参构造器创建线程对象。
4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
5. 调用Thread类的start方法：开启线程，调用Runnable子类接口的run()方法。

class MyThread implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        Runnable runnable = new MyThread();
        Thread t1 = new Thread(runnable,"runnable"); //传入Runnable实现类和线程名
        t1.start(); // start()方法启动线程
    }
}

方法三：实现Callable接口

       原来开发来讲如果要进行多线程的实现肯定依靠的就是Runnable，但是Runnable接口有一个缺点：当线程执行完毕之后，我们无法获取一个返回值。Runnable的run()方法是没有返回值的。所以从JDK5之后就提出了一个新的线程实现接口：java.util.concurrent.Callable接口。
与使用Runnable相比,Callable功能更强大一些

• 相比run()方法，可以有返回值
• 方法可以抛出异常
• 支持泛型的返回值
• 需要借助FutureTask类，比如获取返回结果

使用步骤

1. 定义子类，实现Callable接口
2. 子类中重写Callable接口中call()方法。
3. 通过Thread类含参构造器创建线程对象。
4. 通过FutureTask类含参构造器创建FutureTask对象。
5. 将Callable接口的子类对象作为实际参数传递给FutureTask类的构造器中。
6. 将FutureTask类对象作为实际参数传递给Thread类的构造器中。
7. 调用Thread类的start方法：开启线程，调用Callable子类接口的call()方法。

解释一下，线程的启动，只能通过一种方式，那就是Thread类的start()方法。那么如何让Callable接口和Thread类搭上关系呢？就需要借助于FutureTask类了。
首先，FutureTask这个类的有参构造可以传入一个Callable接口的实现类对象。
然后看看FutureTask类的定义

public class FutureTask<V> implements RunnableFuture<V> {}

FutureTas实现了RunnableFuture这个接口

public interface RunnableFuture<V> extends Runnable, Future<V> {}

RunnableFuture这个接口又继承了我们想看到的Runnable接口。那么根据接口的传递性，FutureTask也实现了Runnable接口，FutureTask也是Runnable接口的一个子类，而Thread的构造器刚好能够接收Runnable接口对象。FutureTask重写的run()方法中就调用了Callable实现类对象的call()方法。
这样，Callable接口和Thread就搭上关系了。

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

class MyThread implements Callable<String> { //Callable接口的泛型就是call()方法的返回类型

    @Override
    public String call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
        return "线程执行完毕";
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();//创建Callable接口实现类
        FutureTask futureTask = new FutureTask(myThread);//传入FutureTask构造器
        Thread thread = new Thread(futureTask);//传入Thread构造器
        thread.start(); // 一定要先start()启动才能get()获取到返回值
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

方式四：线程池创建

       经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大，对此，可以提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
线程池相关API:ExecutorService和Executors。
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

• void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
• Future submit(Callable task)：执行任务，有返回值，一般又来执行Callable
• void shutdown() ：关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

• Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
• Executors.newFixedThreadPool(n)：创建一个可重用固定线程数的线程池
• Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
• Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
• Executors.newWorkStealingPool(int)：jdk8新增，使用目前机器上可用的处理器作为它的运行级别。

package day03;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class MyThread implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        // 1.调用Executors的newFixedThreadPool(),返回指定线程数量的ExecutorService
        ExecutorService pool = Executors.newFixedThreadPool(10);
        // 2.将Runnable实现类对象传递给ExecutorService的execute()方法中，开启线程并执行相关的run()
        pool.execute(new MyThread());
        pool.execute(new MyThread());
        pool.execute(new MyThread());
        // 3.结束线程的使用
        pool.shutdown();
    }
}