实现多线程的几种方式

方式一：实现继承Thread类

步骤：
1:定义一个类去继承Thread类，比如ThreadDemo
2:重写run()方法
3:在测试类中创建ThreadDemo类的对象
4:启动线程

ThreadDemo类

public class ThreadDemo extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            System.out.println("多线程运行..."+i);
        }
    }
}

测试类

public class TestDemo {
    public static void main(String[] args){
       	ThreadDemo threadDemo1 = new ThreadDemo();
        ThreadDemo threadDemo2 = new ThreadDemo();
        //线程执行的方法，开启了俩个线程
        threadDemo1.start();
        threadDemo2.start();
    }
}

运行结果

看了一下代码，其实这个方式也是通过实现Runnable接口完成的

方式二：实现Runnable接口

步骤：
1：定义一个类，实现Runnable接口，比如RunnableDemo类
2：重写run()方法
3：创建测试类，并创建RunnableDemo类对象
4：创建Thread对象，将RunnableDeme类对象作为构造方法的参数传进去
5：启动线程

RunableDemo类

public class RunnableDemo implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"-----"+i);
        }
    }
}

测试类

public class TestDemo {
    public static void main(String[] args){
        RunnableDemo runnableDemo = new RunnableDemo();
        Thread thread1 = new Thread(runnableDemo, "线程1");
        Thread thread2 = new Thread(runnableDemo, "线程2");
        thread1.setPriority(10);//这是设置线程优先级的方法，10优先级最高，1最低
        thread2.setPriority(1);
        thread1.start();
        thread2.start();
    }
}

运行结果

与第一种方式看起来其实区别不大哈，就是实现和继承的区别，还有创建线程时需要将那个实现了Runnable接口的对象传入Thread中当构造方法的参数

方式三：实现Callable接口

步骤：
1：定义一个类实现Callable接口，并指定返回值类型，比如CallableDemo
2：重写call()方法
3：创建测试类，创建CallableDemo对象
4：创建Future的实现类FutureTask对象，并将CallableDemo对象作为构造方法的参数传进去
5：创建Thread类的对象，将FutureTask对象作为构造方法的参数传进去
6：启动线程
7：可以通过get方法获取线程结束后的结果

CallableDemo 类

//返回值是string类型
public class CallableDemo implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("正在执行" + i);
        }	
        //返回值就表示线程运行完毕之后的结果
        return "哦豁";
    }
}

测试类

public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        CallableDemo mc = new CallableDemo ();
        FutureTask<String> ft = new FutureTask<>(mc);
        //创建线程对象
        Thread t1 = new Thread(ft);
        String s = ft.get();
        //开启线程
        t1.start();
        System.out.println(s);
    }
}

这个跟之前的不同之处就是有个返回值，然后创建时有所不同

总结：
1：在阿里巴巴开发手册中明确提到，不允许显示创建线程，应该用线程池的方式提供
2：上面三种实现多线程的方式第一种因为是继承，扩展性弱，不推荐使用，第二种和第三种的区别就是有无返回值
3：反正都不咋用，看看了解一下得了，重点是下面的线程池创建线程

方式三：用线程池的方式实现多线程

1：什么是线程池
简单理解就是线程池是一个存储线程的池子，来了个任务我不需要专门去新建，之后又销毁，线程池中有大量的空闲线程，启动这个线程做任务，做完之后也不用销毁，线程会继续变成空闲状态
就好像是一个水池，我每次想喝水不用去挖个井，喝完之后再把井填上，直接从水池里面喝就行了

2：线程池的存在的意义
因为创建销毁线程比较消耗系统资源，为了避免频繁的去创建并销毁那些短暂的线程；
减少在创建和销毁线程上所花的时间以及系统资源的开销，
如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。

3：如何使用线程池
线程池有几种创建方式，比如
FixedThreadPool 定长线程池
ScheduledThreadPool，定时线程池
CachedThreadPool 可缓存线程池
SingleThreadExecutor 单线程化线程池
但是，阿里手册明确要求，不能使用他们

所以，线程池的使用重点是ThreadPoolExecutor

关于ThreadPoolExecutor的创建

//创建线程池
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);

在idea中ctrl+P查看创建线程池的参数如下

下面来详细解释这些参数
参数1(必需)：int corePoolSize ：核心线程数；核心线程会一直存活，如果将 allowCoreThreadTimeout 设置为 true 时，核心线程也会被超时回收；
设置代码如下

threadPoolExecutor.allowCoreThreadTimeOut(true);

参数2(必需)：int maximumPoolSize：线程池所能容纳的最大线程数。当活跃线程数达到该数值后，后续的新任务将会阻塞。如果线程数超过了核心线程数，那么会创建新的线程，最多就只能创建这么多；

参数3(必需)：long keepAliveTime ：线程闲置超时时长。如果超过该时长，非核心线程就会被回收。如果将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。

参数4(必需)：TimeUnit unit：指定 keepAliveTime 参数的时间单位。常用的有：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分）。

参数5(必需)：BlockingQueue workQueue ： 任务队列。通过线程池的 execute() 方法提交的 Runnable 对象将存储在该参数中。其采用阻塞队列实现。
有以下几种

            new ArrayBlockingQueue<Runnable>(20);
            new LinkedBlockingDeque<Runnable>();
            new PriorityBlockingQueue<>();
            new SynchronousQueue<>();
            new LinkedBlockingDeque<>();
            new LinkedBlockingQueue<>();
            new DelayQueue<Delayed对象>();

参数6(可选)：ThreadFactory threadFactory：线程工厂。用于指定为线程池创建新线程的方式。

参数7(可选)：RejectedExecutionHandler handler：拒绝策略。当达到最大线程数时需要执行的饱和策略。默认丢弃任务并抛出 RejectedExecutionException 异常。

可选的这俩个参数有默认提供的

关于线程池的部分，参考大佬文章
彻底搞懂线程池