Linux学习第十一天

最新推荐文章于 2023-04-17 10:39:21 发布
最新推荐文章于 2023-04-17 10:39:21 发布
阅读量265 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yanmengqi0/article/details/94500970
这篇博客回顾了Linux学习的第十一课，重点讲解了信号处理（如使用sigaction实现重入）和线程相关概念。内容包括线程创建、清理、同步与互斥，涉及互斥锁的初始化、加锁、解锁操作，以及线程锁在进程间共享和错误检查的应用。还探讨了条件变量在多线程等待与激发中的作用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、昨日回顾

1、信号处理sigaction

2、使用sigaction如何实现不断重入效果？

 struct sigaction act;

 act.sa_flags=SA_SIGINFO|SA_NODEFER;

3、想在2号信号的处理流程过程中，屏蔽3号信号

 struct sigaction act;

 act.sa_flags=SIGINFO;

 act.sa_sigaction=sig_Func;

 

 sigemptyset(&act.sa_mask);

 sigaddset(&act.sa_mask,SIGQUIT);

4、如何设置信号屏蔽？

 sigset_t mask;

 sigemptyset(&mask);

 sigaddset(&mask,SIGQUIT);//设置屏蔽信号

 sigprocmask(SIG_BLOCK,&mask,NULL);//增加屏蔽

 sleep(3);

 sigpromask(SIG_UNBLOCK,&mask,NULL);//解除屏蔽

5、线程pthread

（1）线程创建pthread_create(&pthid,NULL,thread_Func,NULL);

（2）线程退出pthread_exit((void)*2)

（3）线程合并

 long threadRet;

 pthread_join(pthid,(void**)&threadPRet);

 

 

二、上午内容

1、线程清理

（1）查看清理函数的执行顺序

①代码示例pthread_cleanup_exec.c(已完成)

 

#include"func.h"

void cleanup(void*p)

{

    printf("I am cleanup %ld\n",(long)p);

 

}

 

void *thread_Func(void *p)

{

    pthread_cleanup_push(cleanup,(void*)1);

    pthread_cleanup_push(cleanup,(void*)2);

    pthread_exit(NULL);

    pthread_cleanup_pop(1);

    pthread_cleanup_pop(2);

 

}

int main(int argc, char* argv[])

{

    pthread_t pthid;

    int ret=pthread_create(&pthid,NULL,thread_Func,NULL);

 

    long threadRet;

    ret=pthread_join(pthid,(void **)&threadRet);

    THREAD_ERROR_CHECK(ret,"pthread_join");

 

    printf("threadRet=%ld",threadRet);

    return 0;

}

 

 

Ⅰ先压栈的清理函数后执行

Ⅱ该功能使用的是清理栈

 

②工作的时候如何写清理资源？

代码示例pthread_cleanup_malloc.c（已完成）

 

#include"func.h"

void cleanup(void*p)

{

    free(p);

    printf("I am cleanup\n");

 

}

 

void *thread_Func(void *p)

{

    p=malloc(20);

    pthread_cleanup_push(cleanup,p);

    sleep(1);

    pthread_cleanup_pop(1);

    pthread_exit(NULL);

 

}

int main(int argc, char* argv[])

{

    pthread_t pthid;

    int ret=pthread_create(&pthid,NULL,thread_Func,NULL);

 

    long threadRet;

    ret=pthread_join(pthid,(void **)&threadRet);

    THREAD_ERROR_CHECK(ret,"pthread_join");

 

    printf("threadRet=%ld",threadRet);

    return 0;

}

 

2、线程的同步与互斥：双方互斥进行

（1）互斥锁

①锁的初始化

Ⅰ使用函数

pthread_mutex_t mutex;

pthread_mutex_init;

 

②加锁操作

Ⅰ使用函数pthread_mutex_lock();

Ⅱ代码示例pthread_add2000.c

 

#include <func.h>

#define N 20000000

typedef struct{

    int val;

    pthread_mutex_t mutex;

}Data_t;

void* threadFunc(void* p)

{

    int i;

    Data_t* threadInfo=(Data_t*)p;

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

    {

        pthread_mutex_lock(&threadInfo->mutex);

        threadInfo->val+=1;

        pthread_mutex_unlock(&threadInfo->mutex);

    }

}

int main(int argc,char* argv[])

{

    pthread_t pthid;

    int ret;

    Data_t threadInfo;

    threadInfo.val=0;

    ret=pthread_mutex_init(&threadInfo.mutex,NULL);

    THREAD_ERROR_CHECK(ret,"pthread_mutex_init");

    struct timeval start,end;

    gettimeofday(&start,NULL);

    ret=pthread_create(&pthid,NULL,threadFunc,&threadInfo);

    THREAD_ERROR_CHECK(ret,"pthread_create");

    int i;

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

    {

        pthread_mutex_lock(&threadInfo.mutex);

        threadInfo.val+=1;

        pthread_mutex_unlock(&threadInfo.mutex);

    }

    pthread_join(pthid,NULL);//等待子线程

    gettimeofday(&end,NULL);

    printf("I am main thread,val=%d,use time=%ld\n",threadInfo.val,(end.tv_sec-start.tv_sec)*1000000+end.tv_usec-start.tv_usec);

    return 0;

}

 

 

③解锁操作

Ⅰ代码例子pthread_mutex_trylock.c

 

#include <func.h>

typedef struct{

    pthread_mutex_t mutex;

}Data_t;

void* threadFunc(void* p)

{

    Data_t* pArg=(Data_t*)p;

    int ret=pthread_mutex_trylock(&pArg->mutex);

    CHILD_THREAD_ERROR_CHECK(ret,"pthread_mutex_trylock");

    printf("child lock success\n");

    pthread_exit(NULL);

}

int main(int argc,char* argv[])

{

    Data_t threadInfo;

    pthread_t pthid;

    pthread_mutex_init(&threadInfo.mutex,NULL);

    pthread_create(&pthid,NULL,threadFunc,&threadInfo);

    pthread_mutex_lock(&threadInfo.mutex);

    printf("main thread lock success\n");

    int ret=pthread_join(pthid,NULL);

    THREAD_ERROR_CHECK(ret,"pthread_join");

    return 0;

}

 

 

④测试加锁

Ⅰ代码示例sem_add1000.c

 

#include <func.h>

#define N 20000000

int main(int argc,char* argv[])

{

    int semArrId=semget(1000,1,IPC_CREAT|0600);

    ERROR_CHECK(semArrId,-1,"semget");                                                                                   

    int shmid;

    shmid=shmget(1000,1<<20,IPC_CREAT|0600);

    ERROR_CHECK(shmid,-1,"shmget");

    int *p;

    p=(int*)shmat(shmid,NULL,0);

    ERROR_CHECK(p,(int*)-1,"shmat");

    *p=0;

    int ret=semctl(semArrId,0,SETVAL,1);

    ERROR_CHECK(ret,-1,"semctl");

    struct sembuf sopp,sopv;

    sopp.sem_num=0;

    sopp.sem_op=-1;

    sopp.sem_flg=SEM_UNDO;

    sopv.sem_num=0;

    sopv.sem_op=1;

    sopv.sem_flg=SEM_UNDO;

    struct timeval start,end;

    gettimeofday(&start,NULL);

    if(!fork())

    {

        int i;

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

        {

            //加锁

            semop(semArrId,&sopp,1);

            p[0]=p[0]+1;

            semop(semArrId,&sopv,1);

            //解锁

        }

    }else{

        int i;

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

        {

            semop(semArrId,&sopp,1);

            p[0]=p[0]+1;

            semop(semArrId,&sopv,1);

        }

        wait(NULL);

        gettimeofday(&end,NULL);

        printf("result=%d,use time=%ld\n",p[0],(end.tv_sec-start.tv_sec)*1000000+end.tv_usec-start.tv_usec);

    }

    return 0;

}

 

 

 

(2)别人加的锁，可以解开吗？

①

Ⅰ代码例子pthread_mutex_trylock.c

 

#include <func.h>

typedef struct{

    pthread_mutex_t mutex;

}Data_t;

void* threadFunc(void* p)

{

    Data_t* pArg=(Data_t*)p;

    int ret=pthread_mutex_trylock(&pArg->mutex);

    CHILD_THREAD_ERROR_CHECK(ret,"pthread_mutex_trylock");

    printf("child lock success\n");

    pthread_exit(NULL);

}

int main(int argc,char* argv[])

{

    Data_t threadInfo;

    pthread_t pthid;

    pthread_mutex_init(&threadInfo.mutex,NULL);

    pthread_create(&pthid,NULL,threadFunc,&threadInfo);

    pthread_mutex_lock(&threadInfo.mutex);

    printf("main thread lock success\n");

    int ret=pthread_join(pthid,NULL);

    THREAD_ERROR_CHECK(ret,"pthread_join");

    return 0;

}

 

 

Ⅱ代码例子pthread_mutex_unlock_other.c

 

#include <func.h>

typedef struct{

    pthread_mutex_t mutex;

}Data_t;

void* threadFunc(void* p)

{

    Data_t* pArg=(Data_t*)p;

    pthread_mutex_unlock(&pArg->mutex);

    pthread_mutex_lock(&pArg->mutex);

    printf("child lock success\n");

    pthread_exit(NULL);

}

int main(int argc,char* argv[])

{

    Data_t threadInfo;

    pthread_t pthid;

    pthread_mutex_init(&threadInfo.mutex,NULL);

    pthread_create(&pthid,NULL,threadFunc,&threadInfo);

    pthread_mutex_lock(&threadInfo.mutex);

    printf("main thread lock success\n");

    int ret=pthread_join(pthid,NULL);

    THREAD_ERROR_CHECK(ret,"pthread_join");

    return 0;

}

 

 

锁传递，应该传递地址

 

 

3、使用线程锁统计时间

 

三、下午的内容

1、如何加锁？

①加两次锁

使用命令pthread_mutex_lock

代码例子pthread_mutex_locktwice.c（已完成）

给锁加两次锁

#include"func.h"

 

int main(int argc,char* argv[])

{

    pthread_mutex_t mutex;//定义锁

    pthread_mutexattr_t mattr;//定义互斥锁属性

   

    int ret;//定义返回值

    ret=pthread_mutexattr_init(&mattr);//初始化互斥锁属性

    THREAD_ERROR_CHECK(ret,"pthread_mutexattr_init");//错误检查

 

    pthread_mutexattr_settype(&mattr,PTHREAD_MUTEX_RECURSIVE);//设置互斥锁属性类型

    pthread_mutex_init(&mutex,&mattr);//初始化互斥锁

    pthread_mutex_lock(&mutex);//第一次加锁

    ret=pthread_mutex_lock(&mutex);//第二次加锁，得到返回值

    THREAD_ERROR_CHECK(ret,"pthread_mutex_lock");//错误检查

    printf("you can see me\n");//打印输出

    return 0;

 

}

 

 

②如何检测是否有错误

代码示例thread_mutex_errorcheck.c

避免对同一把锁加锁两次

 

#include <func.h>

 

int main(int argc,char* argv[])

{

    pthread_mutex_t mutex;

    pthread_mutexattr_t mattr;

    int ret;

    ret=pthread_mutexattr_init(&mattr);

    THREAD_ERROR_CHECK(ret,"pthread_mutexattr_init");

    pthread_mutexattr_settype(&mattr,PTHREAD_MUTEX_ERRORCHECK);//允许同一个线程对同一把锁加锁多次

    pthread_mutex_init(&mutex,&mattr);

    pthread_mutex_lock(&mutex);

    ret=pthread_mutex_lock(&mutex);

    THREAD_ERROR_CHECK(ret,"pthread_mutex_lock");

    printf("you can see me\n");

    return 0;

}

 

 

③使用进程锁进行2000万加法。

代码示例fork_mutex.c

 

#include <func.h>

#define N 20000000

typedef struct{

    int val;

    pthread_mutex_t mutex;

}Data_t,*pData_t;

int main(int argc,char* argv[])

{

    int semArrId=semget(1000,1,IPC_CREAT|0600);

    ERROR_CHECK(semArrId,-1,"semget");                                                                                   

    int shmid;

    shmid=shmget(1000,1<<20,IPC_CREAT|0600);

    ERROR_CHECK(shmid,-1,"shmget");

    pData_t p;

    p=(pData_t)shmat(shmid,NULL,0);

    ERROR_CHECK(p,(pData_t)-1,"shmat");

    p->val=0;

    pthread_mutexattr_t mattr;

    pthread_mutexattr_init(&mattr);

    pthread_mutexattr_setpshared(&mattr,PTHREAD_PROCESS_SHARED);//设置为进程共享

    int ret=pthread_mutex_init(&p->mutex,&mattr);

    THREAD_ERROR_CHECK(ret,"pthread_mutex_init");

    struct timeval start,end;

    gettimeofday(&start,NULL);

    if(!fork())

    {

        int i;

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

        {

            //加锁

            pthread_mutex_lock(&p->mutex);

            p->val+=1;

            pthread_mutex_unlock(&p->mutex);

            //解锁

        }

    }else{

        int i;

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

        {

            pthread_mutex_lock(&p->mutex);

            p->val+=1;

            pthread_mutex_unlock(&p->mutex);

        }

        wait(NULL);

        gettimeofday(&end,NULL);

        printf("result=%d,use time=%ld\n",p->val,(end.tv_sec-start.tv_sec)*1000000+end.tv_usec-start.tv_usec);

    }

    return 0;

}

 

 

tips：

Ⅰ锁使用的区域是在共享内存内

Ⅱ在加锁代码中，先加锁，在执行操作，之后再解锁

 

④代码示例sale_tickets.c

 

#include <func.h>

typedef struct{

    int tickets;

    pthread_mutex_t mutex;

}Data_t;

void cleanup(void *p)

{

    pthread_mutex_unlock((pthread_mutex_t*)p);

    printf("unlock success\n");

}

 

void* saleWindows1(void* p)

{

    Data_t* pArg=(Data_t*)p;

    int i=0;

    while(1)

    {

        pthread_mutex_lock(&pArg->mutex);

        if(pArg->tickets>0)

        {

            //printf("I am saleWindows1 start sale,%d\n",pArg->tickets);

            pArg->tickets--;

            i++;

            //printf("I am saleWindows1 sale finish,%d\n",pArg->tickets);

            pthread_mutex_unlock(&pArg->mutex);

        }else{

            pthread_mutex_unlock(&pArg->mutex);

            printf("I am saleWindows1,%d\n",i);

            break;

        }

    }

    return NULL;

}

void* saleWindows2(void* p)

{

    Data_t* pArg=(Data_t*)p;

    int i=0;

    while(1)

    {

        pthread_mutex_lock(&pArg->mutex);

        if(pArg->tickets>0)

        {

            //printf("I am saleWindows2 start sale,%d\n",pArg->tickets);

            pArg->tickets--;

            i++;

            //printf("I am saleWindows2 sale finish,%d\n",pArg->tickets);

            pthread_mutex_unlock(&pArg->mutex);

        }else{

            pthread_mutex_unlock(&pArg->mutex);

            printf("I am saleWindows2,%d\n",i);

            break;

        }

    }

    return NULL;

}

int main(int argc,char* argv[])

{

    Data_t threadInfo;

    threadInfo.tickets=20000000;

    pthread_t pthid,pthid1;

    pthread_mutex_init(&threadInfo.mutex,NULL);

    pthread_create(&pthid,NULL,saleWindows1,&threadInfo);

    pthread_create(&pthid1,NULL,saleWindows2,&threadInfo);

    int ret;

    long threadRet;

    ret=pthread_join(pthid1,(void**)&threadRet);

    THREAD_ERROR_CHECK(ret,"pthread_join");

    ret=pthread_join(pthid,(void**)&threadRet);

    THREAD_ERROR_CHECK(ret,"pthread_join");

    printf("sale over\n");

    return 0;

}

 

tips：

Ⅰ在判断有没有票之前，就要加一个锁

 

 

2、条件变量

（1）两个线程要设置等待和激发

Ⅰ等待条件有两种方式：无条件等待和有条件等待

Ⅱ通过这种方式，就可以实现线程同步

 

！！要注意区别：进程间通信和进程间的同步

进程间的同步：可以通过管道、消息队列、或者信号量实现

①等待与激发

Ⅰ首先要初始化一个参数

代码示例：（子线程等待，主线程执行）

Pthread_cond.c

#include <func.h>

typedef struct{

    pthread_mutex_t mutex;

    pthread_cond_t cond;

}Data_t,*pData_t;

void* threadFunc(void* p)

{

    pData_t pArg=(pData_t)p;

    pthread_mutex_lock(&pArg->mutex);

    pthread_cond_wait(&pArg->cond,&pArg->mutex);

    pthread_mutex_unlock(&pArg->mutex);

    printf("I am child thread wake up\n");

    pthread_exit(NULL);

}

int main(int argc,char* argv[])

{

    Data_t threadInfo;

    pthread_mutex_init(&threadInfo.mutex,NULL);

    pthread_cond_init(&threadInfo.cond,NULL);

    pthread_t pthid;

    pthread_create(&pthid,NULL,threadFunc,&threadInfo);

    usleep(5000);

    pthread_cond_signal(&threadInfo.cond);//让条件变量成立

    pthread_join(pthid,NULL);

    printf("I am main thread\n");

    return 0;

}

 

 

②一个函数

上半部：

Ⅰ排队在对应的cond

Ⅱ解锁

Ⅲ睡觉

 

下半部

Ⅰ醒来

Ⅱ加锁

Ⅲ返回

 

 

③

Ⅰ条件变量初始化:pthread_cond_init

Ⅱ让条件变量成立pthread_cond_signal//让条件变量成立

 

tips：内核真正在调度的时候，调度单位是内核线程

 

④新的代码示例pthread_cond_twowait.c

 

#include <func.h>

typedef struct{

    pthread_mutex_t mutex;

    pthread_cond_t cond;

}Data_t,*pData_t;

void cleanup(void *p)

{

    pthread_mutex_unlock((pthread_mutex_t*)p);

    printf("unlock ok\n");

}

void* threadFunc(void* p)

{

    pData_t pArg=(pData_t)p;

    pthread_mutex_lock(&pArg->mutex);

    pthread_cleanup_push(cleanup,&pArg->mutex);

    pthread_cond_wait(&pArg->cond,&pArg->mutex);

    printf("wait return\n");

    pthread_cleanup_pop(1);

    printf("I am child thread wake up\n");

    pthread_exit(NULL);

}

#define N 2

int main(int argc,char* argv[])

{

    Data_t threadInfo;

    pthread_mutex_init(&threadInfo.mutex,NULL);

    pthread_cond_init(&threadInfo.cond,NULL);

    pthread_t pthid[N];

    int i;

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

    {

        pthread_create(pthid+i,NULL,threadFunc,&threadInfo);

    }

    int ret;

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

    {

        ret=pthread_cancel(pthid[i]);

        THREAD_ERROR_CHECK(ret,"pthread_cancel");

    }

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

    {

        pthread_join(pthid[i],NULL);

    }

    printf("I am main thread\n");

    return 0;

}

 

 

tips：

Ⅰ多个线程在等待，代码示例是2个线程在等待

Ⅱ如何解决无法cancel线程的问题？使用cleanup，其中push放在wait前边，pop放在wait后边；要注意，要定义一个cleanup函数

 

⑤超时等待，代码示例

Pthread_cond_timedwait.c

 

#include <func.h>

typedef struct{

    pthread_mutex_t mutex;

    pthread_cond_t cond;

}Data_t,*pData_t;

void* threadFunc(void* p)

{

    pData_t pArg=(pData_t)p;

    struct timespec t;

    t.tv_sec=time(NULL)+3;

    t.tv_nsec=0;

    int ret;

    pthread_mutex_lock(&pArg->mutex);

    ret=pthread_cond_timedwait(&pArg->cond,&pArg->mutex,&t);

    pthread_mutex_unlock(&pArg->mutex);

    printf("I am child thread wake up,ret=%d\n",ret);

    pthread_exit(NULL);

}

int main(int argc,char* argv[])

{

    Data_t threadInfo;

    pthread_mutex_init(&threadInfo.mutex,NULL);

    pthread_cond_init(&threadInfo.cond,NULL);

    pthread_t pthid;

    pthread_create(&pthid,NULL,threadFunc,&threadInfo);

    sleep(1);

    pthread_cond_signal(&threadInfo.cond);

    pthread_join(pthid,NULL);

    printf("I am main thread\n");

    return 0;

}

颜颜颜M
关注
linux 信号
隙光
11-02 1627
一、概念 信号是运载消息的工具，是消息的载体。在linux世界中，信号是进程间通信的方式之一，它提供了处理异步事件的一种方法。信号是软中断，一个进程收到某信号后可以执行一个信号处理函数（捕捉信号），与CPU收到一个中断请求在原理上是一样的。进程收到信号后，也可以采用系统的默认动作，忽略信号、终止或停止进程。但是有两个信号是不能被忽略和捕捉：SIGKILL和SIGSTOP。 早期的信号机制只是一
linux系统编程之信号（四）：信号的捕捉与sigaction函数
Meditation
05-19 2万+
一、内核如何实现信号的捕捉 如果信号的处理动作是用户自定义函数，在信号递达时就调用这个函数，这称为捕捉信号。由于信号处理函数的代码是在用户空间的，处理过程比较复杂，举例如下： 1. 用户程序注册了SIGQUIT信号的处理函数sighandler。 2. 当前正在执行main函数，这时发生中断或异常切换到内核态。 3. 在中断处理完毕后要返回用户态的main函数之前检查到有信号SIGQUIT
Linux应用编程（信号基础）
afddasfa的博客
04-17 795
也就是说当进程此时正在执行某个信号的处理函数，默认情况下，进程会自动将该信号添加到进程的信号掩码字段中，从而在执行信号处理函数期间阻塞该信号，默认情况下，我们期望进程在处理一个信号时阻塞同种信号，否则引起一些竞态条件；如果进程当前正在执行信号处理函数，在处理信号期间接收到了新的信号，如果该信号是信号掩码中的成员，那么内核会将其阻塞，将该信号添加到进程的等待信号集（等待被处理，处于等待状态的信号）中，为了确定进程中处于等待状态的是哪些信号，可以使用 sigpending()函数获取。带着这个问题来聊一聊。
linux信号处理handler2,linux进程管理之信号处理(2) -电脑资料
weixin_31139479的博客
05-14 526
另外,内核经常使用force_sig_info()/force_sig()来给进程发送信号.这样的信号经常不可以忽略,不可以阻塞.我们来看一下它的处理.代码如下:int force_sig_info(int sig, struct siginfo *info, struct task_struct *t){ unsigned long int flags; int ret, blo...
sigaction介绍
WangIcter的专栏
08-04 2682
sigaction 原型： int sigaction(int signo,const struct sigaction *restrict act, struct sigaction *restrict oact); @signo 信号编号 @act 要注册的信号动作 @oact 原信号动作
linux SA_RESTART的问题
fay8048的博客
04-08 8456
<br />信号是异步的，它会在程序的任何地方发生。由此程序正常的执行路径被打破，去执行信号处理函数。<br /> 一般情况下 ，进程正在执行某个系统调用，那么在该系统调用返回前信号是不会被递送的。但慢速系统调用除外，如读写终端、网络、磁盘，以及wait和pause。这些系 统调用都会返回-1，errno置为EINTR当系统调用被中断时，我们可以选择使用循环再次调用，或者设置重新启动该系统调用 (SA_RESTART)。<br />现在说说对上面话的理解：<br />我认为函数或进程的运行最
linux中sigaction函数详解
热门推荐
魏波
08-04 10万+
一、函数原型：sigaction函数的功能是检查或修改与指定信号相关联的处理动作（可同时两种操作） int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); signum参数指出要捕获的信号类型，act参数指定新的信号处理方式，oldact参数...
linux进程信号处理函数signal和sigaction
迷失的专栏
08-21 4214
Linux中signal函数说明： NAME        signal - ANSI C signal handling SYNOPSIS        #include        typedef void (*sighandler_t)(int);        sighandler_t signal(int signum, sighandler_t
sigaction函数 和 sigqueue函数(信号的发送和安装)
qq_38813056的博客
12-24 1204
    [1]sigqueue(发送信号)          int sigqueue(pid_t pid, int sig, const union sigval value); 参数: pid:     要发送信号的进程ID                  sig:      要发送的信号               value: 发送的伴随数据,该参数的数据类型是联合体        ...
linux c学习笔记----信号(sigaction,sigaddset,sigprocmask)
weixin_43667308的博客
12-31 2901
sigaction（查询或设置信号处理方式） 相关函数 signal，sigprocmask，sigpending，sigsuspend 表头文件 #include&amp;lt;signal.h&amp;gt; 定义函数 int sigaction(int signum,const struct sigaction *act ,struct sigaction *oldact); 函数说明 sigaction(...
linux下sigaction函数解析功能作用
nb_zsy的博客
06-15 565
原文链接：linux中sigaction函数详解 一、函数原型：sigaction函数的功能是检查或修改与指定信号相关联的处理动作（可同时两种操作） int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); signum参数指出要捕获的信号类型，act参数指定新的信号处理方式，oldact参数输出先前信号的处理方式（如果不为NULL的话）。 二、 struc
sigaction函数解析
stormbjm的专栏
09-03 8079
sigaction函数的功能是检查或修改与指定信号相关联的处理动作（可同时两种操作）。 他是POSIX的信号接口，而signal()是标准C的信号接口(如果程序必须在非POSIX系统上运行，那么就应该使用这个接口) 给信号signum设置新的信号处理函数act， 同时保留该信号原有的信号处理函数oldact int sigaction(int signo,
signal函数和sigaction结构体理解
我的新博客
04-08 8107
signal函数和sigaction结构体理解 一，signal函数 详细介绍: http://blog.youkuaiyun.com/ta893115871/article/details/7475095 #include #include #include /* SIG_IGN忽略/SIG_DFL默认，这俩宏也可以作为信号处理函数。同时SIGSTOP/SIGKILL这俩信号
linux信号（4）：信号安装函数sigaction和信号发送函数sigqueue
Alatebloomer的博客
08-18 823
Sigaction 信号安装   signaction 和signal都是信号安装函数 #include &lt;signal.h&gt; int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); 功能:    sigaction函数用于改...
Linux中的31个普通信号
2021dragon的博客
12-18 3773
Linux中31个普通信号各自的含义。 信号编号 信号名 信号含义 1 SIGHUP 如果终端接口检测到一个连接断开，则会将此信号发送给与该终端相关的控制进程，该信号的默认处理动作是终止进程。 2 SIGINT 当用户按组合键（一般采用Ctrl+C）时，终端驱动程序产生此信号并发送至前台进程组中的每一个进程，该信号的默认处理动作是终止进程。 3 SIGQUIT 当用户按组合键（一般采用Ctrl+\）时，终端驱动程序产生此信号并发送至前台进程组中的每一个
sigaction函数中 SA_NODEFER与sa_mask之间
D_DreKing的博客
07-01 3081
函数原型： int sigaction(int signo, struct sigaction *act, struct sigaction *oldact) ; signo ：需要处理的特定的信号 act ：设定对信息处理的动作 oldact ：返回signo信号的当前设置 结构体sigaction包含的元素： (1) void (*sa_handler)() ;   //旧
韩顺平Linux教程第一天学习笔记要点
因此，我们无法从中获取更多详细信息，但链接本身指向了韩顺平的个人博客，那里可能有更多关于Linux学习资源和相关文章。 标签“源码”和“工具”表明，该视频笔记可能包含Linux内核源码分析和常用Linux系统管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值