线程、进程的区别，多线程的四种实现方式以及其优缺点总结，四种方式的简单实现代码小demo

本文链接：https://blog.csdn.net/qq_44840230/article/details/118999705

进程：

电脑中时会有很多单独运行的程序，每个程序有一个独立的进程，而进程之间是相互独立存在的。

线程：

进程想要执行任务就需要依赖线程。换句话说，就是进程中的最小执行单位就是线程，并且一个进程中至少有一个线程。
那什么是多线程？提到多线程这里要说两个概念，就是串行和并行，搞清楚这个，我们才能更好地理解多线程。

串行，其实是相对于单条线程来执行多个任务来说的，我们就拿下载文件来举个例子：当我们下载多个文件时，在串行中它是按照一定的顺序去进行下载的，也就是说，必须等下载完A之后才能开始下载B，它们在时间上是不可能发生重叠的。
在这里插入图片描述

并行：下载多个文件，开启多条线程，多个文件同时进行下载，这里是严格意义上的，在同一时刻发生的，并行在时间上是重叠的。
在这里插入图片描述

多线程

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位，而多线程就是指从软件或者硬件上实现多个线程并发执行的技术，具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。

多线程的应用场景：

程序中出现等待的操作的时候，比如网络操作、文件IO等，可以利用多线程充分使用处理器资源，而不会阻塞程序中其他任务的执行
程序中出现可分解的大任务，比如耗时较长的计算任务，可以利用多线程来共同完成任务，缩短运算时间
程序中出现需要后台运行的任务，比如一些监测任务、定时任务，可以利用多线程来完成

自定义线程的实现：

继承Thread类

1、创建一个继承于Thread类的子类
2、重写Thread类中的run()：将此线程要执行的操作声明在run()
3、创建Thread的子类的对象
4、调用此对象的start():①启动线程 ②调用当前线程的run()方法

package thread;

/**
 * @author blh
 * @date 2021/7/22 10:47
 * @Description
 */
//通过继承Thread类来实现自定义线程类
public class MyThread extends Thread{
    //线程体
    @Override
    public void run() {
        System.out.println("run了起来");
    }

    public static void main(String[] args) {
        //实例化自定义的线程
        Thread t = new MyThread();
        //启动线程
        t.start();
    }
}

优点：实现简单，只需实例化继承类的实例，即可使用线程
缺点：扩展性不足，Java是单继承的语言，如果一个类已经继承了其他类，就无法通过这种方式实现自定义线程

实现Runnable接口

1、创建一个实现Runnable接口的类
2、实现Runnable接口中的抽象方法：run():将创建的线程要执行的操作声明在此方法中
3、创建Runnable接口实现类的对象
4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5、调用Thread类中的start():① 启动线程 ② 调用线程的run() —>调用Runnable接口实现类的run()

package thread;

/**
 * @author blh
 * @date 2021/7/22 11:08
 * @Description
 */
public class MyRunnable implements Runnable{

    //线程体
    @Override
    public void run() {
        System.out.println("run起来吧实现了Runnable接口的类");
    }
    public static void main(String[] args){
        //线程的执行目标对象
        MyRunnable myRunnable = new MyRunnable();
        //实际的线程对象
        Thread thread = new Thread(myRunnable);
        //启动线程
        thread.start();
    }
}

优点：
扩展性好，可以在此基础上继承其他类，实现其他必需的功能
对于多线程共享资源的场景，具有天然的支持，适用于多线程处理一份资源的场景
缺点：构造线程实例的过程相对繁琐一点

实现Callable接口

1、与使用Runnable相比， Callable功能更强大些
2、实现的call()方法相比run()方法，可以返回值
3、方法可以抛出异常
4、支持泛型的返回值
5、需要借助FutureTask类，比如获取返回结果

Future接口可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
FutureTask是Futrue接口的唯一的实现类
FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

package thread;

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

/**
 * @author blh
 * @date 2021/7/22 11:12
 * @Description
 */
public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        return "阿巴阿巴";
    }

    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        //传入线程执行目标，实例化线程对象
        Thread t = new Thread(futureTask);
        t.start();
        String r = null;
        try {
             r = futureTask.get();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(r);
    }
}

优点：
扩展性好
支持多线程处理同一份资源
具备返回值以及可以抛出受检查异常
缺点：
相较于实现Runnable接口的方式，较为繁琐

使用线程池

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


package thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
/**
 * @author blh
 * @date 2021/7/22 14:41
 * @Description
 */
public class MyThreadPool implements Runnable{
    @Override
    public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
    }

    public static void main(String[] args) {
        // 线程池
        ExecutorService pool = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor executor = (ThreadPoolExecutor) pool;
        /*
         * 可以做一些操作:
         * corePoolSize：核心池的大小
         * maximumPoolSize：最大线程数
         * keepAliveTime：线程没任务时最多保持多长时间后会终止
         */
        executor.setCorePoolSize(5);
        // 开启线程
        executor.execute(new MyThreadPool());
        executor.execute(new MyThreadPool());
        executor.execute(new MyThreadPool());
        executor.execute(new MyThreadPool());

    }
}

好处：
1、提高响应速度（减少了创建新线程的时间）
2、降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3、便于线程管理

关于线程的一些例子：

你吃饭吃到一半，电话来了，你一直到吃完了以后才去接，这就说明你不支持并发也不支持并行。
你吃饭吃到一半，电话来了，你停了下来接了电话，接完后继续吃饭，这说明你支持并发。
你吃饭吃到一半，电话来了，你一边打电话一边吃饭，这说明你支持并行。
并发的关键是你有处理多个任务的能力，不一定要同时。
并行的关键是你有同时处理多个任务的能力。

多线程使用的主要目的在于：

1、吞吐量：你做WEB，容器帮你做了多线程，但是他只能帮你做请求层面的。简单的说，可能就是一个请求一个线程。或多个请求一个线程。如果是单线程，那同时只能处理一个用户的请求。

2、伸缩性：也就是说，你可以通过增加CPU核数来提升性能。如果是单线程，那程序执行到死也就利用了单核，肯定没办法通过增加CPU核数来提升性能。鉴于你是做WEB的，第1点可能你几乎不涉及。那这里我就讲第二点吧。–举个简单的例子：假设有个请求，这个请求服务端的处理需要执行3个很缓慢的IO操作（比如数据库查询或文件查询），那么正常的顺序可能是（括号里面代表执行时间）：

a、读取文件1 （10ms）

b、处理1的数据（1ms）

c、读取文件2 （10ms）

d、处理2的数据（1ms）

e、读取文件3 （10ms）

f、处理3的数据（1ms）

g、整合1、2、3的数据结果（1ms）

单线程总共就需要34ms。

那如果你在这个请求内，把ab、cd、ef分别分给3个线程去做，就只需要12ms了。

所以多线程不是没怎么用，而是，你平常要善于发现一些可优化的点。然后评估方案是否应该使用。假设还是上面那个相同的问题：但是每个步骤的执行时间不一样了。

a、读取文件1 （1ms）

b、处理1的数据（1ms）