【IT专家】linux多线程及信号处理

linux异步io实现方式Linux异步IO（Asynchronous I/O）是一种实现I/O操作的方式，它与传统的同步IO（Synchronous I/O）相比具有更高的效率和更好的性能。

本文将介绍Linux异步IO的实现方式。

Linux异步IO的实现方式主要有以下几种：多线程方式、信号方式、回调函数方式和事件驱动方式。

1. 多线程方式：在多线程方式中，主线程负责发起IO请求，然后创建一个或多个工作线程来处理这些请求。

主线程启动一个线程池，每个线程负责一个IO操作。

主线程将IO请求分配给空闲的工作线程，工作线程独立地进行IO操作。

这种方式的优点是简单易用，但需要管理线程池和线程间的同步和通信。

2. 信号方式：在信号方式中，主线程发起IO请求后，将信号设置为非阻塞模式，然后继续执行其他任务。

当IO操作完成时，内核会发送一个信号通知主线程。

主线程通过信号处理函数来处理完成的IO操作。

这种方式的优点是简单高效，但需要处理信号的并发性和可靠性。

3. 回调函数方式：在回调函数方式中，主线程发起IO请求后，将回调函数注册到内核中，并继续执行其他任务。

当IO操作完成时，内核会调用注册的回调函数来处理完成的IO操作。

这种方式的优点是灵活性高，但需要管理回调函数的注册和执行。

4. 事件驱动方式：在事件驱动方式中，主线程发起IO请求后，将IO事件添加到事件循环中，并继续执行其他任务。

事件循环会监听所有IO事件，并根据事件类型调用相应的处理函数。

这种方式的优点是高效灵活，但需要管理事件循环和事件处理函数。

总结起来，Linux异步IO的实现方式有多线程方式、信号方式、回调函数方式和事件驱动方式。

不同的方式适用于不同的场景，开发者可以根据实际需求选择合适的实现方式。

异步IO可以提高系统的并发性和性能，使系统能够更好地处理大量的IO操作。

linux多线程编程详解教程（线程通过信号量实现通信代码）线程按照其调度者可以分为⽤户级线程和核⼼级线程两种。

（1）⽤户级线程主要解决的是上下⽂切换的问题，它的调度算法和调度过程全部由⽤户⾃⾏选择决定，在运⾏时不需要特定的内核⽀持。

在这⾥，操作系统往往会提供⼀个⽤户空间的线程库，该线程库提供了线程的创建、调度、撤销等功能，⽽内核仍然仅对进程进⾏管理。

如果⼀个进程中的某⼀个线程调⽤了⼀个阻塞的系统调⽤，那么该进程包括该进程中的其他所有线程也同时被阻塞。

这种⽤户级线程的主要缺点是在⼀个进程中的多个线程的调度中⽆法发挥多处理器的优势。

（2）这种线程允许不同进程中的线程按照同⼀相对优先调度⽅法进⾏调度，这样就可以发挥多处理器的并发优势。

现在⼤多数系统都采⽤⽤户级线程与核⼼级线程并存的⽅法。

⼀个⽤户级线程可以对应⼀个或⼏个核⼼级线程，也就是“⼀对⼀”或“多对⼀”模型。

这样既可满⾜多处理机系统的需要，也可以最⼤限度地减少调度开销。

Linux的线程实现是在核外进⾏的，核内提供的是创建进程的接⼝do_fork()。

内核提供了两个系统调⽤clone()和fork()，最终都⽤不同的参数调⽤do_fork()核内API。

当然，要想实现线程，没有核⼼对多进程（其实是轻量级进程）共享数据段的⽀持是不⾏的，因此，do_fork()提供了很多参数，包括CLONE_VM（共享内存空间）、CLONE_FS（共享⽂件系统信息）、CLONE_FILES（共享⽂件描述符表）、CLONE_SIGHAND（共享信号句柄表）和CLONE_PID（共享进程ID，仅对核内进程，即0号进程有效）。

当使⽤fork系统调⽤时，内核调⽤do_fork()不使⽤任何共享属性，进程拥有独⽴的运⾏环境，⽽使⽤pthread_create()来创建线程时，则最终设置了所有这些属性来调⽤__clone()，⽽这些参数⼜全部传给核内的do_fork()，从⽽创建的“进程”拥有共享的运⾏环境，只有栈是独⽴的，由__clone()传⼊。

多线程----信号处理1，在linux的信号机制⾥⾯，有很多信号的默认处理都是结束进程，例如SIGPIPE，SIGINT如果我们没有对信号进⾏处理，那么我们的程序就不太健壮。

2，不同的操作系统，多线程中对信号的处理不⼀致。

linux的线程其实就是⼀个轻量级的进程，每⼀个线程都可以接收和处理信号。

例如，linux中信号处理默认是由主线程进⾏，但如果主线程对某个信号进⾏了屏蔽，这个信号就可以交给其它可以处理的线程进⾏处理。

3，为了统⼀，我们可以在主线程⾥⾯接收和处理信号，⽽其它线程屏蔽所有信号。

代码如下：rbsignal.h#ifndef _RB_SIGNAL_H#define _RB_SIGNAL_H#include <sys/signal.h>#include <sys/types.h>#include <stdio.h>#include <stdlib.h>#include <errno.h>#include <unistd.h>#include <string.h>#include <sys/socket.h>void set_pipe(int p);//阻塞所有的信号void block_all_signal();//主线程信号处理void main_thread_sig_hand();//信号是否在信号掩码中int is_member(int sig);#endif#include "rbsignal.h"static int rb_pipe;void set_pipe(int p){rb_pipe = p;}//阻塞所有的信号void block_all_signal(){sigset_t mask;sigfillset(&mask);int rc = pthread_sigmask(SIG_BLOCK, &mask, NULL);if (rc != 0){fprintf(stderr, "block all signal error: %s\n", strerror(rc));exit;}}//所有信号的处理函数//就是向管道发⼀个信号值，以便在libevent循环中处理，⽬标：统⼀事件源static void sig_handler(int sig){int save_errno = errno;int msg = sig;int r = write(rb_pipe, (char*)&msg, 4);errno = save_errno;}//安装⼀个信号处理程序static void add_signal(int sig){struct sigaction action;memset(&action, 0, sizeof(action));action.sa_handler = sig_handler;sigfillset(&action.sa_mask);sigaction(sig, &action, NULL);}//主线程的信号处理void main_thread_sig_hand(){sigset_t except;sigemptyset(&except);sigaddset(&except, SIGHUP);sigaddset(&except, SIGPIPE);sigaddset(&except, SIGTERM);sigaddset(&except, SIGINT);int rc= pthread_sigmask(SIG_UNBLOCK, &except, NULL);if (rc != 0){fprintf(stderr, "main thread signal error: %s\n", strerror(rc));exit;}add_signal(SIGHUP);add_signal(SIGPIPE);add_signal(SIGTERM);add_signal(SIGINT);}//信号是否在信号掩码中int is_member(int sig){sigset_t old;pthread_sigmask(SIG_SETMASK, NULL, &old);return sigismember(&old, sig);}以上两个⽂件是信号处理模块的相关接⼝，使⽤⽅法如下：/*信号处理---在主线程⽣成多线程前阻塞所有信号，这样在⼦线程中可以继承主线程的信号处理，即阻塞所有信号*/ block_all_signal();/*初始化线程池*/thread_pool_init(thread_num);/*为主线程添加信号处理---⼦线程⽣成完成后，再由主线程接收对信号的处理*/ int pipefd[2];pipe(pipefd);set_pipe(pipefd[1]);main_thread_sig_hand();//在libevent统⼀的事件处理中，对信号进⾏处理//......event_set(&sig_event,pipefd[0], EV_READ|EV_PERSIST, sig_callback, NULL);//......void sig_callback(int fd,short ev,void *arg){char c[4];read(fd, c ,4);int sig = *(int*)c;switch(sig){case SIGHUP:fprintf(stderr,"receive SIGHUP\n");break;case SIGINT:fprintf(stderr,"receive SIGINT\n");break;case SIGTERM:fprintf(stderr,"receive SIGTERM\n");break;case SIGPIPE:fprintf(stderr,"receive SIGPIPE\n");break;}}。

LINUX信号处理1.信号概念信号是进程在运行过程中，由自身产生或由进程外部发过来的消息（事件）。

信号是硬件中断的软件模拟(软中断)。

每个信号用一个整型常量宏表示，以SIG开头，比如SIGCHLD、SIGINT等，它们在系统头文件<signal.h>中定义,也可以通过在shell下键入kill –l查看信号列表，或者键入man 7 signal查看更详细的说明。

信号的生成来自内核，让内核生成信号的请求来自3个地方：●用户：用户能够通过输入CTRL+c、Ctrl+\，或者是终端驱动程序分配给信号控制字符的其他任何键来请求内核产生信号；●内核：当进程执行出错时，内核会给进程发送一个信号，例如非法段存取(内存访问违规)、浮点数溢出等；●进程：一个进程可以通过系统调用kill给另一个进程发送信号，一个进程可以通过信号和另外一个进程进行通信。

由进程的某个操作产生的信号称为同步信号(synchronous signals),例如除0；由像用户击键这样的进程外部事件产生的信号叫做异步信号(asynchronous signals)。

进程接收到信号以后，可以有如下3种选择进行处理：●接收默认处理：接收默认处理的进程通常会导致进程本身消亡。

例如连接到终端的进程，用户按下CTRL+c，将导致内核向进程发送一个SIGINT的信号，进程如果不对该信号做特殊的处理，系统将采用默认的方式处理该信号，即终止进程的执行；signal(SIGINT,SIG_DFL)；●忽略信号：进程可以通过代码，显示地忽略某个信号的处理，例如：signal(SIGINT,SIG_IGN);但是某些信号是不能被忽略的；●捕捉信号并处理：进程可以事先注册信号处理函数，当接收到信号时，由信号处理函数自动捕捉并且处理信号。

有两个信号既不能被忽略也不能被捕捉，它们是SIGKILL和SIGSTOP。

即进程接收到这两个信号后，只能接受系统的默认处理，即终止进程。

Linux下多线程编程的互斥与同步是怎么回事本文将说明如何使用信号量实现线程之间的互斥与同步。

互斥锁只有0，1两中状态，适合于线程对共享资源的独占访问，很多时候每个资源可以同时被有限的线程访问，此时互斥锁将无法满足；条件变量同步也同样存在这种问题。

信号量实际是一种非负整型计数器，可以很好的控制线程之间资源访问，互斥锁能实现的功能，信号量同样可以。

信号量控制资源共享主要是PV原语操作， PV原语是对整数计数器信号量sem的操作。

一次 P操作使 sem减一，而一次 V操作使sem 加一。

进程（或线程）根据信号量的值来判断是否对公共资源具有访问权限。

当信号量sem 的值大于等于零时，该进程（或线程）具有公共资源的访问权限；相反，当信号量 sem的值小于零时，该进程（或线程）就将阻塞直到信号量 sem的值大于等于 0 为止。

Linux实现了POSIX 的无名信号量，主要用于线程间的互斥同步。

这里主要介绍几个常见函数。

· sem_init用于创建一个信号量，并能初始化它的值。

· sem_w ai t和sem_trywait相当于P操作，它们都能将信号量的值减一，两者的区别在于若信号量小于零时，sem_wait将会阻塞进程，而sem_trywait则会立即返回。

· sem_post相当于V操作，它将信号量的值加一同时发出信号唤醒等待的进程。

· sem_getvalue用于得到信号量的值。

· sem_destroy用于删除信号量。

所需头文件＃i nclude函数原型 int sem_init（sem_t *sem，int pshared，unsigned int value）sem：信号量pshared：决定信号量能否在几个进程间共享。

由于目前Linux还没有实现进程间共享信号量，所以这个值只能够取0value：信号量初始化值函数返回值成功：0 ，出错：-1所需头文件＃i nclude函数原型int sem_wait（sem_t *sem）int sem_trywait（sem_t *sem）int sem_post（sem_t *sem）int sem_getvalue（sem_t *sem）int sem_destroy（sem_t *sem）函数传入值 sem：信号量函数返回值成功：0 ，出错：-1从上面函数来看，实现线程之间同步信号量比互斥锁使用起来相对容易一些，操作简单，容易理解，适用范围广。

linux进程管理之信号处理(1)电脑资料信号是操作系统中一种很重要的通信方式.近几个版本中,信号处理这部份很少有大的变动.我们从用户空间的信号应用来分析Linux内核的信号实现方式.一:信号有关的数据结构在taskstruct中有关的信号结构:Sigsett的数据结构如下:在linux中共有64个信号.前32个为常规信号.后32个为实时信号.实时信号与常规信号的唯一区别就是实时信号会排队等候. structsigpending结构如下:Structsighandstruct的结构如下:同中断处理一样,每一个信号都对应action中的一个处理函数. structksigaction结构如下示:Structsignalstruct结构如下:上述所讨论的数据结构可以用下列图表示(摘自<>):二:更改信号的处理函数在用户空间编程的时候,我们常用的信号处理函数的API有:两者都可以更改信号.sigaction是Unix后期才出现的接口.这个接口较signal()更为强健也更为强大:Signal()只能为指定的信号设置信号处理函数.而sigaction()不仅可以设置信号处理函数,还可以设置进程的信号掩码.返回设置之前的sigaction结构.sigaction结构在上面已经分析过了.这两个用户空间的接口对应的系统调用为别是:syssignal(intsig,sighandlerthandler)syssigaction(intsig,con ststructoldsigactionuser*act,structoldsigactionuser*oact)我们来分析一下内核是怎么样处理的.syssignal()代码如下:syssigaction()的代码如下:由此可以看出,两个函数最终都会调用dosigaction()进行处理.该函数代码如下:Rmfromqueuefull()用来将等待队列中的信号删除.并去除等待队列中的位图.代码如下:上面有关POSIX标准,请自行查阅相关资料.三:发送信号在用户空间中,我们可以用kill()给指定进程发送相应信号.它在用户空间的定义如下所示:intkill(pidtpid,intsigno)pid的含义如下所示:pid>0将信号发送给进程ID为pid的进程，pid==0将信号发送给其进程组ID等于发送进程的进程组ID，而且发送进程有许可权向其发送信号的所有进程。

LINUX信号处理－信号概念【ITjob课程资料】信号概念信号全称为软中断信号，也有人称作软中断。

1、信号可以由内核在内存段冲突、浮点处理器错误或非法指令的时候发出。

2、信号也可以由用户进程发出，是进程间通讯的一种最老的实现方式。

2.1、SHELL输入，比如：CTRL+c、Ctrl+\2.2、进程调用kill函数发出。

1、系统所有的信号可以在头文件<asm/signal.h>中查询到2、可以通过在shell下键入kill –l查看信号列表3、或者键入man 7 signal查看更详细的说明signal信号处理函数函数signal捕捉信号，并进行处理。

原型为：#include <signal.h>typedef void (*sighandler_t)(int);参数：信号值sighandler_t signal(int signum, sighandler_t handler);参数： signum：捕捉的信号handler：1、函数指针2、SIG_DFL：缺省处理3、SIG_IGN：忽略信号返回值：1、函数的地址：成功2、SIG_ERR：失败信号的生命周期：示例1：#include <stdio.h>#include <signal.h>void SignHandler(int iSignNo){printf("Capture sign no:%d\n",iSignNo);}int main(){signal(SIGINT,SignHandler);getchar();return 0;}kill函数发送信号#include <signal.h>int kill(pid_t pid, int sig);参数：pid：接受信号的进程的pidsig：发送的信号值返回值：成功，返回0，否则为-1案例1：#include <signal.h>int main(int argc, char* argv[]){int pid = atoi(argv[1]);kill(pid,SIGQUIT);return 0;}注意：需要通过ps –a指令查看到相应的进程号利用可靠信号进行进程通信1－31是不可靠信号，可能会造成信号丢失，而31之后的信号是可靠信号。

Linux 多线程应用中如何编写安全的信号处理函数简介：关于代码的可重入性，设计开发人员一般只考虑到线程安全，异步信号处理函数的安全却往往被忽略。

本文首先介绍如何编写安全的异步信号处理函数；然后举例说明在多线程应用中如何构建模型让异步信号在指定的线程中以同步的方式处理。

Linux 多线程应用中编写安全的信号处理函数在开发多线程应用时，开发人员一般都会考虑线程安全，会使用pthread_mutex去保护全局变量。

如果应用中使用了信号，而且信号的产生不是因为程序运行出错，而是程序逻辑需要，譬如SIGUSR1、SIGRTMIN 等，信号在被处理后应用程序还将正常运行。

在编写这类信号处理函数时，应用层面的开发人员却往往忽略了信号处理函数执行的上下文背景，没有考虑编写安全的信号处理函数的一些规则。

本文首先介绍编写信号处理函数时需要考虑的一些规则；然后举例说明在多线程应用中如何构建模型让因为程序逻辑需要而产生的异步信号在指定的线程中以同步的方式处理。

回页首线程和信号Linux 多线程应用中，每个线程可以通过调用pthread_sigmask()设置本线程的信号掩码。

一般情况下，被阻塞的信号将不能中断此线程的执行，除非此信号的产生是因为程序运行出错如SIGSEGV；另外不能被忽略处理的信号SIGKILL 和SIGSTOP 也无法被阻塞。

当一个线程调用pthread_create()创建新的线程时，此线程的信号掩码会被新创建的线程继承。

POSIX.1 标准定义了一系列线程函数的接口，即POSIX threads(Pthreads)。

Linux C 库提供了两种关于线程的实现：LinuxThreads和NPTL(Native POSIX Threads Library)。

LinuxThreads已经过时，一些函数的实现不遵循POSIX.1 规范。

NPTL 依赖Linux 2.6 内核，更加遵循POSIX..1 规范，但也不是完全遵循。

多线程中的信号处理 在linux下写服务器，处理信号在所难免。

在多线程和单线程中信号的处理还是有点不同的。

参考： 在linux下，每个进程都有⾃⼰的signal mask，这个信号掩码指定哪个信号被阻塞，哪个不会被阻塞，通常⽤调⽤sigmask来处理。

同时每个进程还有⾃⼰的signal action，这个⾏为集合指定了信号该如何处理，通常调⽤sigaction来处理。

使⽤了多线程后，便有些疑问：1. 信号发⽣时，哪个线程会收到2. 是不是每个线程都有⾃⼰的mask及action3. 每个线程能按⾃⼰的⽅式处理信号么 ⾸先，信号的传递是根据情况⽽定的：如果是异常产⽣的信号（⽐如程序错误，像SIGPIPE、SIGEGV这些），则只有产⽣异常的线程收到并处理。

如果是⽤pthread_kill产⽣的内部信号，则只有pthread_kill参数中指定的⽬标线程收到并处理。

如果是外部使⽤kill命令产⽣的信号，通常是SIGINT、SIGHUP等job control信号，则会遍历所有线程，直到找到⼀个不阻塞该信号的线程，然后调⽤它来处理。

(⼀般从主线程找起)，注意只有⼀个线程能收到。

其次，每个线程都有⾃⼰独⽴的signal mask，但所有线程共享进程的signal action。

这意味着，你可以在线程中调⽤pthread_sigmask(不是sigmask)来决定本线程阻塞哪些信号。

但你不能调⽤sigaction来指定单个线程的信号处理⽅式。

如果在某个线程中调⽤了sigaction处理某个信号，那么这个进程中的未阻塞这个信号的线程在收到这个信号都会按同⼀种⽅式处理这个信号。

另外，注意⼦线程的mask是会从主线程继承⽽来的。

第三个问题，因为signal action共享的问题，已经知道不能。

下⾯以⼀个例⼦说明：/*threadsig.c*/#include <signal.h>#include <pthread.h>#include <stdio.h>#include <stdlib.h>#include <string.h>void sighandler(int signo);void *thr1_fn(void *arg){struct sigaction action;action.sa_flags = 0;action.sa_handler = sighandler;sigaction(SIGINT, &action, NULL);pthread_t tid = pthread_self();int rc;printf("thread 1 with tid:%lu\n", tid);rc = sleep(60);if (rc != 0)printf("thread 1... interrupted at %d second\n", 60 - rc);printf("thread 1 ends\n");return NULL;}void *thr2_fn(void *arg){struct sigaction action;pthread_t tid = pthread_self();int rc, err;printf("thread 2 with tid:%lu\n", tid);action.sa_flags = 0;action.sa_handler = sighandler;err = sigaction(SIGALRM, &action, NULL);rc = sleep(60);if (rc != 0)printf("thread 2... interrupted at %d second\n", 60 - rc);printf("thread 2 ends\n");return NULL;}void *thr3_fn(void *arg){pthread_t tid = pthread_self();sigset_t mask;int rc, err;printf("thread 3 with tid%lu\n", tid);sigemptyset(&mask); /* 初始化mask信号集 */sigaddset(&mask, SIGALRM);err = pthread_sigmask(SIG_BLOCK, &mask, NULL);if (err != 0){printf("%d, %s/n", rc, strerror(rc));return NULL;}rc = sleep(10);if (rc != 0)printf("thread 3... interrupted at %d second\n", 60 - rc);err = pthread_sigmask( SIG_UNBLOCK,&mask,NULL );if ( err != 0 ){printf("unblock %d, %s/n", rc, strerror(rc));return NULL;}rc = sleep(10);if (rc != 0)printf("thread 3... interrupted at %d second after unblock\n", 60 - rc);printf("thread 3 ends\n");return NULL;return NULL;}intmain(void){int rc, err;pthread_t thr1, thr2, thr3, thrm = pthread_self();printf("thread main with pid %lu\n",thrm);err = pthread_create(&thr1, NULL, thr1_fn, NULL);if (err != 0) {printf("error in creating pthread:%d\t%s\n",err, strerror(rc));exit(1);}/* pthread_kill(thr1, SIGALRM); send a SIGARLM signal to thr1 before thr2 set the signal handler, then the whole process will be terminated*/ err = pthread_create(&thr2, NULL, thr2_fn, NULL);if (err != 0) {printf("error in creating pthread:%d\t%s\n",err, strerror(rc));exit(1);}err = pthread_create(&thr3, NULL, thr3_fn, NULL);if (err != 0) {printf("error in creating pthread:%d\t%s\n",err, strerror(rc));exit(1);}sleep(10);//内部产⽣的信号，只有指定的线程能收到，因此要向所有线程发送pthread_kill(thr1, SIGALRM);pthread_kill(thr2, SIGALRM);pthread_kill(thr3, SIGALRM);pthread_kill(thr3, SIGALRM);pthread_kill(thr3, SIGALRM);sleep(5);pthread_join(thr1, NULL); /*wait for the threads to complete.*/pthread_join(thr2, NULL);pthread_join(thr3, NULL);printf("main ends\n");return0;}voidsighandler(int signo){pthread_t tid = pthread_self();printf("thread with pid:%lu receive signo:%d\n", tid, signo);return;}在上⾯的代码中，主线程创建三个线程。

Linux命令技巧使用多线程和并行处理提高效率Linux命令是Linux操作系统中的重要组成部分，通过灵活运用Linux命令的技巧，可以提高工作效率和操作效果。

本文将介绍如何使用多线程和并行处理的技巧来提高效率。

一、多线程与并行处理的概念多线程和并行处理是在计算机领域中常见的概念，它们可以提高任务的执行效率。

1. 多线程：多线程是指在一个进程中同时执行多个线程，每个线程独立执行自己的任务。

多线程的优势在于提高了并发执行的能力，可以更好地利用多核处理器的性能。

2. 并行处理：并行处理是指将一个任务分成多个子任务，分别由多个处理器同时完成，最后将结果进行合并。

并行处理的优势在于缩短了任务的执行时间，提高了整体的处理能力。

二、使用多线程和并行处理的技巧1. 使用GNU Parallel命令进行并行处理：GNU Parallel是一个用于并行执行命令的工具，它可以将一个任务分成多个子任务，并在多个CPU核心上同时执行。

使用GNU Parallel 可以显著加快任务的执行速度。

使用示例：```$ parallel command ::: arg1 arg2 arg3```其中，command是需要执行的命令，arg1、arg2、arg3是命令的参数。

通过并行处理，可以同时执行多个命令，提高任务的执行效率。

2. 使用xargs命令实现多线程：xargs命令是用来将标准输入数据转化成命令行参数的一个过滤器，它可以将一个命令应用到多个参数上。

通过xargs命令，可以实现多线程的效果，快速处理多个任务。

使用示例：```$ cat file.txt | xargs -P 5 -I {} command {}```其中，file.txt是需要处理的文件名，-P 5表示启动5个线程，command是需要执行的命令。

通过xargs命令，可以将文件中的内容按行分成多个参数，然后使用多个线程同时执行命令，提高处理效率。

3. 使用GNU parallel命令和xargs命令的结合：GNU Parallel和xargs命令都是用于多线程和并行处理的工具，它们的结合可以进一步提高效率。