请教signal(SIGCHLD, SIG_IGN)的问题 [问题点数:20分,结帖人csshow]

Bbs1
本版专家分:0
结帖率 100%
Bbs1
本版专家分:0
Bbs6
本版专家分:8357
Blank
红花 2016年7月 Linux/Unix社区大版内专家分月排行榜第一
2016年3月 Linux/Unix社区大版内专家分月排行榜第一
Blank
黄花 2016年12月 Linux/Unix社区大版内专家分月排行榜第二
Bbs5
本版专家分:2468
Bbs7
本版专家分:25185
版主
Blank
红花 2008年2月 Linux/Unix社区大版内专家分月排行榜第一
2007年7月 Linux/Unix社区大版内专家分月排行榜第一
Blank
黄花 2008年3月 Linux/Unix社区大版内专家分月排行榜第二
Blank
蓝花 2012年9月 Linux/Unix社区大版内专家分月排行榜第三
2007年6月 Linux/Unix社区大版内专家分月排行榜第三
Bbs6
本版专家分:8357
Blank
红花 2016年7月 Linux/Unix社区大版内专家分月排行榜第一
2016年3月 Linux/Unix社区大版内专家分月排行榜第一
Blank
黄花 2016年12月 Linux/Unix社区大版内专家分月排行榜第二
#define SIG_IGN语法问题
void(*<em>signal</em>(int sig,void(*disp)(int)))(int);rn#define SIG_IGN (void(*)()) 1rnvoid(*)()定义了一个指向函数的空指针,这个空指针后面加个常数又会是怎么回事?是函数的参数?SIG_IGN又可做为参数传入<em>signal</em>中,真是被搞得晕部转向,请大家帮忙解释一下。
请教一个signal问题
有这样一段代码:rn------------------------------------------------------------------rnvoid AlertFastCleanExitFunc(int <em>signal</em>, void *arg)rnrn SpoAlertFastData *data = (SpoAlertFastData *)arg;rn /* close alert file */rn DEBUG_WRAP(DebugMessage(DEBUG_LOG,"AlertFastCleanExitFunc\n"););rn fclose(data->file);rn /*free memory from SpoAlertFastData */rn free(data);rnrn------------------------------------------------------------------rn这个函数中传进来了一个int <em>signal</em>,可是在整个函数体中根本没有看出哪里用到了这个变量,不知是作什么用处的。请大家给讲一下。rnrn多谢 !!!!!!
signal(SIGPIPE, SIG_IGN)方法设置一下,会永久起作用吗?
写了一个socket程序,开始没调用该方法,不起server,直接启动client端,则程序异常退出,打出Broken pipe.我在csdn上问了一下怎么样能捕到该错误,然后是client程序重新连接,有人说用<em>signal</em>(SIGPIPE, SIG_IGN),效果确实不错,程序不再自动退出.但是现在我注释掉了这个方法,怎么不像以前会自动退出了.是不是这个方法,是对操作系统而言的,只要我不重启机器,就一直这样了?
请教signal函数的问题
<em>signal</em>函数void (*<em>signal</em>(int, void(*)(int)))(int);rn可简化为:rntypedef void (*HANDLER)(int);rnHANDLER <em>signal</em>(int, HANDLER);rnrnrn一个<em>signal</em>函数的例子是这样的:rnrn#include rn#include rn#include rnvoid sigroutine(int dunno) /* 信号处理例程,其中dunno将会得到信号的值 */rnswitch (dunno) rn case SIGHUP:rn printf("Get a <em>signal</em> -- SIGHUP ");rn break;rn case SIGINT:rn printf("Get a <em>signal</em> -- SIGINT ");rn break;rn case SIGQUIT:rn printf("Get a <em>signal</em> -- SIGQUIT ");rn break;rn rn return;rn rnint main() rn printf("process id is %d ",getpid());rn <em>signal</em>(SIGHUP, sigroutine); //* 下面设置三个信号的处理方法rn <em>signal</em>(SIGINT, sigroutine);rn <em>signal</em>(SIGQUIT, sigroutine);rn pause();rnrnrnrn我想问的是sigroutine函数的参数是如何传进去的,rn为什么<em>signal</em>函数void (*<em>signal</em>(int, void(*)(int)))(int);其中的第1个int和第3个int值是相同的?是要看<em>signal</em>函数的定义吗?谢谢rn
关于SIGCHLD信号问题
[code=C/C++]rntypedef void Sigfunc(int);rnrnvoid sig_chld(int signo)rnrn pid_t pid;rn int stat;rn rn while ((pid = waitpid(-1, &stat, WNOHANG)) > 0)rn rn printf("child terminated %d\n", pid);rn rn rn return ;rnrnrnSigfunc *Signal(int signo, Sigfunc *func)rnrn struct sigaction act, oact;rn rn act.sa_handler = func;rn sigemptyset(&act.sa_mask);rn act.sa_flags = 0;rn rn printf("......\n");rn rn if (sigaction(signo, &act, &oact) < 0)rn return (SIG_ERR);rn rn return (oact.sa_handler);rnrnrnint main()rnrn int i = 0;rn pid_t pid;rn rn Signal(SIGCHLD, sig_chld);rn rn for (i = 0; i, getpid());rn exit(0);rn rn rnrn sleep(5);rn exit(0);rnrn[/code]rnrn对于上面的代码,我有几点弄不明白:rn1,为什么main()函数中Signal(SIGCHLD, sig_chld)的调用位置是那里,而不能放到fork()后;rn2,当有5个子进程退出时,会有5个SIGCHLD信号给父进程,这个时候Signal()是怎么工作的?它只是被调用一次吗?rn3,while中的waitpid函数是直到什么时候退出呢?
signal(SIGCHLD, SIG_IGN)和signal(SIGPIPE, SIG_IGN)
<em>signal</em>(SIGCHLD, SIG_IGN) 因为并发服务器常常fork很多子进程,子进程终结之后需要服务器进程去wait清理资源。如果将此信号的处理方式设为忽略,可让内核把僵尸子进程转交给init进程去处理,省去了大量僵尸进程占用系统资源。(Linux Only) 对于某些进程,特别是服务器进程往往在请求到来时生成子进程处理请求。如果父进程不等待子进程结束,子进程将成为僵尸进程(zomb...
关于中SIG_ERR、SIG_DEL、SIG_IGN定义的问题
#define SIG_ERR (void (*)())-1 #define SIG_DEL (void (*)())0 #define SIG_IGN (void (*)())1为什么不是#define SIG_ERR (void (*) (int))-1 呢?在网上搜索之后找到答案: 在C里这样的代码是可以的void fun(); int main() { fun(1,2);
宏定义SIG_DFL及SIG_IGN
define SIG_DFL和SIG_IGN
关于signal(SIGPIPE,SIG_IGN);
当服务器close一个连接时,若client端接着发数据。根据TCP协议的规定,会收到一个RST响应,client再往这个服务器发送数据 时,系统会发出一个SIGPIPE信号给进程,告诉进程这个连接已经断开了,不要再写了。根据信号的默认处理规则SIGPIPE信号的默认执行动作是terminate(终止、退出), 所以client会退出。 若不想客户端退出可以把 SIGPIPE设为SIG_IGN
signal(SIGPIPE, SIG_IGN) (转)
<em>signal</em>(SIGPIPE, SIG_IGN)   当服务器close一个连接时,若client端接着发数据。 根据TCP 协议的规定,会收到一个RST响应,client再往这个服务器发送数据时,系统会发出一个SIGPIPE信号给进程,告诉进程这个连接已经断开了,不要再写了。  根据信号的默认处理规则SIGPIPE信号的默认执行动作是terminate(终止、退出),所以client会退出...
SIGCHLD信号的问题
循环创建50个子进程,然后捕获SIGCHLD信号,在<em>sigchld</em>里wait子进程。rn为什么有的时候<em>sigchld</em>处理的次数少于50?rnrn大概代码如下:rnrn<em>signal</em>(SIGCHLD,<em>sigchld</em>) ;rnrnint iChildPid4;rn rn int i;rn for( i=0; i 0)rn rn printf( "iChildPid4 = %d\n ", iChildPid4);rn //printf ( "after child process 4 \n" );rn rn elsern rn printf( "create child process4 error\n" );rn rn rnrnrnrnvoid <em>sigchld</em>(int signo)rnrn _iIn++;rn printf("in is %d\n", _iIn);rnrn <em>signal</em>(signo, SIG_IGN);rn <em>signal</em>(SIGCHLD, <em>sigchld</em>);rn rn rn rv = wait( NULL);rn
SIGCHLD信号问题
在父进程利用变量++记录子进程个数,并在收到SIGCHLD信号之后--,为什么跑时间久后变量值会变为负值 giConn = 0?代码如下rn sighold(SIGCLD);rn if((iChildpid=fork())0)rn giConn--;rn /* rnrn
请教关于C的signal问题
现在每1秒钟会发送SIGALRM信号,每2秒钟发送SIGVTALRM信号rn他们都是触发同一个函数的,rn那么在这个函数里我怎么知道是那个信号的触发调用了此函数呢?rn触发这个函数时能不能传参数,就把信号传进来rn如果能,那么应该怎么写?rn
请教一个关于signal问题
[code=C/C++]#incldude rn#include rnstatic void sig_usr(int);rnrnint main(void)rnrnif (<em>signal</em>(SIGUSR1, sig_usr) == SIG_ERR)rnrnperror("can't catch SIGUSR1");rnexit(1);rnrnif (<em>signal</em>(SIGUSR2, sig_usr) == SIG_ERR)rnrnperror("can't catch SIGUSR2");rneixt(1);rnrnfor( ; ;)rnpause();rnrnstatic void sig_usr(int signo)rnrnif (signo == SIGUSR1)rnprintf("received SIGUSR1\n");rnelse if (signo == SIGUSR2)rnprintf("received SIGUSR2\n");rnelse rnprintf("received <em>signal</em> %d\n", signo);rnreturn;rn[/code]rnrn书上的一个示例程序,编译后为a.out rn执行 ./a.out &rn然后按照书上的方法分别执行 kill -USR1 6132(a.out的进程ID)rn kill -USR2 6132rn但是没有任何反应。。。rn有没有哪位指点一下是因为什么原因啊? 多谢!
请教信号量处理函数signal问题
<em>问题</em>是这个样子的:rnrn有一段如下的代码:rnvoid handler(int sig_number);//信号量处理函数rnint main()rnrn//some code herernrn <em>signal</em>(SIGINT,handler);//安装信号量rnrn//some other code here.rn return 0;rnrnrnvoid handler(int sig_number)rnrn //do something here.rnrnrn当执行到//some other code here.rn这片代码区域的时候,产生了信号量。此时后续rn代码会“中断”执行,转而去执行信号处理函数。rn请问这是一种什么处理机制?rnrn说一说我的看法:rn说是中断,应该不是。严格来说,中断处理函数运行在rn内核态。而信号量处理函数在用户态运行。但是我还是认为rn这里采用了一种类似中断的机制。信号产生的时候,中断当前rn的执行代码,转而去执行信号量处理函数,信号处理函数结束以后rn返回中断的代码处。但是这种机制不就是中断了吗?rn我搞不明白其中的道理,麻烦解释一下?rn谢谢!
关于SIGCHLD与SIG_IGN应用。
一、SIGCHLD是unix的一种信号。 SIGCHLD信号是子进程结束时,向内核发送的信号。 无论进程是正常终止,还是不正常终止,都会向内核发送SIGCHLD信号。 如果父进程不等待子进程结束,子进程将有可能成为僵尸进程(zombie)从而占用系统资源。因此需要对SIGCHLD信号做出处理,回收僵尸进程的资源,避免造成不必要的资源浪费。 可以用如下语句: signa
signal(SIGCHLD, SIG_IGN)
SIGCHLD信号子进程结束时, 父进程会收到这个信号。 如果父进程没有处理这个信号,也没有等待(wait)子进程,子进程虽然终止,但是还会在内核进程表中占有表项,这时的子进程称为僵尸进程。这种情 况我们应该避免(父进程或者忽略SIGCHILD信号,或者捕捉它,或者wait它派生的子进程,或者父进程先终止,这时子进程的终止自动由init进程 来接管)。使用<em>signal</em>(SIGCHLD, SIG_I
signal(SIGPIPE, SIG_IGN);
TCP是全双工的信道, 可以看作两条单工信道, TCP连接两端的两个端点各负责一条. 当对端调用close时, 虽然本意是关闭整个两条信道,  但本端只是收到FIN包.  按照TCP协议的语义, 表示对端只是关闭了其所负责的那一条单工信道, 仍然可以继续接收数据. 也就是说, 因为TCP协议的限制,  一个端点无法获知对端的socket是调用了close还是shutdown. 这句
linux信号函数signal(SIGCHLD, SIG_IGN)
我们调用fork函数派生一个子进程后,当子进程快要结束,会向父进程发送一个SIGCHLD信号,告诉父进程我快结束,赶快调用wait函数,来回收子进程的退出状态和其他信息。 这就是一种我们通常来预发僵尸进程产出的方法,在父进程接收到SIGCHLD信号后,将默认行为改为wait来回收子进程的信息。如果父进程没有调用wait函数,子进程先于父进程退出,则子进程将成为僵尸进程。 但是wait函数需要阻塞
请教signal函数的用法!
在好几本书上看<em>signal</em>函数,都没弄明白!rn到底是什么样的格式调用呢?返回值呢?rnrnif( <em>signal</em>(SIGKILL,&terminatehandler)==SIG_ERR)rnrn 对吗??rnrnrn
signal 函数请教
想问下大家,写了 <em>signal</em>(SIGRTMIN,function) 并关联了定时器以后,想要取消这样一个信号,或者想给函数function重新定义一个新的信号,需要怎么做,谢谢!
有关signal handler,请教
一般<em>signal</em>函数都如下处理:rnvoid handler(int sig).......rnrnint main()rnrn (void)<em>signal</em>(SIG,handler);rn rnrn ..............rnrnrn若希望使handler()产生返回值该怎么办?最好不使用全局变量.
signal问题
One specific example is how an interactive shell treats the interrupt and quit <em>signal</em>s for a background process. With a shell that doesn't support job control, when we execute a process in the background, as inrnrn cc main.c &rnrnrnthe shell automatically sets the disposition of the interrupt and quit <em>signal</em>s in the background process to be ignored. This is so that if we type the interrupt character, it doesn't affect the background process. If this weren't done and we typed the interrupt character, it would terminate not only the foreground process, but also all the background processes.rnrnMany interactive programs that catch these two <em>signal</em>s have code that looks likernrn void sig_int(int), sig_quit(int);rnrn if (<em>signal</em>(SIGINT, SIG_IGN) != SIG_IGN)rn <em>signal</em>(SIGINT, sig_int);rn if (<em>signal</em>(SIGQUIT, SIG_IGN) != SIG_IGN)rn <em>signal</em>(SIGQUIT, sig_quit);rnDoing this, the process catches the <em>signal</em> only if the <em>signal</em> is not currently being ignored.rnrnThese two calls to <em>signal</em> also show a limitation of the <em>signal</em> function: we are not able to determine the current disposition of a <em>signal</em> without changing the disposition. We'll see later in this chapter how the sigaction function allows us to determine a <em>signal</em>'s disposition without changing it.rnrn这段程序<em>问题</em>是,对于shell设置了后台程序忽略中断,退出信号,那么处理方法没<em>问题</em>rn要是shell没有设置设置忽略中断退出信号,if(<em>signal</em>(SIGINT,SIG_INT) != SIG_IGN)会忽略SIGINT,后面的<em>signal</em>(SIGINT, sig_int)又捕捉SIGINT信号,这会发生什么事呢?相当于对SIGINT处理了两次阿,而第一次就已经ignore了,rnrn测试代码rn[code=C/C++]#include rn#include rn#include rnstatic void deposition(int );rnrnint main()rnrn if(<em>signal</em>(SIGUSR1, SIG_IGN) != SIG_IGN)//默认为终止,if肯定成立rn rn <em>signal</em>(SIGUSR1, deposition);rn rn for(;;)rn pause();rnrnrnstatic void deposition(int stat)rnrn printf("received user <em>signal</em>\n");rnrn[/code]rnrn[ob@localhost mycode]$ ./main &rn[1] 3974rn[ob@localhost mycode]$ kill -USR1 3974rnreceived user <em>signal</em>rnrn是不是这样的?<em>signal</em>仅仅是设置处理方法,对于该nu信号究竟怎么处理,还是要看最后的<em>signal</em>(nu, func)?rn
关于捕捉SIGCHLD。
代码如下:rn[code=c]#include //forkrn#include rn#include rn#include //exitrn#include //waitrn#include //<em>signal</em>rnrn#define PRINT(msg) print(msg)rnrnvoid print(const char *msg)rnrn printf("%s[%d]:%s\r\n", __FUNCTION__, __LINE__, msg);rnrnrnrnstatic void sig_usr(int <em>signal</em>)rnrn if(<em>signal</em> == SIGCHLD)rn rn PRINT("child exit.");rn int status;rn wait(&status);rn if(WIFEXITED(status))rn rn printf("status:%d\n", WEXITSTATUS(status));rn rn rnrnrn//child notify parentrnint main(int argc, char const *argv[])rnrn pid_t pid;rn pid = fork();rn if(pid < 0)rn rn PRINT("fork failed.");rn exit(-1);rn rn else if(pid == 0)rn rn PRINT("I am Child.");rn sleep(5);rn exit(3);rn rn elsern rn PRINT("I am Parent"); rn <em>signal</em>(SIGCHLD, sig_usr);rn sleep(10); rn rn return 0;rn[/code]rnrnrn我在父进程中捕捉SIGCHLD, 收到SIGCHLD后,执行了相应的捕捉函数,但是父进程跟着也退出了。并没有执行接下来的sleep,这是为何?
SIGCHLD信号与SIG_IGN处理的使用
<em>signal</em>(SIGCHLD, SIG_IGN); //忽略SIGCHLD信号,这常用于并发服务器的性能的一个技巧//因为并发服务器常常fork很多子进程,子进程终结之后需要//服务器进程去wait清理资源。如果将此信号的处理方式设为//忽略,可让内核把僵尸子进程转交给init进程去处理,省去了//大量僵尸进程占用系统资源。(Linux Only) some code(); pid = fork(); //生成一个子进程if
Signal ()函数详细介绍
<em>signal</em>()函数理解 在 这个头文件中。 <em>signal</em>(参数1,参数2); 参数1:我们要进行处理的信号。系统的信号我们可以再终端键入 kill -l查看(共64个)。其实这些信号时系统定义的宏。 参数2:我们处理的方式(是系统默认还是忽略还是捕获)。 一般有3中方式进行操作。 (1)eg: <em>signal</em>(SIGINT ,SIG_ING ); //SI
关于SIGCHLD和sigaction的疑惑
各位大哥,小弟搞了好久也没整明白,代码如下:rn#include "apue.h"rn#includernrnvoid show_handler(struct sigaction * act)rnrn printf("<em>sigchld</em> catched!\n");rnrnmain()rnrn int i;rn pid_t pid;rn struct sigaction act,oldact;rn rn act.sa_handler = show_handler;rn rn pid = fork();rn if(pid < 0)rn printf("fork err!\n");rn if(pid == 0)rn rn sleep(5);rn printf("child process\n");rn rn else rn sigaction(SIGCHLD,&act,&oldact);rn printf("parent process\n");rnrnrnrnrn输出:rnparent processrn[root@localhost threadctl]# child processrnparent processrnrn为什么在父进程里面设置了sigaction动作,但却没有执行,并且执行了两次printf("parent process\n");rn。rnrn而:rnvoid show_handler(struct sigaction * act)rnrn printf("<em>sigchld</em> catched!\n");rnrnmain()rnrn int i;rn pid_t pid;rn struct sigaction act,oldact;rn rn act.sa_handler = show_handler;rn sigaction(SIGCHLD,&act,&oldact);rn rn pid = fork();rn if(pid < 0)rn printf("fork err!\n");rn if(pid == 0)rn rn printf("child process\n");rn rn else rn printf("parent process\n");rnrn确实正常的输出:rnchild processrn<em>sigchld</em> catched!rnparent process
signal问题
我用<em>signal</em>等待SIGCHLD信号(子进程退出),请问如何得到该子进程的pid? rnrn还有个<em>问题</em>,SIGCLD SIGCHLD有什么区别吗?rn还有个<em>问题</em>,我使用<em>signal</em>之后需要在处理函数中继续<em>signal</em>吗?还是只要<em>signal</em>一次就可以了?rn
(三十五)信号——SIGCHLD信号处理
SIGCHLD的产生条件 1、子进程终止时 2、子进程接收到SIGSTOP信号停止时 3、子进程处在停止态,接受到SIGCONT后唤醒时 举例:#include #include #include #include #include #include <sys/wait.h
【信号】---关于SIGCHLD信号
一、 下面证明验证子进程退出时会给父进程发送SIGCHLD信号(17号信号)的机制测试结果: 三、父进程等待子进程的异步版本(非阻塞版本)测试:
僵尸进程的产生和SIGCHLD信号
核心句子 子进程在终止时会给父进程发SIGCHLD信号,该信号的默认处理动作是忽略,父进程可以自 定义SIGCHLD信号的处理函数。 僵尸进程的产生: 1 #include &amp;amp;amp;quot;head.h&amp;amp;amp;quot; 2 #include &amp;amp;amp;amp;lt;unistd.h&amp;amp;amp;amp;gt; 3 #include &amp;amp;amp;amp;lt;<em>signal</em>.h&amp;amp;amp
signal(SIGPIPE, SIG_IGN) 解析
<em>signal</em>(SIGPIPE, SIG_IGN)     当服务器close一个连接时,若client端接着发数据。根据TCP 协议的规定,会收到一个RST响应,client再往这个服务器发送数据时,系统会发出一个SIGPIPE信号给进程,告诉进程这个连接已经断开了,不要再写了。    根据信号的默认处理规则SIGPIPE信号的默认执行动作是terminate(终止、退出),所以client会退
select()函数以及FD_ZERO、FD_SET、FD_CLR、FD_ISSET
http://hi.baidu.com/%B1%D5%C4%BF%B3%C9%B7%F0/blog/item/e7284ef16bcec3c70a46e05e.html select函数用于在非阻塞中,当一个套接字或一组套接字有信号时通知你,系统提供select函数来实现多路复用输入/输出模型,原型:        #include #include
一个重要且实用的signal---SIGCHLD
https://blog.csdn.net/lyztyycode/article/details/78150805SIGCHLD(修改)因为笔者之前的文章里面有错误,今天发现,立马做个修改。在下面我的一段关于<em>sigchld</em>信号相对于直接调用wait函数的好处时,我说调用wait函数要一直检测子进程是否执行完其实是错误的, wait是阻塞函数,当主进程调用wait函数的时,主进程处于阻塞状态,并没有...
SIGCHLD
在Linux系统下,子进程状态改变后产生此信号,如子进程停止(STOP)、子进程终止(terminate)等。在Linux系统下,如果进程明确地将该信号的配置设置为SIG_IGN,则调用进程的子进程将不产生僵死进程。注意,这与其默认动作(SIG_DFL)“忽略”不同。在Linux系统下,如果使用sigaction将信号SIGCHLD的sa_flags中的SA_NOCLDSTOP选项打开,当子进程停止
聊聊SIGCHLD信号的作用
一句话总结:子进程终止或者停止时,将SIGCHLD信号发送给其父进程,按系统默认将忽略此信号,如果父进程希望被告知其子系统的这种状态,则应捕捉此信号。 看下如何捕捉 #include #include #include #include #include void sigFun(int sig) { printf("sigFun begin\n"); pid_t pid;
SIGCHLD信号使用和注意事项
1.SIGCHLD简介 SIGCHILD是指在一个进程终止或者停止时,将SIGCHILD信号发送给其父进程,按照系统默认将忽略此信号,如果父进程希望被告知其子系统的这种状态,则应捕捉此信号。注意:SIGCLD信号与其长得非常相似。SIGCLD是系统V的一个信号名,其语义与名为SIGCHLD的BSD信号不同。POSIX.1则采用BSD的SIGCHLD信号。BSD的SIGCHLD信号语义与其他信号的...
请教一个linux signal相关的问题
我做了一个实验:rn在linux shell下面用kill SIGUSR1 pid送<em>signal</em>给pid这个process,系统会挂掉;rn但是在代码中使用kill(pid, SIGUSR1);则可以成功的发送SIGUSR1给pid呢?rnrn有谁知道这是为什么吗?感谢!
请教Linux的一个signal信号问题
我有1个主进程和2个线程,代码大概如下:rnvoid main()rnrn pthread_create(task1.....);rn pthread_create(task2.......);rnrn for(;;) run();rnrnrnvoid task1()rnrn for(::) run(); rnrnrnvoid task2()rnrn for(::)run(): rnrnrn 因为task1和task2都有服务器端程序socket,为了防止触发PIPE错误,我对PIPE信号作了忽略处理,调用了rn<em>signal</em>(SIGPIPE, SIG_IGN)。我的<em>问题</em>是<em>signal</em>调用加在哪里?在main里边加一句<em>signal</em>(SIGPIPE, SIG_IGN)就可以了?rn还是应该task1和task2都要加入<em>signal</em>(SIGPIPE, SIG_IGN)?rn 我个人推测应该只在main里边就可以了,主进程会处理子线程的异常处理。还请各位大神帮忙解答,谢谢!rnrn
Linux下的SIGCHLD信号
在之前我们为了避免出现僵尸进程我们采用了两种方式 1、调用wait()函数使父进程去等待子进程。wait()是一种阻塞等待 2、调用waitpid()函数这也是父进程去等待子进程而waitpid()分为阻塞式等待和非阻塞式等待,轮询的方式就是建立在非阻塞等待的基础之上的而SIGCHILD信号也可以避免出现僵尸进程创建僵尸进程 #include #include <unistd.
关于SIGCHLD的一点疑问
-
[Linux]关于SIGCHLD
父进程异步清理子进程,SIGCHLD
SIGCHLD 信号
SIGCHID:子进程在终止时会给父进程发SIGCHLD信号,该信号的默认处理动作是忽略,父进程可以自定义SIGCHLD信号的处理函数,这样父进程只需专心处理自己的工作,不必关心子进程了,子进程终止时会通知父进程,父进程在信号处理函数中调用wait清理子进程即可。要想不产生僵尸进程还有另外一种办法:父进程调用sigaction将SIGCHLD的处理动作置为SIG_IGN,这样...
SIGCHLD信号
在进程的学习中,我们用wait和waitpid函数清理僵尸进程,父进程可以阻塞式等待子进程结束,也可以非阻塞地查询是否有子进程结束等待清理(即轮询方式)。采用第一种方式,父进程阻塞式等待,就不能处理自己的工作了;采用第二种方式,父进程在处理自己工作的同时还要记得时不时地轮询一下,程序实现复杂。其实,子进程在终止时会给父进程SIGCHLD信号,该信号的默认处理动作是忽略,父进程可以自定义SIGCHL...
有关SIGCHLD信号的处理
(<em>问题</em>来自Unix network programming)rn服务器进程设置了SIGCHLD的处理函数,此函数调用wait清除僵尸进程;且服务器进程为每一个连接fork一个子进程。rn客户端与服务器端建立了5个TCP连接,然后客户端终止,5个连接几乎同时关闭,5个子进程几乎同时终止,在linux下,服务器进程总是处理了最后派生的2个子进程,而还剩3个僵尸子进程。rn我想问的是,如果断续的,隔一段时间才关闭一个TCP连接,也就是内核断续地发给服务器进程SIGCHLD信号,那么wait是可以将5个僵尸子进程都处理掉的?(而不需要在循环中使用waitpid)
LInux操作系统之SIGCHLD信号
(1)SIGCHLD产生条件             1)子进程终止的时候             2)子进程接收到SIGSTOP信号停止时             3)子进程处于停止状态,接受到SIGCONT后唤醒 (2)借助SIGCHLD使用waitpid信号实现父进程对子进程的回收      (3)SIGCHLD信号注意<em>问题</em>        1)子进程继承父进程的信号屏蔽字和信号...
【信号】SIGCHLD信号
一、SIGCHLD信号 1. SIGCHLD简介 SIGCHLD的产生条件: 子进程终止 子进程接收到SIGSTOP信号停止时 子进程处于停止状态,接收到SIGCONT后唤醒 注意:通过<em>signal</em>(SIGCHLD, SIG_IGN)通知内核对子进程的结束不关心,由内核回收。如果不想让父进程挂起,可以在父进程中加入一条语句:<em>signal</em>(SIGCHLD,SIG_IGN);表示父进程忽略...
请教 signal 函数原型的语法细节
void (*<em>signal</em>(int sig, void (*func)(int)))(int); rnrn明白函数指针。但是<em>signal</em>的原型看了好几天了也没有明白。请用 C 语言的语法解释该函数原型的各部分。
signal 中几句声明请教
rnrntypedef void (*__p_sig_fn_t)(int);rnrn#define SIG_DFL ((__p_sig_fn_t) 0)rnrn宏 SIG_DFL 为什么这名声明
Python之signal模块详解
先简单说一下Signal是啥.(如果想直接使用可以不看)Signal翻译过来中文就是信号- -当然, 本身他就是Linux系统编程中非常重要的概念, 信号机制是进程之间传递消息的一种机制,其全称为软中断信号作用是通知进程发生了异步事件。进程之间可以调用系统来传递信号, 本身内核也可以发送信号给进程, 告诉该进程发生了某个事件.注意,信号只是用来通知某进程发生了什么事件,并不给该进程传递任何数据。接...
linux的SIGCHLD信号
SIGCHLD信号 SIGCHLD的产生条件 子进程终止时 子进程接收到SIGSTOP信号停止时 子进程处在停止态,接受到SIGCONT后唤醒时 借助SIGCHLD信号回收子进程 #include #include #include #include #include #include #include void sys_err(char *str) { per
捕捉SIGCHLD,处理僵死进程
在Linux/Unix系统中,当进程结束时,内核会释放进程
信号的捕捉以及SIGCHLD信号
一. 信号的捕捉定义     用户提供一个处理函数, 要求内核在处理信号时必须切换到用户态,执行这个函数, 这种方式就叫做信号的捕捉 二. 图解信号的捕捉过程     1. 由上图可以看出,当处理信号的执行动作时用户自定义的时候,此时就需返回该函数去调用该函数, 这就叫做信号的捕捉. 以前我们总是说进程收到信号时会在合适的时候取处理该信号, 现在可以看出,这个合适的时候就是当进程处理...
Linux下信号SIGCHLD处理不当产生僵尸进程的问题
LINUX 通过fork创建子进程时,如果子进程退出,内核会向父进程发送SIGCHLD信号,这样由父进程回收子进程的资源,避免产生僵尸进程, 产生僵尸进程的本质是该进程的内核资源未被释放,本着谁创建谁释放的原则,则是父进程释放,所以需要在父进程处理SIGCHLD信号。 一般代码如下:  <em>signal</em>(SIGCHLD, OnSignalSIGCHLD); static void OnSi
Signal
看了下Signal 头快爆掉了rn搞不明白信号是怎么产生的rn还有在main中第一句就调用<em>signal</em>() ,他怎么会执行??rn还有alarm()最晕了rn指点一下rn有网址链接也行rn谢谢了!!~~~~
No such signal
创建了工具栏,添加了第三个QAction时,在MainWindow类里rn[code=c]rn RectAction[2] = new QAction(tr("&Text"), this);rn RectAction[2]->setStatusTip(tr("Inpute a Text."));rn RectAction[2]->setIcon(QIcon("icons/encoding.png"));rn connect(RectAction[2],SIGNAL(triggered()),this,SLOT(Text_selected()));rn m_ptoolbar->addAction(RectAction[2]);/////rn m_paction = RectAction[2];////m_paction 为全局变量,为了传到另一个类里rn[/code]rn还是在MainWindow里,Text_selected槽函数rn[code=c]rnvoid MainWindow::Text_selected()rnrn emit createText();//信号能进这里,发到另一个类里面rnrn[/code]rn[code=c]rn另一个类rnMyPainter::MyPainter()//MyPainter里面做信号处理rnrn connect(m_paction,SIGNAL(createText()),this,SLOT(recvtocreateText()),Qt::DirectConnection);//这里连接createText信号!!!rnrnvoid MyPainter::recvtocreateText()///这个槽函数不被执行!!!!!rnrn QLineEdit *edit = new QLineEdit(this);rn edit->move(QPoint());//rn edit->show();rnrn[/code]rn报警告说:Object::connect: No such <em>signal</em> QAction::createText() in MyPainter.cpp:41rn可是我的程序有这个信号啊!!!!!
signal 7和signal 11
我的程序运行了大概1周就出错了,gdb时有这样一句rnProgram terminated with <em>signal</em> 7, Bus error.rnrn我查了一下<em>signal</em> 7,bus error(bad memory access)rn我不知道<em>signal</em> 7 和<em>signal</em> 11究竟有什么区别啊?rnrn最重要的是什么导致了<em>signal</em> 7?是越界了吗?rn哪位大仙能讲解下<em>signal</em> 7
实现mysleep,可重入函数,SIGCHLD信号
一,pause函数实现sleepint pause(void);//头文件&amp;lt;unistd.h&amp;gt;        该函数的功能是使调用进程挂起直到有信号递达。如果处理动作是终止进程,则进程终止,函数不再返回;若处理动作是忽略,则进程继续挂起;若是自定义行为,则捕捉信号后返回-1。所以该函数只有出错的返回值。 #include &amp;lt;unistd.h&amp;gt; unsigned int s...
SIGCHLD信号处理方式的疑问
-
处理SIGCHLD信号
在上一讲中,我们使用fork函数得到了一个简单的并发服务器。然而,这样的程序有一个<em>问题</em>,就是当子进程终止时,会向父进程发送一个SIGCHLD信号,父进程默认忽略,导致子进程变成一个僵尸进程。僵尸进程一定要处理,因为僵尸进程占用内核中的空间,耗费进程资源。这里通过<em>signal</em>函数处理信号。 1、信号是啥? 信号(<em>signal</em>)就是告知某个进程发生了某个事件的通知,有时也叫软件中断(softwar...
UNIX网络编程笔记(5):处理SIGCHLD信号
在上一讲中,我们使用fork函数得到了一个简单的并发服务器。然而,这样的程序有一个<em>问题</em>,就是当子进程终止时,会向父进程发送一个SIGCHLD信号,父进程默认忽略,导致子进程变成一个僵尸进程。僵尸进程一定要处理,因为僵尸进程占用内核中的空间,耗费进程资源。这里通过<em>signal</em>函数处理信号。 1、信号是啥? 信号(<em>signal</em>)就是告知某个进程发生了某个事件的通知,有时也叫软件中断(softwar
Linux SIGCHLD信号处理
SIGCHLD信号处理SIGCHLD的产生条件1、子进程终止时 2、子进程接收到SIGSTOP信号停止时 3、子进程处在停止态,接受到SIGCONT后唤醒时源代码<em>signal</em>_test.c#include &amp;lt;stdlib.h&amp;gt; #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;unistd.h&amp;gt; #include &amp;lt;<em>signal</em>.h&amp;gt; ​ v...
c++调用system函数调用系统命令报错
-
Linux——竟态条件和SIGCHLD
可重入函数 一个函数被多个执行流调用,有可能在第一次调用还没返回时就再次进入函数,称为重入。 例如上面的insert函数,在执行第一步时收到信号产生硬件中断,转去信号处理函数,而信号处理函恰好调用了insert函数,由于两个函数操纵了同一个链表而产生意外的结果,所以这个函数是不可重入函数。如果这个函数只是操纵自己的局部变量就是可重入的。 另外调用IO库,或者使用malloc的函数也是不可...
Linux: 关于 SIGCHLD 的更多细节
僵尸进程 何为僵尸进程? 一个进程使用fork创建子进程,如果子进程退出,而父进程并没有调用 wait 或 waitpid 获取子进程的状态信息,那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵尸进程 成为僵尸进程的因素 子进程 先于 父进程退出; 子进程的状态信息,没有被父进程回收; 那么<em>问题</em>来了,子进程退出了,父进程怎么知...
a question: about SIGCHLD, thanks
[code=C/C++]#includern#include rn#include rn#include rn#include /*fork()函数所在的头文件*/rn#include rn#include rn#include rn#includern#includernrnint i;rnrnstatic void pri(int signo)rnrn pid_t pid;rn int status;rn rn while( (pid = wait(&status))>0 )rn printf("recevied <em>sigchld</em>,i = %d,pid = %d,status=%d\n",i,pid,status);rnrnrnint main(int argc,char *argv[]) rnrn char c = 0;rn pid_t pid;rn rnrn <em>signal</em>(SIGCHLD,pri);rnrn for(i=0;i,i);rn rn rn rn rnrnrn[/code]rnrn 结果不可预见 ,一个例子 : 为什么后面几个信号会丢失 rnrnparent running,i=0rnparent running,i=1rnrecevied <em>sigchld</em>,i = 2,pid = 13772,status=0rnrecevied <em>sigchld</em>,i = 2,pid = 13773,status=0rnparent running,i=2rnparent running,i=3rnparent running,i=4rnparent running,i=5rnrecevied <em>sigchld</em>,i = 6,pid = 13775,status=0rnrecevied <em>sigchld</em>,i = 6,pid = 13776,status=0rnrecevied <em>sigchld</em>,i = 6,pid = 13777,status=0rnrecevied <em>sigchld</em>,i = 6,pid = 13778,status=0rnparent running,i=6rnparent running,i=7rnparent running,i=8rnparent running,i=9rn
信号捕捉 、pause函数和SIGCHLD信号
一、信号捕捉 信号捕捉针对于自定义的函数处理信号方式。信号递达调用这个函数称为捕捉信号。发生信号并不是立即处理的,而是找合适的机会,这个机会就是从内核态切换到用户态的时候处理信号。 用户态切换到内核态的方式:(1)系统调用(2)程序异常(3)软件中断 信号捕捉流程顺序见下图:  二、pause函数 调用pause函数回事进程挂起,直到有信号递达。如果信号的处理动作是终止进程,则进...
waitpid和SIGCHLD信号回收僵尸进程
对于多进程而言,父进程一般需要跟踪子进程的退出状态。因此当子进程结束运行时,内核不会立即释放该进程的进程表的表项。以满足父进程后续对子进程退出的信息查询(死后验尸),当然前提是父进程还在运行。在子进程结束之后,父进程读取其退出状态之前,我们称该子进程处于僵尸态(用户空间已经被释放,其不能被调度)。
父进程无法接收到子进程退出时发出的SIGCHLD信号
相同的程序,在自己的SUSE/Red hat环境下都可以收到子进程退出时发出的SIGCHLD信号。 但是到客户(OS:SUSE)那边就是无法收到。 请问这个是什么原因造成的?是客户(OS:SUSE)的
忽略SIGCHLD信号来避免僵尸进程
一句话总结:仔细处理子进程死后的信息,如果不想处理就需要交给系统处理。 僵尸进程:一个进程执行了exit系统调用退出时会向父进程发送SIGCHLD信号,而其父进程并没有为它收尸(调用wait或waitpid来获得它的结束状态,如进程ID、终止状态等等)的进程。
SIGCHLD信号处理
在apue这本书中,介绍了早期System V不可靠信号中SIGCLD的经典语义。如在RH7.2上编译并运行该程序则一切正常(不会出现重复打印"SIGCLD received"), 因为:  1)现今的Unices系统(包括Linux)都提供了可靠的信号机制.  2)Linux(RH7.2,kernel 2.4.7)上对SIGCLD的处理是: #define SIGCLD SIGCHLD
Linux虚拟机网络配置-net模式
虚拟机在配置网络之前,网络是不可用的,这里我们用net模式来配置虚拟机网络,以便在虚拟机中访问外网,例如pingwww.baidu.com,根本ping不通,因为这时我们还没有配置可用的网络。 1.查看本机网关 打开菜单栏中的“编辑”选项卡中的子选项卡“虚拟机网络编辑器”,找到NAT模式下的配置 记住NAT中的这些参数:子网IP是192.168.159.0、子网掩码是255.255....
信号函数signal问题
小弟正在学习Linux信号编程.rn看到书上有一个例子,有点搞不懂.请问:<em>signal</em>(SIGHUP, [color=#FF0000]sigroutine[/color])中的sigroutine是不是指向函数的指针?rn还有void sigroutine(int [color=#FF0000]dunno[/color]) 中的dunno不是形参吗?没有赋值怎么会有值呢?rn请高手为我解惑,谢了rnvoid sigroutine(int [color=#FF0000]dunno[/color]) rnrn switch ([color=#FF0000]dunno[/color]) rn rn case 1:printf("Capture SIGHUP <em>signal</em>, the <em>signal</em> number is %d\n", dunno); break;rn case 2:printf("Capture SIGINT <em>signal</em>, the <em>signal</em> number is %d\n", dunno); break;rn case 3:printf("Capture SIGQUIT <em>signal</em>, the <em>signal</em> number is %d\n", dunno);break;rn rn return;rnrnint main(void) rnrn printf("process ID is %d\n",getpid());rn if([color=#FF0000]<em>signal</em>(SIGHUP, sigroutine)[/color] == SIG_ERR) rn printf("Couldn't register <em>signal</em> handler for SIGHUP!\n");rn rn if([color=#FF0000]<em>signal</em>(SIGINT, sigroutine)[/color] == SIG_ERR)rn rn printf("Couldn't register <em>signal</em> handler for SIGINT!\n");rn rn if([color=#FF0000]<em>signal</em>(SIGQUIT, sigroutine)[/color] == SIG_ERR)rn rn printf("Couldn't register <em>signal</em> handler for SIGQUIT!\n");rn rn while(1)rn sleep(1);rn return 0;rn
signal的处理函数问题
有些例子:rnvoid sig_cld() rn pid_t pid;rn int status;rn if (<em>signal</em>(SIGCLD,sig_cld)!= -1) rn pid = wait(&status);rn printf("%d\n",pid);rn rnrn为什么sig_cld()中还要调用一次<em>signal</em>(SIGCLD,sig_cld)
signal函数的定义问题
<em>signal</em>函数原型:rnvoid (*<em>signal</em>(int sig, void (*handler)(int)))(int)rnrn可以用下面两句替换:rntypedef void (*HANDLER)(int);rnHANDLER <em>signal</em>(int, HANDLER);rnrn调用<em>signal</em>函数的例子:rn#include rn#include rnvoid handler(int sig)rnrn printf("%d\n", sig);rn printf("hello\n");rnrn rnint main()rnrn int i;rn <em>signal</em>(SIGALRM, handler);rn alarm(5);rn for (i = 1; i < 7; i++)rn rn printf("sleep %d ...\n", i);rn sleep(1);rn rn return 0;rnrnrn中间“<em>signal</em>(int sig, void (*handler)(int))”返回一个指向void (*handler)(intrn)函数的指针。rnrn这里不明白的是,最后一个(int),这个参数应该是<em>signal</em>返回的指针指向的函数的rn参数,那么什么地方给这个参数赋值了呢?(<em>signal</em>函数调用的时候只给自己的两个参rn数赋值了,那最后面的那个参数,是怎么赋值的?)
signal函数的问题
最近学习<em>signal</em>函数,写了一个例程:rn[code=C/C++]rnvoid err(int i)rnrn printf("Core dump啦 原因码为[%d]\n",i);rnrnrnint main()rnrn <em>signal</em>(SIGSEGV, err);rn int fd;rn rn if ((fd = open("cfg", O_RDWR)) < 0)rn rn printf("文件没打开\n");rn exit(1);rn rn printf("文件打开:%d, %s\n",errno,strerror(errno));rn rn sprintf(0,"bad");rnrn return 0;rnrn[/code]rn以上运行没什么<em>问题</em>,但我改了一行,让<em>signal</em>去监听不存在的信号。rn[code=C/C++]rn<em>signal</em>(150, err);rn[/code]rn结果下面一行的文件打开就出错了。rnrn文件打开:22, Invalid argumentrnrnrn请问是什么原理导致的啊?rn
关于signal函数返回值 的问题
理论上说,<em>signal</em>成功处理后返回信号以前的处置。rn于是我写了如下一个函数:rn----------------------------rn#include "apue.h"rn#include "error.h"rnstatic void sig_usr1(int);rnstatic void sig_usr2(int);rnrnint rnmain(void)rn Sigfunc* func;rn int i=0;rn if(<em>signal</em>(SIGUSR1,sig_usr1)==SIG_ERR)rn err_sys("can't catch S1");rn if((func = <em>signal</em>(SIGUSR2,sig_usr2))==SIG_ERR)rn err_sys("can't catch S2");rn for(i=0;i);rnrn/*rnoutput:rn rn[root@localhost f10.1]# ./c &rn[1] 3348rn[root@localhost f10.1]# kill -USR1 3348rn rn usr1rn[root@localhost f10.1]# kill -USR2 3348rn rn usr2rn[root@localhost f10.1]#rn[1]+ 段错 rnrnrn*/rn------------------------------------------------rn我预期是这样的:rnfunc可以得到<em>signal</em>前一次的处置,就是sig_usr1,于是打印rnusr1rn但是结果不正确,出现段出错,我觉得这当中没有 什么堆栈分配的<em>问题</em>嘛?rn请赐教
SIGCHLD信号与父进程异步等待子进程
阻塞式等待:wait函数,当然waitpid函数当其第三个参数不为WNOHANG时也是阻塞式等待。 非阻塞式等待:(轮询的方式):当waitpid函数当其第三个参数为WNOHANG是非阻塞式等待。 父进程可以阻塞等待子进程结束,也可以非阻塞地查询是否有子进程结束等待清理(也就是轮询的方式)。 若采用阻塞等待方式,父进程就不能处理自己的工作了;采用非阻塞方式,父进程在处理自己工作的同时还要时不...
关于linux环境下信号SIGCHLD的排队机制
2006-05-31 11:38:35 分类: LINUX 一直对这个<em>问题</em>没有深入的思考过。最近由于项目的需要终于弄清了这个<em>问题</em>。 以下文字是抄袭+理解+估计: 在linux系统中,子进程的正常/异常终止都会给父进程发送SIGCHLD的信号,当父进程接收到子进程(第一个)信号进行wait()或waitpid()时,会屏蔽掉下一个的SIGCHLD信号,实际
linux下同时使用wait和SIGCHLD的信号处理函数
前一段时间写代码用到了子进程,设置了SIGCHLD的信号处理函数,并且父进程使用wait等待子进程结束,运行的结果和我想象的不大一样。 原型抽取如下: /* * SigChld.cpp * * Created on: 2012-11-16 * Author: hf */ #include #include #include #include #include
Linux中的SIGCHLD及wait,waitpid的使用
在一个进程终止或者停止时,将SIGCHLD信号发送给其父进程。按系统默认将忽略此信号。如果父进程希望被告知其子系统的这种状态,则应捕捉此信号。信号的捕捉函数中通常调用wait(waitpid)函数以取得进程ID和其终止状态     该信号常用于处理僵死(zombie)进程,通过在listen调用后增加如下函数调用: <em>signal</em>(SIGCHLD, sig_chld); // void
alarm() 和 signal()的问题
程序如下,这个程序为什么没能捕捉到<em>signal</em> handler呢??请运行一下,谢谢各位大神rnrn/** Author : kotrue rn * Tm&Add : 22:54:00 10/16/2011 in USTBrn * Notes : non-reentrant functions.rn */rnrn#include rn#include rn#include rn#include rnrnvoid <em>signal</em>_handler(int signum);rnrn// use static data structure.rnstatic char str[20];rnrnint main()rnrn strcpy(str, "\n");rn <em>signal</em>(SIGALRM, <em>signal</em>_handler);rn alarm(1);rn while(1)rn rn printf("%s", str);rn strcpy(str, "hello world\n");rn strcpy(str, "WWWWWWWWWWW\n");rn alarm(1);rn rn return 0;rnrnrnvoid <em>signal</em>_handler(int signum)rnrn printf("%s", str);rn alarm(1); rnrn
boost的signal和connection 的问题
[img=https://img-bbs.csdn.net/upload/201308/20/1376980842_275327.jpg][/img]rn这段代码中的boost connection是在做什么呢?
signal的声明问题
ansi c在<em>signal</em>.h中的声明是这样的:rnvoid (*<em>signal</em>(int sig,void (*handler)(int)))(int)rn我看不太明白。谁能详细地分析一下这个声明?谢谢先!
timer & signal问题
写了个timer和<em>signal</em>的程序rn有错误 rn可以打印 "inside thr_quantum" "inside timer" “inside interrupt” rn但是不打印“inside contextswitch”rn不知道哪里错了:(rn请高人指教rn谢谢rnrn/*myhandler: contextswitch*/rnvoid contextswitch(void) rnrn fprintf(stderr, "inside contextswitch\n");rn .............rn .............rnrnrn/* set up myhandler for SIGALRM */rnstatic int th_interrupt(void) rn rn fprintf(stderr, "inside interrupt\n");rn struct sigaction act;rn act.sa_handler = contextswitch;rn act.sa_flags = 0;rn return (sigemptyset(&act.sa_mask) || sigaction(SIGALRM , &act, NULL));rnrnrn/* set ITIMER_REAL for 5-ms intervals */rnstatic int th_timer(time_t n) rnrn fprintf(stderr, "inside timer\n");rn struct itimerval value;rn value.it_interval.tv_sec = 0;rn value.it_interval.tv_usec = n;rn value.it_value = value.it_interval;rn return (setitimer(ITIMER_REAL, &value, NULL));rnrnrnrnvoid thr_quantum(int n)rnrn fprintf(stderr, "inside quantum\n");rn if (th_interrupt() == -1) rn perror("Cannot set up interrupt");rn exit( 1 );rn rn if (th_timer(n) == -1) rn perror("Cannot set up timer");rn exit( 1 );rn rn
无线数据传输模块PTR2000下载
接收发射合一 ! 工作频率为国际通用的数传频段433MHz ! FSK 调制,抗干扰能力强,特别适合工业控制场合 ! 采用DDS+PLL频率合成技术,频率稳定性极好。 ! 灵敏度高,达到-105dBm ! 最大发射功率+10dBm ! 低工作电压(2.7V),功耗小,待机状态仅为8uA. 相关下载链接:[url=//download.csdn.net/download/uestc_zhou/2405430?utm_source=bbsseo]//download.csdn.net/download/uestc_zhou/2405430?utm_source=bbsseo[/url]
免费网站程序_红色物流网站源码下载
模板介绍: 红色风格的物流公司网站模板,风格大气美观,界面设计精细,适合物流公司,货运公司,运输公司等企业网站建设。 宽度:990px 对齐:居中 主色:红色 结构:div+css 运行环境:asp.net2.0(或以上) 后台地址:pageadmin网站管理系统 相关下载链接:[url=//download.csdn.net/download/woshiaq_download/4915881?utm_source=bbsseo]//download.csdn.net/download/woshiaq_download/4915881?utm_source=bbsseo[/url]
ibatis2.3.X培训文档.ppt下载
刚找到的分享下 求围观 相关下载链接:[url=//download.csdn.net/download/swear2009221/5139005?utm_source=bbsseo]//download.csdn.net/download/swear2009221/5139005?utm_source=bbsseo[/url]
相关热词 c# 标准差 计算 c#siki第五季 c#入门推荐书 c# 解码海康数据流 c# xml的遍历循环 c# 取 查看源码没有的 c#解决高并发 委托 c#日期转化为字符串 c# 显示问号 c# 字典对象池
我们是很有底线的