细说Java多线程系列（1.1）线程初探

╰+哭是因爲堅強的太久メ 2022-12-17 07:14 176阅读 0赞

### 细说Java多线程系列（1.1）线程初探 ###

*   *   *  前言
         *  程序、进程、线程与协程（纤程）
         *  创建线程的方式
         *   *  实现Runnable接口的方式
             *  继承Thread类的方式
             *  实现Callable的方式
         *  后记

### 前言 ###

最近开始写Java多线程方面的东西，大概包括四个部分：线程、锁、容器与线程池，每个部分分成好几篇来写，就不知道以我的速度什么时候能写完了。那么第一篇就在1024当天开始吧。

今天我们就先来了解一下与线程本身有关的东西。

### 程序、进程、线程与协程（纤程） ###

这几个概念应该是每个人都遇见过的问题，至于特别官方严谨的概念，网上有很多，说实话看了也记不太住。这里就给出我个人的理解：

首先，程序就是我们写好的代码，它本质上就是一堆二进制的指令和数据，躺在硬盘等着被执行。当我们要执行一个程序的时候，CPU会把它加载到内存中，分配各种资源，然后开始执行这些指令，这时候它就成为了一个进程。一个程序可以被执行很多次，每次对应的进程是不一样的，也可以说，进程是程序的**一次**执行过程。程序与进程，一个是静态的概念，一个是动态的概念。程序就是一堆死在那的代码，而进程是活的，它有自己的生命周期，各种状态，拥有独立的系统资源。

对于一个进程来说，它可能有不同的事情要做，这些事情交给谁来做呢？ 线程才是真正去做事情的人。一个进程内，至少要有一个线程来干活，当然也可以有多个线程。每一个线程都等着CPU的调度，什么时候开始做，做多久，没做完怎么办，都得听CPU安排。所以说，线程是CPU调度的基本单位。

那么，为什么CPU不直接调度进程呢？因为进程是独立占据系统资源（存储空间、I/O资源等）的，切换一次进程开销很大；而同一进程内的多个线程是共享本进程全部资源的，它们自身只占有一点运行时必要的系统资源（程序计数器、一组寄存器和栈），切换线程要节省很多成本。因此对于CPU来说，它调度的是线程，也就意味着在一个进程中，线程是必不可少的。当然，由于线程需要共享进程的资源，其本身只有运行时必要的系统资源，因此线程也不能脱离进程而存在。

我们刚刚所说的线程，是由操作系统内核来实现、管理和调度的，内核可以感知到线程的存在，严格意义上来说，应该称其为内核态线程。而还有一种线程，对于它的管理是由用户来实现的，这种线程的创建、撤销、调度等工作都不依靠系统调用，因此内核是感知不到它的存在的，这种线程被称为用户态线程，也就是协程。协程比我们常说的线程来说，更轻量，因为创建协程的代价比创建线程还要小得多。当然，Java目前还没有支持协程，但是有类库可以使用。

至于纤程呢，可以认为是Windows中的协程。微软为了方便其他公司将代码移植到Windows，对协程这种用户态线程进行了实现，并且提供了一组api可以使用，取名为纤程。纤程与其他语言中的协程可能在实现上会有区别，但是本质上都是用户态线程。

一句话概述：

*  程序（Program）：放在硬盘上的可执行文件
 *  进程（Process）：资源分配的基本单位，程序的一次执行过程
 *  线程（Thread）：CPU调度的基本单位，进程的组成部分
 *  协程（Coroutine）：用户态的轻量级线程
 *  纤程（Fiber）：Windows中的协程

参考资料：

[基础面试题：程序, 进程，线程，纤程，管程，超线程详解][Link 1]

[线程的三种实现方式][Link 2]

[【操作系统】线程实现方式（内核级线程、用户级线程）][Link 3]

[协程-用户态线程][-]

[协程和纤程的区别是什么？][Link 4]

### 创建线程的方式 ###

说了那么多概念上的东西，那么到底如何创建一个线程呢？

直接进到Thread这个类中，可以看到Thread的构造方法：

![1][]

事实上，这些方法都调用了同一个构造方法：  
![2][]

ThreadGroup g: 线程所在的线程组
    Runnable target: 线程要执行的任务
    String name: 线程名字
    long stackSize: 栈空间的大小
    AccessControlContext acc: 安全控制
    boolean inheritThreadLocals: 子线程是否继承父线程的本地变量

对于线程而言，最重要的其实是Runnable这个参数，它代表着线程要执行的任务，毕竟线程就是要来干活的嘛！

Runnable呢，事实上是一个接口，点进源码中看，接口中只有一个run()方法。

![3][]

也就是说，最重要的就是这个run()方法，我们想要创建一个线程，首先要给它一个任务，那么就得实现这个方法，然后交给线程执行。

#### 实现Runnable接口的方式 ####

要实现这个run()方法，首先可以自己写一个类声明实现Runnable接口，然后在类中重写run()方法。

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

这个run的任务是：循环十次输出当前线程的名称。

这样，我们得到了一个Runnable接口的实现类，如果需要执行任务，只需要创建一个线程，将这个类传给它即可。

//两个线程执行的是同一个run()
    MyRunnable myRunnable = new MyRunnable();
    Thread thread1 = new Thread(myRunnable);
    Thread thread2 = new Thread(myRunnable);
    //两个线程执行的是不同的run()
    Thread thread3 = new Thread(new MyRunnable());
    Thread thread4 = new Thread(new MyRunnable());

当然，因为Runnable接口中只有一个方法，而且很多时候我们给线程的任务也不是固定的，也就是说可能需要多个run()方法，为每一个方法都去新建一个类太麻烦，也不方便查看，因此有更简洁的写法，本质上是使用了匿名内部类。

Thread thread = new Thread(new Runnable() { 
        @Override
        public void run() { 
            for (int i = 0;i < 10;i ++){ 
                System.out.println("newRun:"+Thread.currentThread().getName());
            }
        }
    });

在JDK8以后，由于支持了lambda表达式，因此可以写得更加简略

Thread thread = new Thread(()->{
        for(int i = 0;i < 10;i ++){
            System.out.println("lambda:" + Thread.currentThread().getName());
        }
    });
    
    //等同于：
     Runnable r = ()->{
                System.out.println("lambda:" + Thread.currentThread().getName());
     };
     Thread thread = new Thread(r);

#### 继承Thread类的方式 ####

可以发现，Thread类也实现了Runnable接口，这意味着我们可以通过继承Thread类的方式，重写它的run()方法。

Thread类中的run()方法：

public void run() { 
        if (this.target != null) { 
            this.target.run();
        }
    }

继承并重写：

public class MyThread extends Thread {
        @Override
        public void run() {
            for (int i = 0;i < 10;i ++){
                System.out.println("myThread:" + this.getName());
            }
        }
    }

这样，我们得到的是一个Thread的子类，它能执行的任务就是我们指定的run()方法。（不需要传Runnable了。）

MyThread myThread = new MyThread();

#### 实现Callable的方式 ####

Callable是一个类似于Runnable的接口，里面也只有一个call方法：

![4][]

可以发现，call()与run()很类似，不同的是它有返回值，也可以抛出异常。那么可以理解为，call()是一个增强版的run()方法。

为了接收call()方法的返回值，Java设计了一个Future接口来专门做接收。

![5][]

现在，是不是就可以像使用run()一样，直接实现call()方法交给线程执行，然后使用Future来接收呢？很遗憾，并不行。因为线程它只认run()，不认call()啊。为了解决这个问题，JAVA设计了一个RunnableFuture的接口，同时继承了Runnable与Future，然后提供了一个RunnableFuture的实现类FutureTask。

![6][]

![7][]

由于FutureTask是实现了Runnable接口的，因此可以直接交给线程来执行；又由于它也实现了Future接口，因此可以直接接收到call()的返回值，两全其美。有人可能会问：为什么FutureTask没有实现Callable接口，而是将它作为一个成员变量呢？

回想一下我们使用Runnable的方式：

1.  自己写run()方法
2.  交给Thread执行。

现在我们使用Callable就稍微麻烦一些，需要经过FutureTask转手：

1.  自己写call()方法
2.  把call()方法交给一个FutureTask的实例
3.  把这个FutureTask实例交给一个Thread
4.  使用这个FutureTask实例获取返回的数据

//1.自己写call方法
    Callable<Object> c = new Callable<Object>() { 
        @Override
        public Object call() throws Exception { 
            int i = 0;
            for(;i < 10;i++) { 
                System.out.println("callable: " +Thread.currentThread().getName());
            }
            return i;
        }
    };
    //2.把call()方法交给一个FutureTask的实例 
    FutureTask<Object> task = new FutureTask<>(c);
    //3.把这个FutureTask实例交给一个Thread 
    Thread thread5 = new Thread(task);
    thread5.start();
    try { 
        //4.使用这个FutureTask实例获取返回的数据
        System.out.println(task.get());
    } catch (InterruptedException | ExecutionException e) { 
        e.printStackTrace();
    }

这样看就很明白了，call()方法和run()方法使用上也是差不多的，只是多了一道转交的手续。很容易想到，FutureTask的run()方法里肯定调用了call()方法。至于为什么不实现Callable接口，当然是因为call()要你自己根据任务去实现啦。

![8][]

一般来说，大多使用实现Runnable的方式，因为Java中接口是可以实现多个接口的，而继承只能有单继承，实现了Runnable接口的类还可以继承其他类，就等于可以把继承留给最需要的情况。同时，多个线程可以使用同一个Runnable，适合多个线程处理同一份资源的情况。至于Callable，实现起来比Runnable复杂，更适合需要获得返回值的情况。

参考资料：

[JAVA多线程的三种创建方式][JAVA]

[Callable与Runnable的区别及其在JDK源码中的应用][Callable_Runnable_JDK]

### 后记 ###

本来打算一篇把线程相关讲完的，考虑到篇幅的问题，只能先说到这了；剩下的线程状态与切换，以及线程的方法留到下一篇再说吧。

[Link 1]: https://fking.blog.csdn.net/article/details/105524780
[Link 2]: https://blog.csdn.net/u013007900/article/details/79620082
[Link 3]: https://blog.csdn.net/cout_sev/article/details/24745065?utm_medium=distribute.pc_relevant.none-task-blog-title-3&spm=1001.2101.3001.4242
[-]: https://blog.csdn.net/qq_42011541/article/details/102711196
[Link 4]: https://www.zhihu.com/question/23955356
[1]: /images/20221123/c6dc42d89320464c995d44c9e6275a50.png
[2]: /images/20221123/aa89a0b47cc54e6e8a0c0433b17ab845.png
[3]: /images/20221123/733d011be41743728f29d1bc43681ec5.png
[4]: /images/20221123/be848c409a8842b4b4cd51f91ed47478.png
[5]: /images/20221123/30a6dc3417a342f0a262479e31d7daa7.png
[6]: /images/20221123/16054a81ac7b471dbb8e5344f96b3ad8.png
[7]: /images/20221123/fea76fb91f2f416ebff26df689a3c950.png
[8]: /images/20221123/7452e25c8a2d4315b8fd5d830975a4b6.png
[JAVA]: https://blog.csdn.net/yangyechi/article/details/88079983?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param
[Callable_Runnable_JDK]: https://blog.csdn.net/hzw19920329/article/details/52383287?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~all~sobaiduend~default-3-52383287.nonecase&utm_term=%E4%B8%BA%E4%BB%80%E4%B9%88callable%E4%B8%8D%E8%83%BD%E7%9B%B4%E6%8E%A5%E8%A2%AB%E8%B0%83%E7%94%A8&spm=1000.2123.3001.4430