• 「MoreThanJava」 鼓吹的是 「学习，不止 CODE」，本系列 Java 基础教程是本人在联合各方面的常识之后，对 Java 根底的一个总回顾，旨在 「帮忙新敌人疾速高质量的学习」。
• 当然 不管新老朋友 我置信您都能够 从中获益。如果感觉 「不错」 的敌人，欢送 「关注 + 留言 + 分享」，文末有残缺的获取链接，您的反对是我后退的最大的能源！

写在后面

该文章的大部分内容都是翻译自是黑莓 10 实时操作系统 QNX Neutrino 的开发手册，该手册不仅具体地论述了 BlackBerry 10 OS 的原理以及 OS 的体系结构，还形容了其 QNX Neutrino 微内核的详细信息 (包含过程线程、多和解决、网络架构、文件系统等 … 十分残缺..)。

我浏览了其中「形容过程和线程」的精髓局部，感觉写的十分不错，特意翻译 (次要靠有道和 Google 翻译) 跟大家分享一下 (局部内容有改变)。

手册中详细描述了许多对于 Linux 函数调用波及底层方面的细节，在本文中我大都没有贴出来，感兴趣的敌人强烈建议去拜读一下原文！

• 原文地址：https://developer.blackberry….

Part 1. 过程和线程根底

在咱们开始探讨线程、过程、工夫片和所有其余的精彩的概念之前，让咱们先来建设一个类比。

我要做的首先是 阐明线程和过程是如何工作的。我能想到的最好的办法 (不波及实时零碎的设计) 是在某种状况下设想咱们的线程和过程。

过程就像一栋房子

房子实际上是 具备某些属性的容器 (例如卧室数量、占地面积、区域划分等)。

如果您以这个角度来看，房子实际上并不会被动做任何事件————它是一个 被动的对象。这实际上就是过程干的事件了 (充当容器)。

线程就像是居住者

寓居在房子外面的人是 流动的对象，他们能够应用各种房间，看电视、做饭、洗澡等等等 …

单线程

如果您独居过，那么您就会晓得————您能够在家里的任何工夫做您任何想做的事，因为家外面没有其他人，您只有听从心田的规定就好。

多线程

如果在您的房子中再另外增加一个人，状况将发生巨变。

假如您结婚了，那么当初您的家里住着您和您的配偶。因而您不能在 任何工夫 都可能应用厕所，因为您须要首先确保您的配合不在其中！

如果您有两个 负责任的成年人 寓居在屋宇中，那么通常您能够在 「安全性」 这一块儿略微放松一些 (因为您晓得另一个成年人会尊重您的空间，不会试图成心在厨房放火之类的..)。

然而，如果把几个 熊孩子 混在一起，事件就会变得更加乏味了 …

说回过程和线程

就像是屋宇占用土地一样，过程也要占用内存。

也正如屋宇拥有者能够随便进入他们想去的任何房间一样，过程中的线程也 都领有 对该内存区域拜访的权限。

如果某个线程被调配了某些货色 (例如哥哥过程进来买了游戏机???? 回家)，那么其余所有线程都能够立刻拜访它 (因为它存在于公共地址空间中————都在房子里)。

同样，如果给过程调配额定多的一块空间，则新的区域也可能用于所有线程。

这里的诀窍在于辨认内存是否应该对过程中的所有线程可用。

• 如果是，那么您将须要让所有线程同步它们对其的拜访。
• 如果不是，那么咱们将假设它只能用于某个特定的线程 (在这种状况下，因为只有特定线程可能拜访它，咱们能够在假如线程不会本人把本人玩儿坏的前提下，不须要同步操作)。

从日常的生存中咱们晓得，事件并不是那么简略。

当初咱们曾经理解了基本特征 (所有内容都是共享的)，上面咱们来深刻探索一下事件变得乏味的中央以及起因。

下图显示了咱们示意线程和过程的形式。过程是一个圆圈，代表“容器”概念（地址空间），三个长方形是线程。在本文中，您将看到相似这样的图。

互斥

在生活中，如果您想洗个澡，并且曾经有人在洗手间了，您将不得不期待。线程又是如何解决的呢？

这是通过一种叫做 互斥 (mutual exclusion) 的操作实现的。和你想的差不多——当波及到 特定资源 时，许多线程是互斥的。

当你想要独占浴室洗澡时，你通常会走进浴室，从外面锁上门。任何想要上厕所的人都会被锁挡住。当你洗完之后，你会打开门，容许其他人进入。

这就是线程的作用。一个线程应用一个叫做 互斥锁 (mutex) 的对象 (互斥锁 MUTual EXclusion 的首字母缩写)。这个对象就像门上的锁 —— 一旦一个线程锁定了互斥锁，其余线程就不能取得该互斥锁，直到领有它的线程开释它。就像门锁一样，期待取得互斥锁的线程将被阻挡。

互斥锁和门锁的另一个乏味的相似之处是，互斥锁实际上是一种 “倡议”锁 (“advisory”lock)。如果一个线程不恪守应用互斥锁的约定，那么爱护就没有用了。在咱们的房子比喻中，这就像有人不顾门和锁的常规，从一堵墙闯进盥洗室。

优先级

如果卫生间当初上锁了，有很多人在等着应用怎么办？显然，所有人都坐在里面，等着洗手间里的人进去。

真正的问题是：当门关上时会产生什么? 谁下一个去?

你会想，让等待时间最长的人下一个走或者是“偏心的”。又或者，让年龄最大的人排在第二位也可能是“偏心的”。有很多办法能够确定什么是“偏心”。

咱们通过两个因素来解决这个问题：优先级 和 期待的时长。

假如两个人同时呈现在锁着的浴室门口。其中一个有一个有急事 (例如：他们散会曾经早退了 …)，而另一个没有。让那个有急事的人去做下一个，不是很有意义吗？

当然！问题的要害是你如何决定谁更“重要”。

这能够通过调配优先级来实现 (咱们能够应用数字，例如 1 是最低的可用优先级，255 是这个版本的最高优先级)。房子中那些有急事的人将被给予更高的优先权，而那些没有急事的人将被给予较低的优先权。

线程也是一样。线程从父线程继承本人的调度算法，然而能够调用 Linux 零碎函数 pthread_setschedparam() 来更改本人的调度策略和优先级 (如果它有权限这么做的话)。

如果有很多线程在期待，并且互斥锁被解锁，咱们将把互斥锁给优先级最高的期待线程。然而，假如两个人有雷同的优先级。当初该做什么呢？

好吧，在这种状况下，让等待时间最长的人下一个去才是“偏心的”。这不仅是“偏心的”，也是内核理论所做的。在有一堆线程期待的状况下，咱们次要依据优先级，其次是期待的长度。

互斥锁当然不是咱们将遇到的惟一 同步对象。让咱们看看其余一些例子。

信号量

让咱们从浴室转到厨房，因为那里是一个社会认可的能够同时包容一个人以上的中央。在厨房里，你可能不想让每个人都同时待在那里。事实上，你可能想要限度厨房里的人数 (厨师太多等等 …)。

假如你不心愿同时有 超过两个人 在外面，这能够应用互斥锁来实现吗？这对于咱们的类比来说是一个十分乏味的问题。让咱们略微讨论一下。

计数为 1 的信号量

在下面类比的卫生间的例子中，能够有两种状况，并且两种状态互相关联:

• 门没锁，房间里没人；
• 门锁了，房间里有人；

这里并没有其余可能的组合 —— 房间里没有人的时候门不能锁上 (咱们怎么能关上它?)，房间里有人的时候门也不能关上 (他们怎么能保障本人的隐衷呢?)。这是一个计数为 1 的信号量示例：房间中最多只能有一个人，或者有一个线程应用该信号量。

这里的要害是咱们形容锁的形式。

在你典型的浴室锁里，你只能从外面上锁和解锁 (没有能够从内部拜访的锁)。实际上，这意味着互斥锁的所有权是一个原子操作 —— 在你取得互斥锁的过程中，其余线程不可能取得它，后果就是一个线程进入 “ 厨房 ” 上锁，导致另一个线程将无奈进入。在咱们用房子来比喻的故事里，这一点就不那么显著了，因为人类比 1 和 0 聪慧得多。

很显然，咱们厨房须要的是一种不同类型的锁。

计数大于 1 的信号量

假如咱们在厨房装置了传统的基于钥匙的锁。这把锁的工作原理是，如果你有一把钥匙，你就能够开门进去。任何应用这把锁的人都批准，当他们进入外部时，他们将立刻从外部锁门，这样，任何在内部的人都将始终须要一把钥匙。

好了，当初管制咱们想要多少人在厨房就变成一件简略的事件了 —— 把两把钥匙挂在门外！厨房总是锁着。当有人想进厨房时，他们要看是否有钥匙挂在门外。如果是的话，他们就把它带在身边，关上厨房的门，走进去，用钥匙锁门。

因为进入厨房的人必须在他们进入厨房时带着钥匙，所以咱们通过限度门外挂钩上可用的钥匙数量来间接管制容许进入厨房的人数。

对于线程，这是通过 信号量 来实现的。“一般”信号量就像互斥锁一样工作 —— 你要么领有互斥锁，在这种状况下你能够拜访资源，要么不领有，在这种状况下你不能拜访资源。咱们方才在厨房中形容的信号量是一个计数信号量 —— 它跟踪计数 (依据线程可用的 “ 钥匙 ” 的数量)。

作为互斥锁的信号量

咱们方才问了这样一个问题:“能够用互斥锁来实现吗?”对于应用互斥锁实现计数，答案是否定的。反过来怎么样？咱们能够应用信号量作为互斥锁吗？

当然能够！事实上，在某些操作系统中，这正是它们所做的 —— 它们没有互斥锁，只有信号量！那么，为什么要为互斥锁费神呢？

要答复这个问题，先看看你的洗手间。你房子的建造者是如何实现“互斥锁”的？我敢肯定你家的厕所里面并没有挂在墙上的钥匙！

互斥锁是一种“非凡用处”的信号量。如果您心愿在代码的特定局部中运行一个线程，那么互斥是目前为止最无效的实现。

(事实上文章的后续介绍了其余同步计划——称为 condvars、barrier 和 sleepons，这些就是 Java 中同步计划的操作系统层面的原型，感兴趣的能够自行去浏览一下.. 差异不大，只不过应用的是操作系统层面的形容 …)

为了防止混同，请意识到 互斥锁还有其余属性 ，比方 优先级继承 ，这是它与 信号量 的区别。

Part 2. 内核的作用

房子的类比很好地解释了同步的概念，然而它在另一个次要畛域是解释不通的。在咱们家里，有许多 “ 线程 ” 是同时运行的。然而，在一个实在的实时零碎中，通常只有一个 CPU，所以一次只能运行一个“货色”。

单核 CPU

让咱们看看在现实情况中会产生什么，特地是在零碎中 只有一个 CPU 的状况下。在这种状况下，因为只有一个 CPU，因而在 任何给定的工夫点只能运行一个线程。内核决定 (应用一些规定，咱们将很快看到) 到底该运行哪个线程。

多核 CPU (SMP)

如果您购买的零碎具备多个雷同的 CPU，它们都共享内存和设施，那么您将领有一个 SMP box (SMP 代表对称的多处理器，“对称的”局部示意零碎中的所有 CPU 都是雷同的)。在这种状况下，能够并发 (同时) 运行的线程数量受到 CPU 数量的限度。(实际上，单处理器机箱也是如此!) 因为每个处理器一次只能执行一个线程，因而如果有多个处理器，多个线程就能够同时执行。

当初让咱们先疏忽 CPU 的数量 —— 一个有用的形象是把零碎设计成多线程同时运行的样子，即便事实并非如此。(稍后，在“应用 SMP 时要留神的事件”一节中，咱们将看到 SMP 的一些非直观影响 …)

内核作为仲裁程序

那么，在任何给定的时刻，谁来决定哪个线程将运行？这是内核的工作。

内核确定在特定时刻应该应用 CPU 的线程，并将上下文切换到该线程。让咱们钻研一下内核对 CPU 做了什么。

CPU 有许多寄存器 (确切的数目取决于处理器家族，例如，x86 对 MIPS，以及特定的家族成员，例如，80486 对 奔流)。当线程运行时，信息存储在这些寄存器中 (例如，以后程序地位)。

当内核决定另一个线程应该运行时，它须要:

1. 保留以后运行线程的寄存器和其余上下文信息；
2. 将新线程的寄存器和上下文加载到 CPU 中；

然而内核如何决定应该运行另一个线程呢？ 它会查看某个特定线程此时是否可能应用该 CPU。例如，当咱们谈到互斥锁时，咱们引入了一种 阻塞状态 (当一个线程领有互斥锁，另一个线程也想取得它时，就会产生这种状况; 第二个线程将被阻塞)。

因而，从内核的角度来看，咱们有一个线程能够耗费 CPU，而另一个线程因为被阻塞而不能期待互斥锁。在这种状况下，内核让能够运行的线程耗费 CPU，并将另一个线程放入一个外部列表 (以便内核能够跟踪它对互斥锁的申请)。

显然，这不是一个很乏味的状况。假如有许多线程能够应用该 CPU。还记得咱们基于优先级和期待长度来委托对互斥的拜访吗？内核应用相似的计划来确定下一个将运行哪个线程。有两个因素：优先级 和 调度算法，基于此程序评估。

优先级

思考两个可能应用 CPU 的线程。如果这些线程具备不同的优先级，那么答案真的很简略 —— 内核将 CPU 调配给优先级最高的线程。正如咱们在探讨取得互斥锁时提到的，优先级是从 1 (可用性最低的) 开始的。

留神，优先级为零是为闲暇线程保留的 —— 您不能应用它。 (如果您想晓得您的零碎的最小值和最大值，能够应用 Linux 的零碎函数 sched_get_priority_min() 和 sched_get_priority_max() —— 它们的原型被定义在 <sched.h> 中。咱们假如 1 是最低可用性，255 是最高可用性。)

如果另一个具备更高优先级的线程忽然可能应用 CPU，内核将立刻上下文切换到更高优先级的线程。咱们称之为 抢占 —— 高优先级线程抢占了低优先级线程。当高优先级线程实现时，内核上下文切换回之前运行的低优先级线程，咱们称之为 复原 —— 内核持续运行前一个线程。

当初，假如有两个线程可能应用 CPU，并且具备完全相同的优先级。

调度算法

让咱们假如其中一个线程以后正在应用该 CPU。在本例中，咱们将钻研内核用于决定何时进行上下文切换的规定。(当然，这整个探讨实际上只实用于具备雷同优先级的线程)

内核有两种次要调度算法 (策略)：轮询调度 (或简称“RR”) 和 FIFO (先入先出)。

FIFO(First In First Out，先进先出)

在 FIFO 调度算法中，容许线程始终应用 CPU (只有它想要应用)。这意味着，如果该线程正在进行十分长的数学计算，并且没有其余具备更高优先级的线程筹备好，那么该线程可能会永远运行上来。那么具备雷同优先级的线程呢？它们也被锁在里面了。(显然，此时低优先级的线程也被锁定。)

如果正在运行的线程放弃或被迫放弃 CPU，那么内核将查找 具备雷同优先级、可能应用该 CPU 的其余线程。如果没有这样的线程，那么内核将寻找可能应用 CPU 的低优先级线程。

留神，术语 “被迫放弃 CPU” 可能意味着两种状况。

如果线程进入睡眠状态，或者在信号量上阻塞，那么是的，一个低优先级的线程能够运行 (如上所述)。

然而还有一个 “非凡”调用，sched_yield() (基于内核调用 SchedYield())，它仅将 CPU 让给另一个具备雷同优先级的线程 —— 如果高优先级的线程曾经筹备好运行，那么低优先级的线程将永远不会有机会运行。如果一个线程的确调用了 sched_yield()，并且没有其余具备雷同优先级的线程筹备运行，那么原始线程将持续运行。实际上，sched_yield() 用于在 CPU 上对另一个具备雷同优先级的线程进行拜访。

在上面的图中，咱们看到三个线程在两个不同的过程中运行:

如果咱们假如线程“A”和“B”曾经筹备好了，线程“C”被阻塞了 (可能在期待互斥)，线程“D”(没有显示) 正在执行，那么内核保护的就绪队列的一部分看起来是这样的：

这显示了内核的 外部就绪队列，内核应用它来决定下一步调度谁。留神，线程“C”没有在就绪队列中，因为它被阻塞了；线程“D”也没有在就绪队列中，因为它正在运行。

轮循(Round Robin)

RR 调度算法 与 FIFO 雷同，只是如果有另一个具备雷同优先级的线程，则该线程不会永远运行。它只对系统定义的工夫片运行，您能够应用函数 sched_rr_get_interval() 来确定工夫片的值。工夫片通常为 4 毫秒，但实际上是 ticksize 的 4 倍，您能够查问或应用 ClockPeriod() 设置 ticksize。

理论产生的状况是，内核启动一个 RR 线程，并记录时间。如果 RR 线程运行了一段时间，调配给它的工夫就会超时 (工夫片曾经过期)。内核查看是否有另一个具备雷同优先级的线程曾经筹备好了。如果有，内核运行它。如果没有，那么内核将持续运行 RR 线程 (内核授予线程另一个工夫片)。

让咱们总结一下 调度规定 (对于单个 CPU)，按重要性排序:

• 一次只能运行一个线程。
• 最高优先级的就绪线程将运行。
• 线程将始终运行，直到阻塞或退出。
• RR 线程将运行它的工夫片，而后内核将重新安排它 (如果须要)。

上面的流程图显示了内核做出的决策：

对于多 CPU 零碎，规定是雷同的，除了多个 CPU 能够并发地运行多个线程。线程运行的程序 (在多个 CPU 上运行哪些线程) 的确定办法与在单个 CPU 上完全相同 —— 最高优先级的就绪线程将在一个 CPU 上运行。对于优先级较低或等待时间较长的线程，内核在安顿它们以防止缓存应用效率低下方面具备肯定的灵活性。

内核状态

咱们始终在松散地探讨“运行”、“就绪”和“阻塞”—— 当初让咱们更加深刻地来探讨这些线程状态。

运行态（RUNNING）

运行状态仅仅意味着线程正在踊跃地耗费 CPU。在一个 SMP 零碎上，会有多个线程在运行; 在单处理器零碎中，只有一个线程在运行。

就绪态（READY）

就绪状态意味着这个线程当初就能够运行 —— 但它不会立即运行，因为另一个线程 (具备雷同或更高优先级) 正在运行。如果两个线程可能应用 CPU，一个线程优先级为 10，一个线程优先级为 7，那么优先级为 10 的线程将正在运行，优先级为 7 的线程将准备就绪。

阻塞状态（BLOCKED）

咱们把阻塞状态称为什么？问题是，阻塞状态并不只有一个。在内核的作用下，实际上有超过 12 种阻塞状态。

为什么那么多？因为内核会跟踪线程被阻塞的起因。

咱们曾经看到了两种阻塞状态 —— 当一个线程被阻塞期待互斥锁时，这个线程处于互斥锁状态；当线程被阻塞期待信号量时，它处于 SEM 状态。这些状态只是表明线程阻塞在哪个队列 (和哪个资源) 上。

如果在一个互斥锁上阻塞了许多线程 (处于互斥锁阻塞状态)，内核不会留神到它们，直到领有该互斥锁的线程开释它。此时，阻塞的一个线程曾经准备就绪，内核将做出从新调度决策 (如果须要)。

为什么说“如果须要”呢？刚刚开释互斥锁的线程可能还有其余事件要做，并且比期待的线程有更高的优先级。在本例中，咱们应用第二个规定，即“最高优先级的就绪线程将运行”，这意味着调度程序没有扭转 —— 高优先级线程持续运行。

内核状态，残缺的列表

上面是内核阻塞状态的残缺列表，并简要阐明了每个状态。顺便说一下，这个列表能够在 \<sys/neutrino.h> —— 你会留神到所有的状态都以 STATE_ 作为前缀 (例如，这个表中的“READY”在头文件中以 STATE_READY 的模式列出)：

须要记住的重要一点是，当一个线程被阻塞时，无论它处于何种状态，它都不会耗费 CPU。相同，线程耗费 CPU 的惟一状态是运行状态。

Part 3. 线程和过程

让咱们从实在的实时零碎的角度回到对线程和过程的探讨。

咱们晓得一个过程能够有一个或多个线程。(一个没有线程的过程将不能做任何事件 —— 也就是说，没有人在家执行任何有用的工作。) 一个零碎能够有一个或多个过程。(同样的探讨也实用于 —— 一个没有任何过程的零碎不会有任何作用。)

那么这些过程和线程是做什么的呢？最终，它们造成一个零碎 —— 执行某个指标的线程和过程的汇合。

在最高档次上，零碎由许多过程组成。每个过程都负责提供某种性质的服务 —— 无论是文件系统、显示驱动程序、数据采集模块、管制模块，还是其余什么。

在每个过程中，可能有许多线程。线程的数量是不同的。一个只应用一个线程的过程能够实现与另一个应用五个线程的过程雷同的性能。有些问题自身是多线程的，实际上解决起来绝对简略，而其余过程自身是单线程的，很难实现多线程。

如何用线程进行设计的话题很容易就会被另一本书占用 —— 在这里咱们只关注基础知识。

为什么须要多个过程？

那么为什么不让一个过程领有有数线程呢？尽管有些操作系统强制你这样编码，但将事件分解成多个过程的益处有很多:

• 拆散和模块化；
• 可维护性；
• 可靠性；

将问题“合成”成几个独立问题的能力是一个弱小的概念。它也是零碎的外围。一个零碎由许多独立的模块组成，每个模块都有肯定的职责。这些独立的模块是不同的过程。QSS 的人员应用这个技巧来开发独立的模块，而不须要模块相互依赖。模块之间惟一的“依赖”是通过大量定义良好的接口实现的。

因为不足相互依赖关系，这天然会加强可维护性。因为每个模块都有本人的特定定义，所以修复一个模块相当容易 —— 尤其是在它不绑定到任何其余模块的状况下。

然而，可靠性可能是最重要的一点。过程就像房子一样，有一些定义明确的“边界”。住在房子里的人很分明本人什么时候在房子里，什么时候不在房子里。一个线程有一个很好的想法 —— 如果它在过程中拜访内存，它能够存活。如果它超出了过程地址空间的范畴，它就会被杀死。这意味着运行在不同过程中的两个线程能够无效地互相隔离。

过程地址空间由零碎的过程管理器模块保护和执行。当一个过程启动时，过程管理器会调配一些内存给它，并启动一个正在运行的线程。内存被标记为该过程所领有。

这意味着如果过程中有多个线程，内核须要在它们之间进行上下文切换，这是一个十分高效的操作 —— 咱们不须要扭转地址空间，只须要扭转哪个线程在运行。然而，如果咱们必须切换到另一个过程中的另一个线程，那么过程管理器就会染指并导致地址空间的切换。不必放心，尽管在这个额定的步骤中会有一些额定的开销，然而在零碎的作用下依然是十分快的。

如何启动一个过程

当初让咱们将注意力略微转向可用于解决线程和过程的函数调用。任何线程都能够启动一个过程；惟一施加的限度是那些来自根本安全性的限度 (文件拜访、特权限度等)。

想要启动一个过程大略有以下几种办法 (具体的细节咱们在这里不介绍)：

1. 命令行启动；
2. 应用 system() 函数调用启动：这是最简略的，间接在命令行输出就能够。实际上，system() 启动了一个外壳程序来解决您要执行的命令；
3. 应用 exec() 系列函数 和 spawn() 函数调用启动：当一个过程收回 exec() 函数，则该过程进行运行以后程序，并开始运行另一个程序；过程 ID 没有扭转 ——— 过程变成了另一个程序；而调用 spwan() 函数则会创立另一个过程 (带有新的过程 ID)，该过程与函数的参数中指定的程序绝对应。
4. 应用 fork() 调用启动：齐全复制以后过程，所有代码都是雷同的，数据也与创立 (或父) 过程的数据雷同。有意思的是，当您调用 fork() 时，您创立了另一个过程，该过程在雷同的地位执行雷同的代码，两个过程都将从 fork() 调用中作为父过程返回。(感兴趣的同学能够自行搜寻一下 …)
5. 应用 vfork() 调用启动：与一般 fork() 函数相比，vfork() 函数的资源耗费要少得多，因为它共享父线程的地址空间。vfork() 函数创立一个子线程，而后挂起父线程，直到子线程调用 exec() 或退出。另外，vfork() 能够在物理内存模型零碎上工作，而 fork() 不能 —— fork() 须要创立雷同的地址空间，这在物理内存模型中是不可能的。

如何启动线程

当初咱们曾经理解了如何启动另一个过程，让咱们看看如何启动另一个线程。

任何线程都能够在同一过程中创立另一个线程。没有任何限度 （当然，内存空间有余除外！）。最常见的办法是通过 POSIX pthread_create() 调用：

#include <pthread.h>

int
pthread_create (pthread_t *thread,
                const pthread_attr_t *attr,
                void *(*start_routine) (void *),
                void *arg);

• 参数细节和更多线程治理的内容这里就不探讨了..

线程是个好主见

有两类问题，线程的利用是一个好主见。

• 并行化操作，如计算许多数学问题 (图形、数字信号处理等 …)；
• 共享数据执行几个独立的性能，如服务器同时服务多个客户；

第一类问题很容易了解，把同一个问题分成四份并让四个 CPU 同时计算，这当然感觉会快上不少。

第二类问题略微麻烦一些，咱们借助网络中一台「计算图形后果并发往远端的节点」用来演示，并进一步阐明「为什么单核 CPU 零碎应用多线程依然是一个好主见」。

假如咱们有一个程序，须要先计算图形的局部 (假如应用 “C” 示意)，而后须要传输到远端 (假如应用 “X” 示意)，并最终期待远端回应做下一步操作 (假如应用 “W” 示意)，以下就是该程序在单核 CPU 下的应用状况：

等一下！这节约了咱们许多贵重的可用于计算的工夫！因为期待远端回复的过程，CPU 做的仅仅是 “ 期待 ” 而已..

如果咱们应用多线程，应该能够更好地利用咱们的 CPU，对吗？

这样好得多，因为当初，即便第二个线程花了一些工夫期待，咱们也缩小了计算所需的总工夫。

咱们能够来简略计算一下。假如咱们计算的工夫记为 T_计算 ，发送和期待的工夫别离记为：T _发送 和 T _期待。那么在第一种状况下，咱们的总运行工夫为：

（T_计算 + T _发送 + T _期待 ）x 工作数量

而应用两个线程：

(T_计算 + T _发送 ) x 工作数量 + T _期待

间接缩小了：

T_期待 x ( 工作数量 – 1)

请留神，咱们速度最终还是受到以下因素的决定：

T_计算 + T _发送 x 工作数量

因为咱们必须至多进行一次残缺的计算，并且必须将数据传输到硬件之外 —— 只管咱们能够应用多线程笼罩计算周期，但只有一个硬件资源能够传输。

当初，咱们创立一个四线程的版本，并且在 4 核的零碎上运行它，那么咱们最终将失去如下图示的后果：

请留神，四个 CPU 的每个利用率均未失去充分利用 (如图示 “ 利用率 ” 中的灰色矩形所示)。上图中有两个乏味的区域。当四个线程启动时，它们各自进行计算。不过，当线程在每次计算实现时，它们都在抢夺传输硬件 (图中的 “X” 局部 —— 一次只能进行一次传输)。这算是在启动局部给了咱们一个小异样。一旦线程通过此阶段，因为传输工夫比计算周期的 1/4 小得多，因而它们天然会与传输硬件同步。首先，疏忽小异样，该零碎的特色在于以下公式：

（T_计算 + T _发送 + T _期待 ）x 工作数量 / CPU 数量

该公式指出，在四个 CPU 上应用四个线程将比咱们刚开始应用的单线程模型快大概 4 倍。

通过联合从简略领有多线程单处理器版本中学到的常识，咱们天经地义地心愿领有更多的 CPU 运行更多的线程，以便多余的线程能够“排汇”发送确认期待 （和发送信息） 中的闲暇的 CPU 工夫。

然而你尝试像我这样画一下 8 核 8 线程的状况，你就会留神到一些神奇的事件：咱们依然会遭逢利用率有余的状况，并且会发现 CPU 处于 “ 停滞期待 ” 状态的可能同时会有很多个。

这给了咱们一个很重要的教训 —— 咱们不能简略的减少 CPU 以倍速咱们的运算速度。

咱们心愿越来越快，但存在许多限度因素。在某些状况下，这些限度因素仅受多 CPU 主板的设计 —— 当许多 CPU 尝试拜访雷同的内存区域时，会产生多少内存和设施争用。

只管多线程多核给咱们带来了许多益处，但 “ 更加简单的环境 ” 也让咱们面临更多的艰难和挑战。能够参考咱们类比的例子，在生活中，你面临的状况如果认真思考和列举的话，那将会是如许简单 …. 这里也不开展讲了

总结

置信看完的敌人都可能对过程和线程进一步加深印象.. 过程像房子，线程像住户，十分深入人心！

原文章的后半程还具体地介绍了很多线程同步的更多内容，波及 Linux 底层的函数调用，再前面一个章节还具体地介绍了过程间的通信相干的内容，感兴趣的童鞋，请移步原文！

• 本文已收录至我的 Github 程序员成长系列 【More Than Java】，学习，不止 Code，欢送 star：https://github.com/wmyskxz/MoreThanJava
• 集体公众号 ：wmyskxz， 集体独立域名博客：wmyskxz.com，保持原创输入，下方扫码关注，2020，与您独特成长！

非常感谢各位人才能 看到这里 ，如果感觉本篇文章写得不错，感觉 「我没有三颗心脏」有点货色 的话， 求点赞，求关注，求分享，求留言！

创作不易，各位的反对和认可，就是我创作的最大能源，咱们下篇文章见！