创建线程的几种方式

1.继承Thread类创建线程

1】定义Thread类的子类，并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。

2】创建Thread子类的实例，也就是创建了线程对象

3】启动线程，即调用线程的start()方法

package cn.tedu.home.husband.webapi.test;

/**
 * 继承Thread重写run方法创建线程
 */
public class MyThread extends Thread{

    public void run(){

    }
}

class Main {
    public static void main(String[] args) {
        new MyThread().start();
    }
}

2.实现Runnable接口创建线程

1】定义Runnable接口的实现类，一样要重写run()方法，这个run（）方法和Thread中的run()方法一样是线程的执行体

2】创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象

3】第三部依然是通过调用线程对象的start()方法来启动线程

package cn.tedu.home.husband.webapi.test;

/**
 * 实现Runnable接口重写run方法创建线程
 */
public class MyThread2 implements Runnable{

    @Override
    public void run() {

    }
}

class Test{
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread2());
        thread.start();
    }
}

3.使用Callable和Future创建线程

1】创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表达式创建Callable对象）。

2】使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值

3】使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口）

4】调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

package cn.tedu.home.husband.webapi.test;

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

/**
 * 通过Callable和Future创建线程
 * Callable接口 提供了call方法作为线程执行体
 * call方法比run方法功能要强大
 * 》call方法可以有返回值
 * 》call方法可以声明抛出异常
 *
 * Future接口 Java5提供了Future接口来代表Callable接口里call方法的返回值,
 * 并且为Future接口提供了实现类FutureTask,
 * 值得注意的是这个实现类既实现了Future接口,也实现了Runnable接口,
 * 因此可以作为Thread类的target(目标)
 * FutureTask ft = new FutureTask(thread3);也就是这里我们为什么可以封装Callable实现类的实例
 */
public class MyThread3 implements Callable<Integer> {  // 实现Callable接口 Callable可以声明泛型 这里如果没定义默认就是Object类型 也是call方法的返回值 这点也是和run方法不同的地方
    public static void main(String[] args) {
        MyThread3 thread3 = new MyThread3(); // 这里创建了Callable实现类的实例
        FutureTask ft = new FutureTask(thread3);//使用FutureTask类来封装Callable对象
        for (int i =0; i < 100;i++){
            System.out.println(Thread.currentThread().getName()+"循环变量i的值"+i);
            if (i==20){
                new Thread(ft,"有返回值的线程").start();// 实质还是以Callable对象来创建、并启动线程
            }
        }
        try {
            // 获取线程的返回值
            System.out.println("子线程的返回值:"+ft.get());// 返回的是Callable里call方法的返回值，调用这个方法会导致程序阻塞，必须等到子线程结束后才会得到返回值
        }catch (ExecutionException | InterruptedException e){
            e.printStackTrace();
        }
    }



    @Override // 重写call方法 call方法是有返回值的并可以定义返回值类型 
    public Integer call() throws Exception { //作为线程的执行体
        int i = 0;
        for (;i<100;i++){
            System.out.println(Thread.currentThread().getName()+""+i);
        }
        return i;
    }
}

4.使用线程池创建线程

使用线程池可以不用线程的时候放回线程池，用的时候再从线程池取，项目开发中主要使用线程池

package cn.tedu.home.husband.webapi.test;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 自定义线程池创建线程，可以用ThreadPoolExecutor类创建，用该类很容易实现自定义的线程池
 */
public class MyThread4 {
    public static void main(String[] args) {
        // 创建等待(阻塞)队列
        BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20);
        //创建线程池，池中保存的线程数为3(corePoolSize)，允许的最大线程数为5(maximumPoolSize) keepAliveTime(线程存活时间)
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(3,5,50, TimeUnit.MILLISECONDS,bqueue);
        //创建7个任务
        Runnable t1 = new MyThread1();
        Runnable t2 = new MyThread1();
        Runnable t3 = new MyThread1();
        Runnable t4 = new MyThread1();
        Runnable t5 = new MyThread1();
        Runnable t6 = new MyThread1();
        Runnable t7 = new MyThread1();
        //每个任务会在一个线程上执行 三个线程分别执行一个任务 哪个先执行完会再执行下一个任务
        poolExecutor.execute(t1);
        poolExecutor.execute(t2);
        poolExecutor.execute(t3);
        poolExecutor.execute(t4);
        poolExecutor.execute(t5);
        poolExecutor.execute(t6);
        poolExecutor.execute(t7);
        //关闭线程池
        poolExecutor.shutdown();
    }
}
class MyThread1 implements  Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "正在执行.........");
        try {
            Thread.sleep(5000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}