方式一：实现继承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 异常。
可选的这俩个参数有默认提供的
关于线程池的部分，参考大佬文章
彻底搞懂线程池