Linux 线程实现机制分析
linux基于线程通信技术聊天室的设计与实现 -回复
linux基于线程通信技术聊天室的设计与实现-回复Linux基于线程通信技术聊天室的设计与实现聊天室是一种常见的在线交流工具，它允许用户在不同地点之间进行实时对话。
为了实现一个基于线程通信技术的Linux聊天室，我们可以选择使用已有的进程间通信（IPC）机制中的一种，例如共享内存或消息队列。
本文将一步一步回答有关该主题的问题，为您介绍如何设计并实现一个Linux聊天室。
第一步：确定需求和设计目标在开始设计之前，我们需要明确聊天室的需求和设计目标。
在这里，我们希望实现一个具有以下特点的聊天室：1. 实时通信：聊天室应该能够在用户之间进行实时的消息传递。
2. 多用户支持：聊天室应该允许多个用户同时登录和交谈。
3. 可扩展性：聊天室应该可以轻松地添加更多的用户和功能，以适应不同的需求。
4. 兼容性：聊天室应该支持Linux操作系统，并能够在不同的平台上运行。
第二步：选择合适的线程通信技术在设计线程通信聊天室时，我们可以选择使用多种IPC机制，如共享内存、消息队列、命名管道等。
根据聊天室的设计目标，我们可以选择使用共享内存和消息队列来实现聊天室的通信功能。
共享内存允许多个进程访问同一块内存区域，从而实现数据的共享。
通过在内存中创建一个共享缓冲区，我们可以在其中存储消息数据，并通过读写指针来实现消息的传递。
每个用户可以通过从共享内存中读取数据来接收其他用户发送的消息，并可以通过写入数据到共享内存来发送自己的消息。
消息队列是另一种常用的IPC机制，它可以实现进程之间的异步通信。
通过创建一个消息队列，每个用户可以将自己的消息发送到队列中，并从队列中接收其他用户发送的消息。
这种方式比共享内存更灵活，可以轻松地实现多用户的消息传递。
在这里，我们可以选择使用共享内存来存储聊天室的消息数据，并使用消息队列来处理消息的传递。
第三步：设计线程通信聊天室的架构在设计聊天室的架构时，我们需要考虑以下几个方面：1. 服务器：设计一个服务器线程，用于接收和处理用户的连接请求，并将消息分发给其他在线用户。
线程的三种实现方式
线程的三种实现方式线程是操作系统能够进行运算调度的最小单位，是进程中的一个实体，是被系统独立调度和执行的基本单位。
线程有三种实现方式，分别是用户级线程、内核级线程和轻量级进程。
下面将详细介绍这三种实现方式。
一、用户级线程（User-Level Threads，ULT）用户级线程是完全由用户程序实现和控制的线程。
用户级线程的创建、销毁和切换是通过用户程序的函数调用来完成的，与操作系统无关，不需要进行内核态和用户态之间的切换，由线程库在用户空间进行管理。
每当用户级线程调用了一个阻塞的系统调用，整个进程都会被阻塞住。
用户级线程的优点是实现上比较简单，可以根据具体应用的需要进行灵活的线程管理，而且切换线程的开销比较小。
缺点是由于用户级线程无法通过系统调用进行I/O操作，因此当一个线程阻塞时，整个进程都会被阻塞住，无法充分利用多核处理器的并行性能。
二、内核级线程（Kernel-Level Threads，KLT）内核级线程是由操作系统内核实现和管理的线程，调度、创建和销毁线程都在操作系统内核中完成，需要进行内核态和用户态之间的切换。
每个内核级线程都有自己的控制块，操作系统根据调度策略来调度线程的执行。
内核级线程的优点是能够充分利用多核处理器的并行性能，因为线程的调度都由操作系统内核完成。
缺点是创建和切换线程的开销比较大，会降低系统的整体性能。
三、轻量级进程（Lightweight Process，LWP）轻量级进程是一种中间形式的线程，在用户空间和内核空间的线程实现方式之间进行折中。
轻量级进程由用户程序创建和管理，但是它的创建、销毁和切换都是由操作系统内核来完成的，使用内核级线程实现线程的调度。
轻量级进程的优点是能够充分利用多核处理器的并行性能，同时由于线程的创建和切换都由操作系统内核完成，因此能够更好地支持I/O操作，不会出现用户级线程阻塞导致整个进程阻塞的情况。
缺点是由于需要进行内核态和用户态之间的切换，创建和切换线程的开销比用户级线程大，但是相比于内核级线程来说要小得多。
linux基于线程通信技术聊天室的设计与实现 -回复
linux基于线程通信技术聊天室的设计与实现-回复Linux基于线程通信技术聊天室的设计与实现1. 引言(100字)在当今互联网时代，聊天室成为人们分享信息和交流思想的重要工具。
本文将介绍如何利用Linux中的线程通信技术实现一个基于线程通信的聊天室。
2. 设计与实现概述(200字)为了实现基于线程通信的聊天室，我们需要使用Linux中的线程库和进程间通信机制。
我们将设计一个多线程的服务器端和多线程的客户端，服务器端用于接收和处理客户端的请求，客户端用于向服务器发送消息和接收其他客户端的消息。
3. 服务器端设计与实现(500字)服务器端首先需要创建一个主线程，用于监听与接收客户端的连接请求。
一旦有客户端连接请求到达，主线程将创建一个新的工作线程，处理该客户端的请求。
在服务器端，我们可以使用线程锁和条件变量等线程同步机制，防止多个线程并发访问共享资源，实现线程间的安全通信。
我们可以创建一个线程池，用于管理工作线程，当有新的连接请求到达时，从线程池中获取一个空闲的线程进行处理。
我们使用线程锁来保护线程池中线程的访问，确保在某一时刻只有一个线程可以获取到线程资源。
为了实现服务器与客户端的实时通信，我们可以使用Linux中的socket 编程接口。
服务器将创建一个socket，绑定到特定的IP地址和端口上，然后开始监听来自客户端的连接请求。
一旦有连接请求到达，服务器将接受该连接并创建一个新的线程来处理客户端请求。
服务器通过socket接口读取客户端发来的消息，再将消息广播给其他连接到服务器的客户端。
4. 客户端设计与实现(500字)客户端需要创建一个连接到服务器端的socket，并提供用户界面用于发送和接收消息。
客户端主线程需要同时处理用户输入和服务器发来的消息。
客户端需要使用线程同步机制，确保在用户输入消息时，不会和服务器发来的消息产生竞争。
我们可以使用互斥锁来保护消息队列，当用户输入消息时，需要先获取互斥锁以确保消息队列的一致性。
跟我学Linux编程-12-多线程编程-同步
多线程编程-同步在上一章节中，我们通过程序示例，见证了单线程世界中不可能发生的事件（一个数既是奇数又是偶数）在多线程环境中是怎样分分钟发生的，我通过细分程序执行步骤，分析了奇异事件发生的过程，并探明了其原因：一个线程在对全局变量gcnt进行两次判读的过程中，另一个线刚好改变了这个变量的值。
在多线程编程术语中，称这两个线程同时进入了临界区域。
所谓临界区域，是指多线程环境下两个及以上线程同时执行可能会导致冲突的一段代码。
在上一章节的示例中，这几行代码就是一个临界区域：gcnt++;if (gcnt % 2){if (!(gcnt % 2)) printf("[%d] : %d\n", id, gcnt);}冲突之所以会发生，是因为临界区域的代码，通常需要很多个CPU指令周期才能完成，其运行过程随时可能被打断(进行了线程调试)，CPU去运行另外的线程，如果这个线程刚好也进入了临界区域，则异常的程序状态极可能会发生。
如果当某个线程进入临界区域，在其退出区域之前，其他的线程无论如何也不能进入该区域，那么冲突就不会发生。
Linux提供了这种保证多线程进入临界区域互斥的机制，这正是本章节所要介绍的内容：线程锁。
我们今天的示例程序还是在上一章节的示例上改进而来的，我们的任务就是使用线程锁，保证“一个数既是奇数又是偶数”的奇异事件在多线程环境下也不发生，代码如下：#include <pthread.h>#include <stdio.h>#include <unistd.h>int gcnt = 0;pthread_mutex_t g_mutex;void *thread_task(void *arg){int id = (int)arg;while (1){pthread_mutex_lock(&g_mutex);gcnt++;if (gcnt % 2)if (!(gcnt % 2)) printf("[%d] : %d\n", id, gcnt);}pthread_mutex_unlock(&g_mutex);usleep(1);}return NULL;}int main(int argc, char *argv[]){pthread_t thr;pthread_mutex_init(&g_mutex, NULL);pthread_create(&thr, NULL, thread_task, (void *)1);pthread_create(&thr, NULL, thread_task, (void *)2);thread_task((void *)0);return 0;}今天的程序相对于上章的代码，改动非常小，只添加了四行，已使用红色加粗标注。
Linux下的多线程机制的分析与实现
Ｌｎｘ下 的多 线程 机 制 的分 析 与实现 ｉｕ
赵 东 ，周 卫 云２ ，赵 作人 ３
１０３ ；． ３０２２ 长春广顺 电子科技有 限公 司 ， 长春 吉林 １６３） １０４ １０２ ； ３０１ （． １长春 师范学 院计算机科 学与技 术学 院 ， 吉林长春
ｖｉ ＊ａ ：调 用此 函数 可以创建一 个新 的线程 ，新 线程创建 后执行 ｓｌ一ｒ ｔｅ ｏ ｄ ） ，￣ ｏ ｉ 指定 的程序 。其 中参数 ａｒ ｔ ａ ｕｎ ｔ ｔ 是 用户希望 创建线 程的属性 ，当为 Ｎ Ｌ Ｕ Ｌ时表示 以默认 的属性 创建 线程 。ａｇ 向 ｓｒ ｒ ｔｅ传递 的参数 。 ｒ是 ｔｔ ｏ ｉ ａ ｕｎ
Ｉ ｔｐｈ ｅ ｄ ｎ ｔｒａ ｐｈ ｅ ｄ ｔｒ ａ
—
—
ｊｉ ｐｈｅｄ—ｔｈ ａ ，ｖｉ ＊ ＊ｓ ｔ ） ｏ ｎ（ｔｒ ａ ｒｄ ｏ ｔｅ ｄ ｔｕ ：这 个 函数 的作 用 是 等待 一 个 线 程 的结 束 。调用 ａｓ ｄｔ ｈ（ｔｅｄ～ｔ ｔｅｄ ：参数 ｐ ｒ ｄ 表的线 程一 旦终 止 ，立 即释放 调该线 程 占有 的所 ｅｃ ｐ ｒ ａ ｈ ａ ｈ ａ） ｐｒ ｔｅ 代 ｈａ
的指 针 。
２ ２ 线程控 制 函数 ．
ｐｈ ｅ ｄ ｔｒａ
—
ｓｌ ｖｉ） － ｅ ｆ（ｏ ：为了区 分线 程 ，在 线程 创 建 时 系统 为 其分 配 一个 唯一 的 Ｉ 号 ，由 ｐ ｒ ｄ ｄ Ｉ ） ｔｅ ｈａ
—
ｃｅ ｅ ｒ ａｔ
（ ）返 回给 调用者 ，也可 以通 过 ｐ ｒ ｄ ｓｌ ）获取 自己的线 程 Ｉ。 ｔｅ — ｅ ｈａ ｆ（ Ｄ
究。
・
３６ ・
Linux线程机制研究
中期 。现在 ， 多线 程 技术 已经被 许多 操 作 系统 所支
持 ， 括 Ｗｉｄ ｗｓＮＴ／ Ｏ ０和 Ｌｎ ｘ 包 ｎｏ ２０ ｉｕ 。
在 Ｌｎ ｘ ２ ２内核 中， 程 是 通 过 系 统 调 用 ｉｕ ． 进
ｆｒ ｏ ｋ创 建 的 ， 的进 程是 原 来进 程 的 子进 程 。需要 新
Ｒｅ ｅ ｒ ｈ ｏ ｎｕ ｒ ａ ｅ ｈ ｎｉ ｍ ｓ ａ ｃ ｎ Ｌｉ ｘ Ｔｈ ｅ ｄｓ Ｍ ｃ ａ ｓ
ＬＥＩＭ ｉ ｇ— ｈ ＺＨＡＮＧ ｎｇ ｎ ｚ ｅ， Ｙｏ
（ ｒｈ Ａｕ ｏ ｔ ｎ ｒ ｌＴｅ ｈ ｉ ｕ ｓａ ｃ ｎ ｔ ｕ ｅ Ｔａ ｙ ａ ３ ０ ６ Ｃｈ ｎ Ｎｏ ｔ ｔ ｍａ ｉ Ｃｏ ｔｏ ｃ ｎ ｑ ｅＲｅ ｅ ｒ ｈ Ｉ ｓｉ ｔ ， ｉ ｕ ｎ ０ ０ ０ ， ｉ ａ） ｃ ｔ
Ｌ ｎ ｘ进 入企业级 市 场的一 大因素 。 ｉｕ Ｌ ｎ ｘ ２ ４内核 消 除 了 这个 限 制 ， 且 允 许 在 ｉｕ ． 并 系统运 行 中动 态调整 进程数 上 限。 因此 ， 进程数 现在
绪、 阻塞 和运行 三种基本 状态 。
说 明的是 ， Ｌ ｎ ｘ ２ ２ Ｘ中， 存在 真正 意义 上 的 在 ｉｕ ． ． 不
线 程 ， ｉｕ Ｌｎ ｘ中常 用 的线 程 Ｐ ｈｅ ｄ实 际 上 是 通 过 ｔｒａ 进程 来模拟 的 。 就是说 ， ｉｕ 也 Ｌ ｎ ｘ中的线 程也是 通过 ｆｒ ｏｋ创建 的 ， 轻” 程 。Ｌ ｎ ｘ２ ２缺 省 只允许 ４ 是“ 进 ｉｕ ． ０ ６个进 程／ 程 同时运行 ， 高端 系统 同时要 服务 ９ 线 而 上千 的用户 ， 以这显 然是一 个 问题 。 一度是 阻碍 所 它
略 。 单分 析 了一 般 线 程 机 制 ， 细 分 析 了 ｌ ｕ 简 详 ｉ ｘ线 程思 想 及 在 内核 中 的 实 现 ， 括 ｌ ｕ ｎ 包 ｉ ｘ线 程 描 述 数 据 结构 ， 理 线 程 机 制 和 ｎ 管 策 略 ， 程 栈 结 构 ， 程 ｉ 进 程 ｉ 创 建 和 分 配 ，ｉｕ 线 线 ｄ和 ｄ的 Ｌｎ ｘ线 程 实 现 方 法 。 关键词 ： 程 ， 线 内核 ，ｎ ｘ ｌ ｕ ｉ 中 图 分 类号 ： ３ ６ ＴＰ １ 文献标识码 ： Ａ
linux中的同步机制
linux中的同步机制Linux中的同步机制在Linux操作系统中，同步机制是一种重要的机制，用于控制并发访问共享资源的顺序和互斥。
它确保多个进程或线程能够有序地访问共享资源，避免数据竞争和不一致的结果。
本文将介绍Linux中常用的同步机制，包括互斥锁、条件变量、信号量和屏障等。
一、互斥锁（Mutex）互斥锁是一种最常见的同步机制，用于保护共享资源的访问。
在互斥锁的帮助下，只有一个进程或线程能够获得锁，其他进程或线程需要等待锁的释放。
Linux提供了多种互斥锁的实现，如pthread_mutex_t和std::mutex等。
使用互斥锁需要注意避免死锁和竞态条件等问题。
二、条件变量（Condition Variable）条件变量是一种用于线程间通信的同步机制，它允许线程在满足特定条件之前等待，从而避免了忙等待的问题。
在Linux中，条件变量通常与互斥锁一起使用。
当某个线程发现条件不满足时，它可以调用条件变量的等待函数将自己阻塞，直到其他线程满足条件并发出信号，唤醒等待的线程。
三、信号量（Semaphore）信号量是一种用于控制并发访问的同步机制，它可以实现对资源的计数和管理。
Linux提供了两种类型的信号量：二进制信号量和计数信号量。
二进制信号量只有两种状态（0和1），用于互斥访问共享资源；计数信号量可以有多个状态，用于限制并发访问的数量。
通过使用信号量，可以实现进程或线程之间的同步和互斥。
四、屏障（Barrier）屏障是一种用于线程同步的机制，它在多个线程到达指定点之前将它们阻塞，直到所有线程都到达后才继续执行。
屏障可以用于并行计算中的阶段同步，确保每个阶段的计算完成后再进行下一阶段的计算。
在Linux中，可以使用pthread_barrier_t来创建和操作屏障。
五、读写锁（ReadWrite Lock）读写锁是一种特殊的锁机制，用于在读操作和写操作之间提供更好的并发性。
读写锁允许多个线程同时读取共享资源，但只允许一个线程进行写操作。
linux线程id生成原理
linux线程id生成原理L i n u x线程I D生成原理简介L i n u x操作系统是一个非常受欢迎的开源操作系统，具有很强的稳定性和灵活性。
在L i n u x 中，线程是一种轻量级的进程，其创建和管理都是由操作系统完成的。
在线程创建过程中，会为每个线程分配一个唯一的线程I D（T h r e a d I D）。
本文将一步一步介绍L i n u x线程I D生成的原理，帮助读者更好地理解Li n u x线程的创建和管理。
一、什么是线程I D在线程I D生成原理之前，我们首先了解一下什么是线程ID。
每个线程在操作系统中都有一个唯一的标识符，这个标识符就是线程ID。
线程I D是一个整数，通常被用作线程的索引。
通过线程I D，操作系统可以识别和管理不同的线程。
二、线程I D的分配在L i n u x系统中，线程I D的分配是由操作系统内核完成的。
L i n u x内核维护了一个全局的线程I D计数器，用于生成唯一的线程I D。
1.线程I D生成过程当新的线程被创建时，内核会使用线程ID计数器为其分配一个唯一的线程I D。
线程ID的分配是按顺序进行的，即每次分配的线程ID比前一个分配的线程I D大1。
在L i n u x内核中，线程I D是通过原子操作实现的，确保线程ID的分配是原子的，避免了竞争条件的发生。
2.线程I D的范围在L i n u x系统中，线程I D的范围是从1到2^15-1（32767）。
这个范围的设计是为了保留线程I D0，它通常用于表示无效的或者未初始化的线程I D。
3.线程I D的重复由于线程I D是按顺序分配的，所以在一个线程退出后，其线程I D可能会被下一个新线程分配使用。
这意味着，在不同的时间点上，不同的线程可能会拥有相同的线程I D。
因此，在L i n u x 中，线程I D并不是一个全局唯一的标识符。
三、线程I D的使用在L i n u x系统中，线程I D在多个地方被使用，例如线程的创建、线程的等待、线程的取消等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Linux 线程实现机制分析杨沙洲国防科技大学计算机学院2003 年5 月 19 日 自从多线程编程的概念出现在Linux 中以来，Linux 多线应用的发展总是与两个问题脱不开干系：兼容性、效率。
本文从线程模型入手，通过分析目前Linux 平台上最流行的 LinuxThreads 线程库的实现及其不足，描述了Linux 社区是如何看待和解决兼容性和效率这两个问题的。
一.基础知识：线程和进程按照教科书上的定义，进程是资源管理的最小单位，线程是程序执行的最小单位。
在操作系统设计上，从进程演化出线程，最主要的目的就是更好的支持SMP 以及减小（进程/线程）上下文切换开销。
无论按照怎样的分法，一个进程至少需要一个线程作为它的指令执行体，进程管理着资源（比如cpu 、内存、文件等等），而将线程分配到某个cpu 上执行。
一个进程当然可以拥有多个线程，此时，如果进程运行在SMP机器上，它就可以同时使用多个cpu来执行各个线程，达到最大程度的并行，以提高效率；同时，即使是在单cpu的机器上，采用多线程模型来设计程序，正如当年采用多进程模型代替单进程模型一样，使设计更简洁、功能更完备，程序的执行效率也更高，例如采用多个线程响应多个输入，而此时多线程模型所实现的功能实际上也可以用多进程模型来实现，而与后者相比，线程的上下文切换开销就比进程要小多了，从语义上来说，同时响应多个输入这样的功能，实际上就是共享了除cpu 以外的所有资源的。
针对线程模型的两大意义，分别开发出了核心级线程和用户级线程两种线程模型，分类的标准主要是线程的调度者在核内还是在核外。
前者更利于并发使用多处理器的资源，而后者则更多考虑的是上下文切换开销。
在目前的商用系统中，通常都将两者结合起来使用，既提供核心线程以满足smp 系统的需要，也支持用线程库的方式在用户态实现另一套线程机制，此时一个核心线程同时成为多个用户态线程的调度者。
正如很多技术一样，"混合"通常都能带来更高的效率，但同时也带来更大的实现难度，出于"简单"的设计思路，Linux 从一开始就没有实现混合模型的计划，但它在实现上采用了另一种思路的"混合"。
在线程机制的具体实现上，可以在操作系统内核上实现线程，也可以在核外实现，后者显然要求核内至少实现了进程，而前者则一般要求在核内同时也支持进程。
核心级线程模型显然要求前者的支持，而用户级线程模型则不一定基于后者实现。
这种差异，正如前所述，是两种分类方式的标准不同带来的。
当核内既支持进程也支持线程时，就可以实现线程-进程的"多对多"模型，即一个进程的某个线程由核内调度，而同时它也可以作为用户级线程池的调度者，选择合适的用户级线程在其空间中运行。
这就是前面提到的"混合"线程模型，既可满足多处理机系统的需要，也可以最大限度的减小调度开销。
绝大多数商业操作系统（如Digital Unix 、Solaris 、Irix ）都采用的这种能够完全实现POSIX1003.1c 标准的线程模型。
在核外实现的线程又可以分为"一对一"、"多对一"两种模型，前者用一个核心进程（也许是轻量进程）对应一个线程，将线程调度等同于进程调度，交给核心完成，而后者则完全在核外实现多线程，调度也在用户态完成。
后者就是前面提到的单纯的用户级线程模型的实现方式，显然，这种核外的线程调度器实际上只需要完成线程运行栈的切换，调度开销非常小，但同时因为核心信号（无论是同步的还是异步的）都是以进程为单位的，因而无法定位到线程，所以这种实现方式不能用于多处理器系统，而这个需求正变得越来 内容：一.基础知识：线程和进程二.Linux 2.4内核中的轻量进程实现三.LinuxThread 的线程机制 四.其他的线程实现机制 参考资料关于作者 对本文的评价订阅:developerWorks 时事通讯越大，因此，在现实中，纯用户级线程的实现，除算法研究目的以外，几乎已经消失了。
Linux内核只提供了轻量进程的支持，限制了更高效的线程模型的实现，但Linux着重优化了进程的调度开销，一定程度上也弥补了这一缺陷。
目前最流行的线程机制LinuxThreads所采用的就是线程-进程"一对一"模型，调度交给核心，而在用户级实现一个包括信号处理在内的线程管理机制。
Linux-LinuxThreads 的运行机制正是本文的描述重点。
二.Linux 2.4内核中的轻量进程实现最初的进程定义都包含程序、资源及其执行三部分，其中程序通常指代码，资源在操作系统层面上通常包括内存资源、IO资源、信号处理等部分，而程序的执行通常理解为执行上下文，包括对cpu的占用，后来发展为线程。
在线程概念出现以前，为了减小进程切换的开销，操作系统设计者逐渐修正进程的概念，逐渐允许将进程所占有的资源从其主体剥离出来，允许某些进程共享一部分资源，例如文件、信号，数据内存，甚至代码，这就发展出轻量进程的概念。
Linux 内核在2.0.x版本就已经实现了轻量进程，应用程序可以通过一个统一的clone()系统调用接口，用不同的参数指定创建轻量进程还是普通进程。
在内核中，clone()调用经过参数传递和解释后会调用do_fork()，这个核内函数同时也是fork()、vfork()系统调用的最终实现：其中的clone_flags取自以下宏的"或"值：在do_fork()中，不同的clone_flags将导致不同的行为，对于LinuxThreads，它使用（CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND）参数来调用clone()创建"线程"，表示共享内存、共享文件系统访问计数、共享文件描述符表，以及共享信号处理方式。
本节就针对这几个参数，看看Linux内核是如何实现这些资源的共享的。
1.CLONE_VMdo_fork()需要调用copy_mm()来设置task_struct中的mm和active_mm项，这两个mm_struct数据与进程所关联的内存空间相对应。
如果do_fork()时指定了CLONE_VM开关，copy_mm()将把新的task_struct中的mm和active_mm设置成与current的相同，同时提高该mm_struct的使用者数目（mm_struct::mm_users）。
也就是说，轻量级进程与父进程共享内存地址空间，由下图示意可以看出mm_struct在进程中的地位：2.CLONE_FStask_struct中利用fs（struct fs_struct *）记录了进程所在文件系统的根目录和当前目录信息，do_fork()时调用copy_fs()复制了这个结构；而对于轻量级进程则仅增加fs->count计数，与父进程共享相同的fs_struct。
也就是说，轻量级进程没有独立的文件系统相关的信息，进程中任何一个线程改变当前目录、根目录等信息都将直接影响到其他线程。
3.CLONE_FILES一个进程可能打开了一些文件，在进程结构task_struct中利用files（struct files_struct *）来保存进程打开的文件结构（struct file）信息，do_fork()中调用了copy_files()来处理这个进程属性；轻量级进程与父进程是共享该结构的，copy_files()时仅增加files->count计数。
这一共享使得任何线程都能访问进程所维护的打开文件，对它们的操作会直接反映到进程中的其他线程。
4.CLONE_SIGHAND每一个Linux进程都可以自行定义对信号的处理方式，在task_struct中的sig（struct signal_struct）中使用一个struct k_sigaction结构的数组来保存这个配置信息，do_fork()中的copy_sighand()负责复制该信息；轻量级进程不进行复制，而仅仅增加signal_struct::count计数，与父进程共享该结构。
也就是说，子进程与父进程的信号处理方式完全相同，而且可以相互更改。
do_fork()中所做的工作很多，在此不详细描述。
对于SMP系统，所有的进程fork出来后，都被分配到与父进程相同的cpu上，一直到该进程被调度时才会进行cpu选择。
尽管Linux支持轻量级进程，但并不能说它就支持核心级线程，因为Linux的"线程"和"进程"实际上处于一个调度层次，共享一个进程标识符空间，这种限制使得不可能在Linux上实现完全意义上的POSIX线程机制，因此众多的Linux线程库实现尝试都只能尽可能实现POSIX的绝大部分语义，并在功能上尽可能逼近。
三.LinuxThread的线程机制LinuxThreads是目前Linux平台上使用最为广泛的线程库，由Xavier Leroy (Xavier.Leroy@inria.fr)负责开发完成，并已绑定在GLIBC中发行。
它所实现的就是基于核心轻量级进程的"一对一"线程模型，一个线程实体对应一个核心轻量级进程，而线程之间的管理在核外函数库中实现。
1.线程描述数据结构及实现限制LinuxThreads定义了一个struct _pthread_descr_struct数据结构来描述线程，并使用全局数组变量__pthread_handles来描述和引用进程所辖线程。
在__pthread_handles中的前两项，LinuxThreads定义了两个全局的系统线程：__pthread_initial_thread和__pthread_manager_thread，并用__pthread_main_thread表征__pthread_manager_thread的父线程（初始为__pthread_initial_thread）。
struct _pthread_descr_struct是一个双环链表结构，__pthread_manager_thread所在的链表仅包括它一个元素，实际上，__pthread_manager_thread是一个特殊线程，LinuxThreads仅使用了其中的errno、p_pid、p_priority等三个域。
而__pthread_main_thread所在的链则将进程中所有用户线程串在了一起。
经过一系列pthread_create()之后形成的__pthread_handles数组将如下图所示：新创建的线程将首先在__pthread_handles数组中占据一项，然后通过数据结构中的链指针连入以__pthread_main_thread为首指针的链表中。