一、继承于Thread类

java.lang.Thread是一个线程操作的核心类，JDK1.0提供。
Thread类本质上也是实现了Runnable接口的一个实例。

package 线程创建;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 线程创建
 * @Author: mcc
 * @CreateTime: 2020-09-24 07:37
 * @Description:
 */
//1.创建一个继承于Thread类的子类
class MyThread extends Thread {
    //2.重写Thread类的run()-->将此线程执行的操作声明在run()中

    @Override
    public void run() {
        //打印100内的偶数
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        //4.通过此对象调用start()
        t1.start();
    }
}

无论哪种方式实现多线程，线程启动一律调用Thread类提供的start()方法。

package 线程创建;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 线程创建
 * @Author: mcc
 * @CreateTime: 2020-09-24 07:37
 * @Description:
 */

public class ThreadTest {
    public static void main(String[] args) {
        //创建Thread类的匿名子类
        new Thread() {
            @Override
            public void run() {
                //打印100内的偶数
                for (int i = 0; i < 100; i++) {
                    if (i % 2 == 0) {
                        System.out.println(i);
                    }
                }
            }
        }.start();
    }
}

1.为什么要覆写run()方法？

Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。也就是说Thread类中的run方法用于存储线程要运行的代码。

2. start( )方法解析：

2.1功能

Ⅰ.启动当前线程
Ⅱ.调用当前线程的run()方法

2.2start( )方法工作流程

Ⅰ.首先检查线程状态是否为0（线程状态默认为0表示未启动），如果线程已经启动再次调用start()方法会抛出IllegalThreadStateException。也就是说，一个线程的start( )方法只能调用一次。
Ⅱ.通过start0()方法真正将线程启动。
Ⅲ.JVM调用start0()方法进行资源分配与系统调度，准备好资源启动线程后回调run()方法来执行线程的具体任务。

问题：为什么要通过start( )方法来调用run( )方法，而不是run( )直接执行？
只有通过调用start()方法，让JVM来调用start0()方法，这时JVM会进行资源分配与系统调度的准备工作；如果直接调用run()方法，就缺少了这些准备工作，相当于调用了一个普通的run()方法，就达不到启动线程的目的。

二、实现Runnable接口

1.引入（多窗口卖票）

package 卖票;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 卖票
 * @Author: mcc
 * @CreateTime: 2020-09-28 08:04
 * @Description:创建三个窗口卖票，总票数为100张；存在线程安全问题，待解决
 */
class Window extends Thread {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(getName() + ": 卖票，票号为：" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");
        w1.start();
        w2.start();
        w3.start();
    }
}

在这里插入图片描述
从结果来看是三个窗口各自卖了100张票，没有达到预期的三个窗口共卖100张票的目的。由于Window这个线程子类中提供的ticket属性是一个实例变量，在主类中创建了3个对象，就意味着每个对象有一份，在调用run方法的时候每个对象判断自己的ticket是否大于0，所以导致卖了300张票；要解决这个问题可以将ticket设为静态
在这里插入图片描述
这时每个对象共享同一个静态变量，如果不想将ticket设置为静态，那该怎么做呢？

2.实现Runnable接口创建多线程

package 线程创建;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 线程创建
 * @Author: mcc
 * @CreateTime: 2020-09-29 07:52
 * @Description:
 */
//1.创建一个实现Runnable接口的类
class MThread implements Runnable {
    //2.实现类去实现Runnable接口的抽象方法：run
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread mThread = new MThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        //5.通过Thread类的对象调用start方法
        t1.start();
        t2.start();
    }
}

提问：
Thread对象通过调用start方法，从而调用了当前线程（Thread类）的run方法，为什么会调用到MThread类中实现的run方法？

//源码
@Override
public void run() {
	if (target != null) {
		target.run();
	}
}

/* What will be run. */
private Runnable target;

public Thread(Runnable target) {
	this(null, target, "Thread-" + nextThreadNum(), 0);
}

调用start方法时，所执行的是Thread类的run方法
Thread类的run方法中，如果target不等于null，则调用target的run方法，所以我们要清楚target的run方法到底是什么
而target是Thread类中声明的Runnable类型的属性
构造器public Thread(Runnable target)中的形参恰好是target，相当于放到形参位置的MThread的对象去赋值target，然后Thread的run方法中，target被赋过值，所以不等于null，这时调用target的run方法，而target的run就是MThread对象所重写的run方法

3.Runnable接口实现多窗口卖票

package 卖票;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 卖票
 * @Author: mcc
 * @CreateTime: 2020-10-08 10:40
 * @Description:创建三个窗口卖票，总票数为100张；存在线程安全问题，待解决
 */
class Window1 implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

public class Window1Test {
    public static void main(String[] args) {
        Window1 window1 = new Window1();

        Thread thread1 = new Thread(window1);
        Thread thread2 = new Thread(window1);
        Thread thread3 = new Thread(window1);

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

在这里插入图片描述

比较创建线程的两种方式：
开发中优先选择实现Runnable接口的方式
原因：

实现方式没有类的单继承局限性
实现方式更适合来处理多个线程共享数据的情况

联系：public class Thread implementb Runnable
相同点：两种方式都需要重写run，将线程要执行的逻辑声明在run中

三、通过Callable接口实现多线程（Futuretask方式）

出现Callable接口实现多线程的原因：由于Runnable接口的run( )方法没有返回值，但是有些线程执行完后可能带来一些返回结果，为了解决这种问题，就出现了Callable接口实现多线程的方式。
在这里插入图片描述

package 线程创建;

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

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 线程创建
 * @Author: mcc
 * @CreateTime: 2020-10-19 07:34
 * @Description:创建线程方式三：实现Callable接口，JDK5.0新增 计算100内偶数的和
 */
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
    //2.实现call方法，将此线程要执行的操作声明在call方法中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start
        new Thread(futureTask).start();
        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object sum = futureTask.get();
            System.out.println("总和：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

如何理解实现Callable接口的方式创建多线程比Runnable方式更强大？

call()可以有返回值
call()可以抛出异常，被外面的操作捕获，获取异常信息
Callable是支持范型的

四、线程池（开发常用）

1.背景

经常创建和销毁使用量特别大的资源，比如并发情况下的线程，对性能影响很大

2.思路

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。类似生活中的公共交通工具

3.好处

提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
便于线程管理
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
KeepAliveTime：县城没有任务时最多保持多长时间后会终止
。。。

package 线程创建;

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

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 线程创建
 * @Author: mcc
 * @CreateTime: 2020-10-21 07:32
 * @Description:使用线程池实现多线程
 */
class NumberThread implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + "：" + i);
            }
        }
    }
}

class NumberThread1 implements Runnable {

    @Override
    public void run() {
        for (int i = 1; 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 service = Executors.newFixedThreadPool(10);
        //2.执行指定的线程操作，需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适用于Runnable
        service.execute(new NumberThread1());//适用于Runnable
        //3.关闭连接池
        service.shutdown();
    }
}

4.线程池相关API

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

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

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

Executors.newCachedThreadPool()：创建一个可以根据需要创建新线程的线程池
Executors.newFixedThreadPool()：创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
Executors.newScheduledThreadPool()：创建一个线程池，它可以排在给定延迟后运行命令或者定期的执行

五、区别

在这里插入图片描述

原文链接：https://blog.csdn.net/weixin_40995778/article/details/80076976

四种创建线程方式

目录

一、继承于Thread类

1.为什么要覆写run()方法？

2. start( )方法解析：

2.1功能

2.2start( )方法工作流程

二、实现Runnable接口

1.引入（多窗口卖票）

2.实现Runnable接口创建多线程

3.Runnable接口实现多窗口卖票

三、通过Callable接口实现多线程（Futuretask方式）

四、线程池（开发常用）

1.背景

2.思路

3.好处

4.线程池相关API

五、区别