linux线程安全？linux有必要学吗

很多朋友对于linux线程安全和linux有必要学吗不太懂，今天就由小编来为大家分享，希望可以帮助到大家，下面一起来看看吧！

linuxvga驱动linuxvga

linux登录黑屏？

答解决方法如下

1、在启动时，GRUB上GRUB引导命令后面加上一个VGA=791，这样进去屏幕分辩率就是1024*768。

kernel(hd0,0)/linuxroot=/dev/ramramdisk_size=65536devfs=mount,allvga=791

initrd(hd0,0)/initrd

boot

2、在黑屏时。按Ctrl+Alt+F2进入另一个shell，运行yast，选择hardware-GraphicsandMonitor，里面有两个选项，第一个是text模式，第二个是图形模式，还有change和reprobe选项，但change选项是用不了的(如果你能用就最好不过了。直接更改属性，把分辨率调低点，accept，退出重启就行了)，这时候先切换成为text模式，退出重启；重启后应该还是用不了的，再次按Ctrl+Alt+F2进入控制台，运行yast，此时再在上述的选项处进行change就OK了

3、在黑屏时，按ctrl+alt+F2进入控制台。直接输入init3。然后输入init5

4、GRUB4DOS

好多人多系统启动SUSE喜欢用它引导SUSE。

编辑menu.lst

kernel(hdx,y)/linuxvga=791

initrd(hdx,y)/initrd

boot

5、修改xorg.conf

按ctrl+alt+F2进入shell

#vi/etc/x11/xorg.conf

section“Monitor”

HorizSync31.5-70.0

VertRefresh50.0-100.0

Linux系统的图形界面的形式有哪几种？

1．XWindowXWindow是由麻省理工学院（MIT）推出的窗口系统，简称X，它旨在建立不依赖于特定硬件系统的图形和文字显示窗口系统的标准。

1987年9月，MIT推出了X系统的11版，称为X11，它的出现标志着计算机工作站的一个新时代的到来。现在几乎所有的工作站都采用了X窗口的标准，几乎所有的工作站上的应用软件都采用了基于XWindow的软件平台。同时，微机的X系统也日益增多。X窗口系统之所以能受到人们的广泛青睐，是与其优越的特点分不开的。首先，它不依赖与硬件系统的特点，使我们在任意一种计算机上用X系统开发的图形软件，可以不需任何修改或只需极少改动就能移植到几十种其它类型的计算机上。其次，X是一种基于网络的窗口系统，采用X的应用软件可以在由不同机器组成的网络上运行。我们能方便地在远程计算机上运行软件，而将结果显示到本机上。2．SVGALibSVGALib是Linux上底层的图形库，也是Linux系统中最早出现的非X图形支持库，它支持标准的VGA图形模式和一些其他的模式，SVGALib的缺点是程序必须以root权限登录，并且它是基于图形卡的，所以不是所有的硬件都支持它。自从framebuffer这个孪生姐妹诞生后，许多软件由只支持SVGALib改变为同时支持两者，甚至一些流行的高层函数库如QT和GTK只支持Framebuffer，作为一个老的图形支持库，SVGALib目前的应用范围越来越小，尤其是在Linux内核增加了FrameBuffer驱动支持之后。3．FrameBufferFrameBuffer是出现在2.2.xx内核当中的一种驱动程序接口。这种接口将显示设备抽象为帧缓冲区。用户可以将它看成是显示内存的一个映像，将其映射到进程地址空间之后，就可以直接进行读写操作，而写操作可以立即反映在屏幕上。该驱动程序的设备文件一般是/dev/fb0、/dev/fb1等等。4．LibGGIGGI,即GeneralGraphicsInterface,是新一代的图形支持库。GGI的主要功能特性有：可在FrameBuffer,SVGALib,X等设备上运行,在这些设备上是二进制兼容的；在所有平台上提供了一致的输入设备接口,比如鼠标和键盘；与LinuxThreads线程库兼容,接口线程安全；提供异步绘制模式,可提高屏幕刷新速度；提供良好的颜色处理接口；接口简单易用；采用共享库机制,实现底层支持库的动态装载；GGI的主要不足在于安装和配置较为复杂。

小红帽LINUX系统的分辨率怎么调？

XWindow分辨率，开始菜单里“系统设置”——“显示”，先设置“硬件”里的显示器型号，如果没有与实际一致的，就选一个相近的，然后更改分辨率字符控制台更改分辨率：修改/boot/grub/grub.conf，在kernel后加上vga=ask重启后会提示选择显示模式：比如想选择800*600*32的显示模式，输入u回车即可如果以后都想使用此模式，修改/boot/grub/grub.conf，将kernel后的vga=ask改为vga=0x343

如何在Linux系统安装显卡驱动？

给你总结一下吧！

1.先看硬件列表，用lspci，找到VGA那一行，确定型号2.网上找相应型号的驱动并下载3.安装之前，要禁掉X-serveri：方法为：vim/etc/X11/xorg.conf禁掉其中device部分4.重启系统，以root登录5.找到驱动文件，执行：sudosh./*.run（或其他格式）

6.startx启动X-server

有人能教下我有关linux里面线程的知识吗

.线程的基本介绍

(1)线程的概述

线程与进程类似，也允许应用程序并发执行多个任务的一种机制。一个进程可以包含多个线程，同一程序中的所有线程共享同一份全局内存区域，线程之间没有真正意义的等级之分。同一个进程中的线程可以并发执行，如果处理器是多核的话线程也可以并行执行，如果一个线程因为等待I/O操作而阻塞，那么其他线程依然可以继续运行

(2)线程优于进程的方面

argv,environ

主线程栈

线程3的栈

线程2的栈

线程1的栈

共享函数库共享的内存

堆

未初始化的数据段

初始化数据段

文本

.进程间的信息难以共享。由于除去只读代码段外，父子进程并未共享内存，因此必须采用一些进程间通讯，在进程之间交换信息

.调用fork()来创建进程代价相对较高

线程很好的解决了上述俩个问题

.线程之间能够方便，快速的共享信息，只需将数据复制到共享（全局或堆）变量中即可

.创建线程比创建线程通常要快10甚至更多，线程创建之所以快，是因为fork创建进程时所需复制多个属性，而在线程中，这些属性是共享的。

(3)创建线程

启动程序时，产生的进程只有单条线程，我们称之为主线程

#include<pthread.h>

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

新线程通过调用带有arg的函数开始执行，调用pthread_create()的线程会继续执行该调用之后的语句。

(4)终止线程

可以以如下方式终止线程的运行

.线程调用pthread_exit()

.线程start函数执行return语句并返回指定值

.调用pthread_cancel()取消线程

.任意线程调用了exit(),或者主线程执行了return语句，都会导致进程中的所有线程立即终止

pthread_exit()函数可以终止线程，且其返回值可由另一线程通过调用pthread_join()获得

#include<pthread.h>void pthread_exit(void*retval);12

调用pthread_exit()相当于在线程的start函数中执行return,不同之处在于，pthread_exit()可以在任何地方调用，参数retval指定了线程的返回值

(5)获取线程ID

#include<pthread.h>pthread_t pthread_self(void);12

线程ID在应用程序中主要有如下用途

.不同的pthreads函数利用线程ID来标识要操作目标线程。

.在具体的应用程序中，以特定线程的线程ID作为动态数据结构的标签，这颇有用处，既可用来识别某个数据结构的创建者或属主线程，又可确定随后对该数据结构执行操作的具体线程

函数pthread_equal()可检查俩个线程的ID是否相同

#include<pthread.h>int pthread_equal(pthread_t t1,pthread_t t2);//如果相同返回非0值，否则返回0123

(6)连接已终止的线程

函数pthread_join()等待由thread表识的线程终止

#include<pthread.h>int pthread_join(pthread_t thread,void**retval);//返回0调用成功，否则失败123

如果pthread_join()传入一个之前已然连接过的线程ID，将会导致无法预知的行为，当相同线程ID在参与一次连接后恰好为另一新建线程所重用，再度连接的可能就是这个新线程

若线程未分离，则就应该使用pthread_join()来连接线程，否则会产生僵尸线程

pthrea_join()函数的要点

.线程之间的关系是对等的，所以任意线程都可以调用pthread_join()来连接其他线程

.pthread_join()无法针对任意线程，只能连接单个线程

(6)线程的分离

默认情况下线程都是可连接的，但有时候，我们并不关心线程退出的状态，我们可以调用pthread_detach()并向thread参数传入指定线程的的标识符，将该线程标记为处于分离状态

#include<pthread.h>int pthread_detach(pthread_t thread);//返回0成功，否则失败123

一旦线程处于分离状态，就不能在使用pthread_join()来获取其状态，也无法使其重返可连接状态

(7)在应用程序中如何来选择进程还是线程

.线程之间共享数据很简单，进程间的数据共享需要更多的投入

.创建线程要比创建进程块很多

.多线程编程时，需要确保调用线程安全的函数

.某个线程中的bug可能会危害进程中所有线程

.每个线程都在征用宿主进程中有限的虚拟地址空间

.在多线程应用中，需要小心使用信号

.除了数据，线程还可以共享文件描述符，信号处置，当前工作目录，以及用户ID和组ID

线程的同步

(1)保护共享变量访问：互斥量

线程的主要优势在于能够通过全局变量来共享信息，不过这种共享是有代价的。必须确保多个线程修改同一变量时，不会有其他线程也正在修改此变量，为避免线程更新时共享变量时所出现的问题，必须使用互斥量来确保同时仅有一个线程可以访问某项共享资源

(2)静态分配的互斥锁

互斥锁既可以像静态变量那样分配，也可以在运行时动态分配，互斥量属于pthread_mutex_t类型的变量，在使用之前必须对其初始化。对于静态分配的互斥量而言，可如下例所示，将PTHREAD_MUTEX_INITIALIZER赋给互斥量

pthread_mutex_t= PTHREAD_MUTEX_INITIALIZER;1

1.加锁和解锁互斥量

初始化之后，互斥量处于未锁定状态。函数pthread_mutex_lock()可以锁定某一互斥量

而函数pthread_mutex_unlock()则可以将一个互斥量解锁

#include<pthread.h>int pthread_mutex_lock(pthread_mutex_t*mutex);int pthread_mutex_unlock(pthread_mutex_t*mutex);//返回0成功，其他失败1234

要锁定互斥量，在调用pthread_mutex_lock()时需要指定互斥量，如果互斥量当前处于未锁定状态，则该调用将会立即返回，如果该互斥量已被其他线程锁定，那么该调用将会阻塞，直至互斥量被解锁

函数pthread_mutex_unlock()将解锁之前已遭调用线程锁定的互斥量

2.互斥量的性能

通常情况下，线程会花费更多的时间去做其他工作，对互斥量的加锁解锁相对要少的多，因此使用互斥量对大部分程序来说性能并无显著的影响

3.互斥量的死锁

当一个线程需要同时访问多个共享资源时，没个资源由不同的互斥索管理。当超过一个线程加锁同一组互斥量时，就有可能发生死锁。如下图所示

线程A

1.pthread_mutex_lock(mutex1);

2.pthread_mutex_lock(mutex2);

线程2

1.pthread_mutex_lock(mutex2);

2.pthread_mutex_lock(mutex1);

每个线程都成功的锁住一个互斥量，接着试图对以为另一线程锁定的互斥量加锁，就会一直等下去

要避免此类死锁问题，最简单的就是定义互斥量的层级关系

如何看懂《Linux多线程服务端编程

一：进程和线程

每个进程有自己独立的地址空间。“在同一个进程”还是“不在同一个进程”是系统功能划分的重要决策点。《Erlang程序设计》[ERL]把进程比喻为人：

每个人有自己的记忆（内存），人与人通过谈话（消息传递）来交流，谈话既可以是面谈（同一台服务器），也可以在电话里谈（不同的服务器，有网络通信）。面谈和电话谈的区别在于，面谈可以立即知道对方是否死了（crash,SIGCHLD），而电话谈只能通过周期性的心跳来判断对方是否还活着。

有了这些比喻，设计分布式系统时可以采取“角色扮演”，团队里的几个人各自扮演一个进程，人的角色由进程的代码决定（管登录的、管消息分发的、管买卖的等等）。每个人有自己的记忆，但不知道别人的记忆，要想知道别人的看法，只能通过交谈（暂不考虑共享内存这种IPC）。然后就可以思考：

·容错：万一有人突然死了

·扩容：新人中途加进来

·负载均衡：把甲的活儿挪给乙做

·退休：甲要修复bug，先别派新任务，等他做完手上的事情就把他重启

等等各种场景，十分便利。

线程的特点是共享地址空间，从而可以高效地共享数据。一台机器上的多个进程能高效地共享代码段(操作系统可以映射为同样的物理内存)，但不能共享数据。如果多个进程大量共享内存，等于是把多进程程序当成多线程来写，掩耳盗铃。

“多线程”的价值，我认为是为了更好地发挥多核处理器(multi-cores)的效能。在单核时代，多线程没有多大价值（个人想法：如果要完成的任务是CPU密集型的，那多线程没有优势，甚至因为线程切换的开销，多线程反而更慢；如果要完成的任务既有CPU计算，又有磁盘或网络IO，则使用多线程的好处是，当某个线程因为IO而阻塞时，OS可以调度其他线程执行，虽然效率确实要比任务的顺序执行效率要高，然而，这种类型的任务，可以通过单线程的”non-blocking IO+IO multiplexing”的模型（事件驱动）来提高效率，采用多线程的方式，带来的可能仅仅是编程上的简单而已）。Alan Cox说过：”A computer is a state machine.Threads are for people who can’t program state machines.”（计算机是一台状态机。线程是给那些不能编写状态机程序的人准备的）如果只有一块CPU、一个执行单元，那么确实如Alan Cox所说，按状态机的思路去写程序是最高效的。

二：单线程服务器的常用编程模型

据我了解，在高性能的网络程序中，使用得最为广泛的恐怕要数”non-blocking IO+ IO multiplexing”这种模型，即Reactor模式。

在”non-blocking IO+ IO multiplexing”这种模型中，程序的基本结构是一个事件循环（event loop），以事件驱动（event-driven）和事件回调的方式实现业务逻辑：

[cpp] view plain copy

//代码仅为示意，没有完整考虑各种情况

while(!done)

{

int timeout_ms= max(1000, getNextTimedCallback());

int retval= poll(fds, nfds, timeout_ms);

if(retval<0){

处理错误，回调用户的error handler

}else{

处理到期的timers,回调用户的timer handler

if(retval>0){

处理IO事件，回调用户的IO event handler

}

}

}

这里select(2)/poll(2)有伸缩性方面的不足（描述符过多时，效率较低），Linux下可替换为epoll(4)，其他操作系统也有对应的高性能替代品。

Reactor模型的优点很明显，编程不难，效率也不错。不仅可以用于读写socket，连接的建立(connect(2)/accept(2))，甚至DNS解析都可以用非阻塞方式进行，以提高并发度和吞吐量(throughput)，对于IO密集的应用是个不错的选择。lighttpd就是这样，它内部的fdevent结构十分精妙，值得学习。

基于事件驱动的编程模型也有其本质的缺点，它要求事件回调函数必须是非阻塞的。对于涉及网络IO的请求响应式协议，它容易割裂业务逻辑，使其散布于多个回调函数之中，相对不容易理解和维护。

三：多线程服务器的常用编程模型

大概有这么几种：

a：每个请求创建一个线程，使用阻塞式IO操作。在Java 1.4引人NIO之前，这是Java网络编程的推荐做法。可惜伸缩性不佳（请求太多时，操作系统创建不了这许多线程）。

b：使用线程池，同样使用阻塞式IO操作。与第1种相比，这是提高性能的措施。

c：使用non-blocking IO+ IO multiplexing。即Java NIO的方式。

d：Leader/Follower等高级模式。

在默认情况下，我会使用第3种，即non-blocking IO+ one loop per thread模式来编写多线程C++网络服务程序。

1：one loop per thread

此种模型下，程序里的每个IO线程有一个event loop，用于处理读写和定时事件（无论周期性的还是单次的）。代码框架跟“单线程服务器的常用编程模型”一节中的一样。

libev的作者说：

One loop per thread is usually a good model. Doing this is almost never wrong, some times a better-performance model exists, but it is always a good start.

这种方式的好处是：

a：线程数目基本固定，可以在程序启动的时候设置，不会频繁创建与销毁。

b：可以很方便地在线程间调配负载。

c：IO事件发生的线程是固定的，同一个TCP连接不必考虑事件并发。

Event loop代表了线程的主循环，需要让哪个线程干活，就把timer或IO channel（如TCP连接）注册到哪个线程的loop里即可：对实时性有要求的connection可以单独用一个线程；数据量大的connection可以独占一个线程，并把数据处理任务分摊到另几个计算线程中（用线程池）；其他次要的辅助性connections可以共享一个线程。

比如，在dbproxy中，一个线程用于专门处理客户端发来的管理命令；一个线程用于处理客户端发来的MySQL命令，而与后端数据库通信执行该命令时，是将该任务分配给所有事件线程处理的。

对于non-trivial（有一定规模）的服务端程序，一般会采用non-blocking IO+ IO multiplexing，每个connection/acceptor都会注册到某个event loop上，程序里有多个event loop，每个线程至多有一个event loop。

多线程程序对event loop提出了更高的要求，那就是“线程安全”。要允许一个线程往别的线程的loop里塞东西，这个loop必须得是线程安全的。

在dbproxy中，线程向其他线程分发任务，是通过管道和队列实现的。比如主线程accept到连接后，将表示该连接的结构放入队列，并向管道中写入一个字节。计算线程在自己的event loop中注册管道的读事件，一旦有数据可读，就尝试从队列中取任务。

2：线程池

不过，对于没有IO而光有计算任务的线程，使用event loop有点浪费。可以使用一种补充方案，即用blocking queue实现的任务队列：

[cpp] view plain copy

typedef boost::function<void()>Functor;

BlockingQueue<Functor> taskQueue;//线程安全的全局阻塞队列

//计算线程

void workerThread()

{

while(running)//running变量是个全局标志

{

Functor task= taskQueue.take();//this blocks

task();//在产品代码中需要考虑异常处理

}

}

//创建容量（并发数）为N的线程池

int N= num_of_computing_threads;

for(int i= 0; i< N;++i)

{

create_thread(&workerThread);//启动线程

}

//向任务队列中追加任务

Foo foo;//Foo有calc()成员函数

boost::function<void()> task= boost::bind(&Foo::calc，&foo);

taskQueue.post(task);

除了任务队列，还可以用BlockingQueue<T>实现数据的生产者消费者队列，即T是数据类型而非函数对象，queue的消费者从中拿到数据进行处理。其实本质上是一样的。

3：总结

总结而言，我推荐的C++多线程服务端编程模式为：one(event) loop per thread+ thread pool：

event loop用作IO multiplexing，配合non-blockingIO和定时器；

thread pool用来做计算，具体可以是任务队列或生产者消费者队列。

以这种方式写服务器程序，需要一个优质的基于Reactor模式的网络库来支撑，muduo正是这样的网络库。比如dbproxy使用的是libevent。

程序里具体用几个loop、线程池的大小等参数需要根据应用来设定，基本的原则是“阻抗匹配”（解释见下），使得CPU和IO都能高效地运作。所谓阻抗匹配原则：

如果池中线程在执行任务时，密集计算所占的时间比重为 P(0< P<= 1)，而系统一共有 C个 CPU，为了让这 C个 CPU跑满而又不过载，线程池大小的经验公式 T= C/P。（T是个 hint，考虑到 P值的估计不是很准确，T的最佳值可以上下浮动 50%）

以后我再讲这个经验公式是怎么来的，先验证边界条件的正确性。

假设 C= 8，P= 1.0，线程池的任务完全是密集计算，那么T= 8。只要 8个活动线程就能让 8个 CPU饱和，再多也没用，因为 CPU资源已经耗光了。

假设 C= 8，P= 0.5，线程池的任务有一半是计算，有一半等在 IO上，那么T= 16。考虑操作系统能灵活合理地调度 sleeping/writing/running线程，那么大概 16个“50%繁忙的线程”能让 8个 CPU忙个不停。启动更多的线程并不能提高吞吐量，反而因为增加上下文切换的开销而降低性能。

如果 P< 0.2，这个公式就不适用了，T可以取一个固定值，比如 5*C。

另外，公式里的 C不一定是 CPU总数，可以是“分配给这项任务的 CPU数目”，比如在 8核机器上分出 4个核来做一项任务，那么 C=4。

四：进程间通信只用TCP

Linux下进程间通信的方式有：匿名管道(pipe)、具名管道(FIFO)、POSIX消息队列、共享内存、信号(signals)，以及Socket。同步原语有互斥器(mutex)、条件变量(condition variable)、读写锁(reader-writer lock)、文件锁(record locking)、信号量(semaphore)等等。

进程间通信我首选Sockets（主要指TCP，我没有用过UDP，也不考虑Unix domain协议）。其好处在于：

可以跨主机，具有伸缩性。反正都是多进程了，如果一台机器的处理能力不够，很自然地就能用多台机器来处理。把进程分散到同一局域网的多台机器上，程序改改host:port配置就能继续用；

TCP sockets和pipe都是操作文件描述符，用来收发字节流，都可以read/write/fcntl/select/poll等。不同的是，TCP是双向的，Linux的pipe是单向的，进程间双向通信还得开两个文件描述符，不方便；而且进程要有父子关系才能用pipe，这些都限制了pipe的使用；

TCP port由一个进程独占，且进程退出时操作系统会自动回收文件描述符。因此即使程序意外退出，也不会给系统留下垃圾，程序重启之后能比较容易地恢复，而不需要重启操作系统（用跨进程的mutex就有这个风险）；而且，port是独占的，可以防止程序重复启动，后面那个进程抢不到port，自然就没法初始化了，避免造成意料之外的结果；

与其他IPC相比，TCP协议的一个天生的好处是“可记录、可重现”。tcpdump和Wireshark是解决两个进程间协议和状态争端的好帮手，也是性能（吞吐量、延迟）分析的利器。我们可以借此编写分布式程序的自动化回归测试。也可以用tcpcopy之类的工具进行压力测试。TCP还能跨语言，服务端和客户端不必使用同一种语言。

分布式系统的软件设计和功能划分一般应该以“进程”为单位。从宏观上看，一个分布式系统是由运行在多台机器上的多个进程组成的，进程之间采用TCP长连接通信。

使用TCP长连接的好处有两点：一是容易定位分布式系统中的服务之间的依赖关系。只要在机器上运行netstat-tpna|grep<port>就能立刻列出用到某服务的客户端地址（Foreign Address列），然后在客户端的机器上用netstat或lsof命令找出是哪个进程发起的连接。TCP短连接和UDP则不具备这一特性。二是通过接收和发送队列的长度也较容易定位网络或程序故障。在正常运行的时候，netstat打印的Recv-Q和Send-Q都应该接近0，或者在0附近摆动。如果Recv-Q保持不变或持续增加，则通常意味着服务进程的处理速度变慢，可能发生了死锁或阻塞。如果Send-Q保持不变或持续增加，有可能是对方服务器太忙、来不及处理，也有可能是网络中间某个路由器或交换机故障造成丢包，甚至对方服务器掉线，这些因素都可能表现为数据发送不出去。通过持续监控Recv-Q和Send-Q就能及早预警性能或可用性故障。以下是服务端线程阻塞造成Recv-Q和客户端Send-Q激增的例子：

[cpp] view plain copy

$netstat-tn

Proto Recv-Q Send-Q Local Address Foreign

tcp 78393 0 10.0.0.10:2000 10.0.0.10:39748#服务端连接

tcp 0 132608 10.0.0.10:39748 10.0.0.10:2000#客户端连接

tcp 0 52 10.0.0.10:22 10.0.0.4:55572

五：多线程服务器的适用场合

如果要在一台多核机器上提供一种服务或执行一个任务，可用的模式有：

a：运行一个单线程的进程；

b：运行一个多线程的进程；

c：运行多个单线程的进程；

d：运行多个多线程的进程；

考虑这样的场景：如果使用速率为50MB/s的数据压缩库，进程创建销毁的开销是800微秒，线程创建销毁的开销是50微秒。如何执行压缩任务？

如果要偶尔压缩1GB的文本文件，预计运行时间是20s，那么起一个进程去做是合理的，因为进程启动和销毁的开销远远小于实际任务的耗时。

如果要经常压缩500kB的文本数据，预计运行时间是10ms，那么每次都起进程似乎有点浪费了，可以每次单独起一个线程去做。

如果要频繁压缩10kB的文本数据，预计运行时间是200微秒，那么每次起线程似乎也很浪费，不如直接在当前线程搞定。也可以用一个线程池，每次把压缩任务交给线程池，避免阻塞当前线程（特别要避免阻塞IO线程）。

由此可见，多线程并不是万灵丹(silver bullet)。

1：必须使用单线程的场合

据我所知，有两种场合必须使用单线程：

a：程序可能会fork(2)；

实际编程中，应该保证只有单线程程序能进行fork(2)。多线程程序不是不能调用fork(2)，而是这么做会遇到很多麻烦：

fork一般不能在多线程程序中调用，因为Linux的fork只克隆当前线程的thread of control，不可隆其他线程。fork之后，除了当前线程之外，其他线程都消失了。

这就造成一种危险的局面。其他线程可能正好处于临界区之内，持有了某个锁，而它突然死亡，再也没有机会去解锁了。此时如果子进程试图再对同一个mutex加锁，就会立即死锁。因此，fork之后，子进程就相当于处于signal handler之中（因为不知道调用fork时，父进程中的线程此时正在调用什么函数，这和信号发生时的场景一样），你不能调用线程安全的函数（除非它是可重入的），而只能调用异步信号安全的函数。比如，fork之后，子进程不能调用：

malloc，因为malloc在访问全局状态时几乎肯定会加锁；

任何可能分配或释放内存的函数，比如snprintf；

任何Pthreads函数；

printf系列函数，因为其他线程可能恰好持有stdout/stderr的锁；

除了man 7 signal中明确列出的信号安全函数之外的任何函数。

因此，多线程中调用fork，唯一安全的做法是fork之后，立即调用exec执行另一个程序，彻底隔断子进程与父进程的联系。

在多线程环境中调用fork，产生子进程后。子进程内部只存在一个线程，也就是父进程中调用fork的线程的副本。

使用fork创建子进程时，子进程通过继承整个地址空间的副本，也从父进程那里继承了所有互斥量、读写锁和条件变量的状态。如果父进程中的某个线程占有锁，则子进程同样占有这些锁。问题是子进程并不包含占有锁的线程的副本，所以子进程没有办法知道它占有了哪些锁，并且需要释放哪些锁。

尽管Pthread提供了pthread_atfork函数试图绕过这样的问题，但是这回使得代码变得混乱。因此《Programming With Posix Threads》一书的作者说：”Avoid using fork in threaded code except where the child process will immediately exec a new program.”。

b：限制程序的CPU占用率；

这个很容易理解，比如在一个8核的服务器上，一个单线程程序即便发生busy-wait，占满1个core，其CPU使用率也只有12.5%，在这种最坏的情况下，系统还是有87.5%的计算资源可供其他服务进程使用。

因此对于一些辅助性的程序，如果它必须和主要服务进程运行在同一台机器的话，那么做成单线程的能避免过分抢夺系统的计算资源。