Linux系统编程 day07 信号

已于 2023-11-30 13:59:56 修改
阅读量924 收藏 21
点赞数 24
分类专栏： Linux系统编程 文章标签： linux 运维 服务器 ubuntu c语言
于 2023-11-30 13:58:01 首次发布
月仙儿
本文链接：https://blog.csdn.net/qq_42198306/article/details/134679349
版权

Linux系统编程 day07 信号

1. 信号的介绍以及信号的机制

信号是信息的载体，在Linux/Unix环境下，信号是一种很重要的通信手段。信号通信的方式简单，但是不能携带大量的信息，信号是满足某个特定的条件才会产生的。

在Linux中，进程A给进程B发送信号，进程B收到信号之前执行自己的代码，收到信号后，不管执行到应用程序的什么位置，都要暂停运行，去处理信号，处理完毕后再继续执行。信号是在软件的层面上实现的中断，早期被称为软中断。每一个进程收到的信号都是由内核负责发送的。信号的发送过程如下：

在这里插入图片描述
信号的状态有三种，分别是产生、未决、递达。信号的产生由以下的几种方式：

  • 按键产生，如：Ctrl + C（SIGINT）、Ctrl + Z （SIGSTOP）、Ctrl + \ （SIGTERM）。
  • 系统调用产生，如：调用kill 、raise、abort。
  • 软件条件产生，如：定时器alarm。
  • 硬件异常产生，如：非法访问内存（段错误）、除0（浮点数例外）、内存对齐出错（总线错误）。
  • 命令产生，如：kill命令。

信号的未决状态时是信号产生和信号递达之间的状态，主要是由于阻塞导致了该状态，后面我们会用sigpromask去对某个信号集进行阻塞等操作。信号的递达是信号递达并且到达该进程。

进程收到了信号之后，就会对信号进行相应的处理。信号处理默认动作有以下几种方式：

在这里插入图片描述

处理方式处理结果
Term默认行为是终止进程
Ign默认行为是忽略信号
Core默认行为是终止进程并生成core文件
Stop默认行为是暂停进程
Cont默认行为是如果进程当前状态为暂停则继续运行进程

当然，除了默认处理之外我们还可以捕捉信号调用用户的自定义处理函数。由于信号的发送是需要由用户态切换到内核态，处理也是需要进入内核态，所以用信号这种实现进程间通信的手段会导致信号有很强的延时性。虽然有延时，但是这个时间对于用户来说是非常短的，用户基本上察觉不到。

进程的相关信息存储在PCB中，在PCB中有阻塞信号集和未决信号集。阻塞信号集的作用是对信号进行阻塞，若一个信号被阻塞之后如果收到了该信号就会留在未决信号集中，不会被处理。未决信号集是用于存储需要处理的信号，这些信号因为某些原因不能抵达，在解决屏蔽之前，信号都是一直处于未决状态。当信号被处理，这信号会从未决信号集中消失。

信号有四要素，分别是信号的编号、信号的名称、产生信号的事件和默认的处理动作。其中，信号编号为1~31之间的信号为常规信号，也称为普通信号或者标准信号。34~64之间的信号称为实时信号，与驱动编程和硬件相关。下面是信号的四要素表：

在这里插入图片描述在这里插入图片描述
信号编号表：

在这里插入图片描述

从上面可以看到这些信号的编号在不同的操作系统架构中是不一样的，因此我们使用信号的时候应该使用信号的名称。在上面的所有信号之中，特别需要注意SIGKILL和SIGSTOP信号是不能被捕获和阻塞或者是忽略的。

在系统编程中，我们常用的信号有SIGINT、SIGQUIT、SIGKILL、SIGSEGV、SIGUSR1、SIGUSR2、SIGPIPE、SIGALRM、SIGTERM、SIGCHLD、SIGSTOP、SIGCONT。

这些信号的含义如下：

常用信号含义
SIGINT按键中断
SIGQUIT退出
SIGKILL杀死
SIGSEGV内存溢出非法操作内存等
SIGUSR1用户使用自定义信号
SIGUSR2用户使用自定义信号
SIGPIPE管道破裂
SIGALRM定时器信号
SIGTERM终止信号
SIGCHLD子进程死亡、暂停、继续时给父进程发送的信号
SIGSTOP暂停进程
SIGCONT继续运行暂停的进程

2. 信号相关函数

2.1 signal

该函数用于注册信号捕捉函数，函数的原型如下：

#include <signal.h>

// 信号处理函数类型
typedef void (*sighandler_t)(int);

// 作用: 注册信号捕捉函数
// 返回值: 以前信号的处理函数指针
// 参数: signum: 信号编号
//       handler: 信号处理函数
sighandler_t signal(int signum, sighandler_t handler);

该函数的使用示例如下：

// signal函数测试--注册信号处理函数
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

// 信号处理函数
void sighandler(int signo)
{
	printf("signo = [%d]\n", signo);
}

int main()
{
	// 注册信号处理函数
	signal(SIGINT, sighandler);

	sleep(200);

	return 0;
}

需要注意的是signal函数的行为在不同的UNIX版本之间是不同的，在不同的Linux版本之间也是不同的，应该避免是用它，后续会用sigaction函数取代。

2.2 kill

kill函数用于给指定的进程发送指定的信号。该函数的原型为：

#include <sys/types.h>
#include <signal.h>

// 作用: 给指定进程发送指定信号
// 返回值: 成功返回0，失败返回-1并设置errno
// 参数:  pid: 进程号
//             pid > 0: 发送信号给指定进程。
//             pid = 0: 发送信号给调用kill进程属于同一进程组的
//                      所有进程。
//             pid < -1: 发送给pid绝对值对应的进程组。
//             pid = -1: 发送给进程有权限发送的系统中所有进程。
//        sig: 信号
int kill(pid_t pid, int sig);

函数中的sig信号参数不推荐使用数字，应该使用宏名，因为不同的操作系统信号编号可能不一样，但名称不一样。

在Linux中，每一个进程都属于一个进程组，进程组是一个或者多个进程的集合，他们是相互关联的，共同完成一个实体任务，每一个进程都有一个进程组长，默认进程组ID与进程组组长ID相同。

关于kill的示例代码如下：

// kill函数测试--发送信号
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

// 信号处理函数
void sighandler(int signo)
{
	printf("signo = [%d]\n", signo);
	kill(getpid(), SIGKILL);
}

int main()
{
	// 注册信号处理函数
	signal(SIGINT, sighandler);

	while(1)
	{
		sleep(1);
		kill(getpid(), SIGINT);
	}

	return 0;
}

2.3 abort和raise

这两个函数是进程自己给自己发送信号，其中abort用于给自己发送异常终止信号SIGABRT，并会产生core文件，而raise函数是用于给自己发送指定信号。这两个函数的原型如下：

#include <signal.h>

// 作用: 给当前进程发送指定信号，自己给自己发
// 返回值: 成功返回0，失败返回非0值
// 参数: sig: 信号编号
int raise(int sig);

#include <stdlib.h>

// 作用: 给自己发送异常终止信号SIGABRT，并产生core文件
void abort(void);

这两个函数的功能都可以使用kill函数实现。这两个函数的示例代码如下：

raise函数测试

// raise函数测试 -- 给自己发送指定信号
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

// 信号处理函数
void sighandler(int signo)
{
	printf("signo = [%d]\n", signo);
	raise(SIGKILL);
}

int main()
{
	// 注册信号处理函数
	signal(SIGINT, sighandler);
	
	while(1)
	{
		raise(SIGINT);
	}

	return 0;
}

abort函数测试

// abort函数测试 -- 给自己发送异常终止信号
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

// 注册信号处理函数
void sighandler(int signo)
{
	printf("signo = [%d]\n", signo);
	raise(SIGSTOP);
}

int main()
{
	// 注册信号处理函数
	signal(SIGABRT, sighandler);

	abort();
	
	return 0;
}

2.4 alarm

该函数主要是用于设置定时器。函数的原型如下：

#include <unistd.h>

// 作用: 设置定时器（闹钟），在指定seconds之后，内核会给当前进程发送
//       SIGALRM信号。进程收到该信号之后，默认动作为终止。每一个进程
//       都有且只有唯一的一个定时器。
// 返回值: 返回0或者剩余的秒数，无失败的返回
// 参数: seconds: 秒数
unsigned int alarm(unsigned int seconds);

该函数的如果把参数设置为0就表示取消定时器，也就是alarm(0)。alarm函数使用的是自然定时，与进程的状态无关，无论进程处于什么状态alarm都计时。该函数的示例代码如下：

// alarm函数测试--设置定时器
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

int main()
{
	// 设置定时器
	int ret = alarm(5);
	printf("ret = [%d]\n", ret);
	
	sleep(2);

	ret = alarm(4);
	printf("ret = [%d]\n", ret);

	sleep(1);

	ret = alarm(4);
	printf("ret = [%d]\n", ret);

	while(1)
	{
		sleep(1000);
	}

	return 0;
}

2.5 setitimer

setitimer函数也是用于设置定时器的，可以代替alarm函数。该函数的精确到微妙，可以实现周期定时。函数的原型如下：

#include <sys/time.h>

// 作用: 设置定时器，精度为微妙，可以实现周期定时。
// 返回值: 成功返回0，失败返回-1并设置errno。
// 参数: which: 定时方式。
//       new_value: 负责设定timeout时间
//       old_value: 存放旧的timeout时间，一般指定为NULL。 
int setitimer(int which, const struct itimerval *new_value,
                    struct itimerval *old_value);

// 参数的结构体
struct itimerval {
       struct timeval it_interval; // 闹钟触发周期
       struct timeval it_value;    // 闹钟第一次触发时间
};

struct timeval {
       time_t      tv_sec;         // 秒
       suseconds_t tv_usec;        // 微妙
};

其中定时方式主要有以下几种：

定时方式宏名信号含义
自然定时ITIMER_REALSIGALRM计算自然时间
虚拟空间计时（用户空间）ITIMER_VIRTUALSIGVTALRM只计算占用CPU的时间
运行时计时（用户 + 内核）ITIMER_PROFSIGPROF计算占用CPU以及执行系统调用的时间

该函数的使用示例如下：

// setitimer函数测试
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>
#include <signal.h>

// 信号处理函数
void sighandler(int signo)
{
	printf("signo = [%d]\n", signo);
}

int main()
{
	// 注册信号处理函数
	signal(SIGALRM, sighandler);

	// 设置周期时间
	struct itimerval tm;
	tm.it_interval.tv_sec = 1;
	tm.it_interval.tv_usec = 0;
	tm.it_value.tv_sec = 3;
	tm.it_value.tv_usec = 0;

	setitimer(ITIMER_REAL, &tm, NULL);

	while(1)
	{
		sleep(1);
	}

	return 0;
}

3. 信号集

信号集主要是两个信号集。第一个是未决信号集，该信号集存放了当前进程要阻塞的信号。第二个是阻塞信号集，该信号集存放了当前进程中还处于未决状态的信号。这两个集合都存储在PCB中。

在一个进程运行的时候，如果该进程收到了一个信号A，则这个信号首先会被保存到未决信号集中对应的信号编号的存储位置，将该位置置为1，此时该信号处于未决状态。当要处理这个信号的时候，会去检查阻塞信号集中对应的信号编号的存储位置上是否为0，若为1表示需要阻塞该信号，则信号不会被处理，若为0则表示该信号不被阻塞。当未决信号集的信号没有被阻塞被处理之后，未决信号集的信号编号对应的存储位置会被重置为0。

信号集在Linux中使用sigset_t进行定义。该类型是一个结构体，结构体定义如下：

#ifndef ____sigset_t_defined
#define ____sigset_t_defined

#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
{
  unsigned long int __val[_SIGSET_NWORDS];
} __sigset_t;

#endif

由于信号集属于内核的一块区域，所以用户不能直接操作内核空间，因此我们需要使用信号集相关的一些接口函数完成对信号集的相关操作。

接下来看一些信号集的相关函数，信号集相关函数原型如下：

#include <signal.h>

// 作用: 将某个信号集清0
// 返回值: 成功返回0，失败返回-1并设置errno
// 参数: set: 信号集
int sigemptyset(sigset_t *set);

// 作用: 将某个信号集置1
// 返回值: 成功返回0，失败返回-1并设置errno
// 参数: set: 信号集
int sigfillset(sigset_t *set);

// 作用: 将某个信号加入到信号集中
// 返回值: 成功返回0，失败返回-1并设置errno
// 参数: set: 信号集
//      signum: 信号编号
int sigaddset(sigset_t *set, int signum);

// 作用: 将某个信号清出信号集
// 返回值: 成功返回0，失败返回-1并设置errno
// 参数: set: 信号集
//      signum: 信号编号
int sigdelset(sigset_t *set, int signum);

// 作用: 判断某个信号是否在信号集中
// 返回值: 存在返回1，不存在返回0，失败返回-1并设置errno
// 参数: set: 信号集
//      signum: 信号编号
int sigismember(const sigset_t *set, int signum);


#include <signal.h>

// 作用: 用于屏蔽信号，解除屏蔽信号
// 返回值: 成功返回0，失败返回-1并设置error
// 参数: how: 参数取值决定函数的作用，how的取值有以下:
//              SIG_BLOCK: 设置屏蔽信号，set为需要屏蔽的信号
//              SIG_UNBLOCK: 设置解除屏蔽信号，set表示要解除屏蔽信号
//              SIG_SETMASK: set用于代替原始屏蔽集的新屏蔽集
//       set: 需要设置的信号集
//       oldset: 在设置操作之前的信号集 
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

#include <signal.h>

// 作用: 读取当前进程的未决信号集
// 返回值: 成功返回0，失败返回-1并设置errno
// 作用: set: 信号集
int sigpending(sigset_t *set);

接下来使用一个例子来说明以下信号集相关函数的使用，该例子的作用是将当前进程未决信号集中的常用信号集打印出来。

// 信号集相关函数测试
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <signal.h>
#include <unistd.h>

// 信号处理函数
void sighandler(int signo)
{
	printf("signo = [%d]\n", signo);
}

int main()
{
	// 注册信号处理函数
	signal(SIGINT, sighandler);
	signal(SIGQUIT, sighandler);

	// 定义信号集
	sigset_t set; // 设置的信号集
	sigset_t pending; // 未决信号集
	sigset_t oldset; // 保存之前的信号集

	// 初始化信号集
	sigemptyset(&set);
	sigemptyset(&oldset);
	sigemptyset(&pending);

	// 将SIGINT和SIGQUIT加入到信号集中
	sigaddset(&set, SIGINT);
	sigaddset(&set, SIGQUIT);

	// 将SIGINT和SIGQUIT加入到阻塞信号集中
	// sigprocmask(SIG_BLOCK, &set, NULL);
	sigprocmask(SIG_BLOCK, &set, &oldset);

	int j = 1;

	while(1)
	{
		// 获取未决信号集
		sigpending(&pending);

		for(int i = 1; i < 32; i ++)
		{
			// 判断某个信号是否位于信号集中
			if(sigismember(&pending, i))
			{
				printf("1");
			}
			else 
			{
				printf("0");
			}
		}
		printf("\n");

		if(j ++ % 10 == 0)
		{
			// 解除阻塞
			// sigprocmask(SIG_UNBLOCK, &set, NULL);
			sigprocmask(SIG_UNBLOCK, &set, &oldset);
		}
		else
		{
			// 阻塞
			sigprocmask(SIG_BLOCK, &set, NULL);
		}

		sleep(1);

	}

	return 0;
}

程序的运行结果如下：

在这里插入图片描述

4. 信号捕捉函数

这里的信号处理函数是说的sigaction，该函数的作用和signal一样。不同的signal函数在不同的Unix或者Linux下其行为可能是不一样的，而sigaction的行为都是一样的，想要做一个跨平台的程序一般使用sigaction函数。该函数的原型如下：

#include <signal.h>

// 作用: 注册一个信号处理函数
// 返回值: 成功返回0，失败返回-1并设置errno
// 参数: signum: 捕捉的信号
//       act: 新的处理方式
//       oldact: 旧的处理方式
int sigaction(int signum, const struct sigaction *act,
                     struct sigaction *oldact);

// struct sigaction 定义如下
struct sigaction {
    // 信号处理函数
    void     (*sa_handler)(int); 
    // 信号处理函数，一般不用这个
    void     (*sa_sigaction)(int, siginfo_t *, void *);
    // 处理期间需要阻塞的信号
    sigset_t   sa_mask;
    // 默认标识，通常设置为0
    int        sa_flags;
    // 已丢弃不用
    void     (*sa_restorer)(void);
};

在上面结构体的sa_handler，表示指定信号捕捉后处理的函数名，也可以赋值为SIG_IGN表示忽略，SIG_DFL表示执行默认动作。sa_mask用于指定在信号处理函数执行期间需要被屏蔽的信号，特别是当某个信号被处理的时候，它自身会被自动放入到进程的信号掩码，因此在信号处理函数执行期间这个信号不会再度发生。需要注意的是sa_mask只在处理函数调用期间屏蔽生效，是一个临时性的设置。另外需要知道的是信号是不支持排队的。也就是在一个信号处理函数执行期间该函数接收到了很多个该信号，则信号处理函数处理完该信号之后只执行一次处理。

内核再执行信号处理函数的过程如下：

在这里插入图片描述
接下来给一个关于使用sigaction函数的例子。

// sigaction函数测试：信号捕获
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

// 信号处理函数
void sighandler(int signo)
{
	printf("signo = [%d]\n", signo);
	sleep(5);
}

int main()
{
	// 注册信号处理函数
	struct sigaction act;
	act.sa_handler = sighandler; // 信号处理函数
	sigemptyset(&act.sa_mask);
	sigaddset(&act.sa_mask, SIGQUIT);  // 信号执行期间需要阻塞的信号
	act.sa_flags = 0;
	sigaction(SIGINT, &act, NULL); // 注册信号处理函数

	signal(SIGQUIT, sighandler);

	while(1)
	{
		sleep(1);
	}
	
	return 0;
}

6. SIGCHLD信号

SIGCHLD信号主要是由子进程在一定条件下触发并由内核给父进程发送的信号，该信号的产生有三种情况：

  • 子进程结束的时候。
  • 子进程收到SIGSTOP信号。
  • 子进程停止时收到SIGCONT信号。

子进程退出之后，内核会给父进程发送SIGCHLD信号，因此我们可以用这个信号完成对子进程的回收。这样避免父进程一直阻塞等待而不能执行其它操作。在回收子进程的时候，我们需要考虑到有可能还没有完成信号注册的时候子进程就可能退出了，也有可能在SIGCHLD处理期间SIGCHLD再次产生了很多次，若不进行多次回收则会出现僵尸进程。

避免第一个问题的方法是在注册处理函数之前先对SIGCHLD信号进行阻塞；第二个问题的解决是使用循环进行多次回收。因此我们可以写出来以下用SIGCHLD函数完成子进程回收的例子。关于信号产生的条件可以自行验证。

// 使用SIGCHLD回收子进程的资源
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>

// 注册信号处理函数
void sighandler(int signo)
{
	while(1)
	{
		pid_t wpid = waitpid(-1, NULL, WNOHANG);
		if(wpid > 0)
		{
			printf("Child pid = [%d] is dead\n", wpid);
		}
		else if(wpid == 0)
		{
			printf("Child is living\n");
			break;
		}
		else if(wpid == -1)
		{
			printf("No child is living\n");
			break;
		}
	}
}

int main()
{
	// 在注册SIGCHLD之前阻塞SIGCHLD信号
	sigset_t  set;
	sigemptyset(&set);
	sigaddset(&set, SIGCHLD);
	sigprocmask(SIG_BLOCK, &set, NULL);
	
	// 创建子进程
	int i;
	for(i = 0; i < 3; i ++)
	{
		pid_t pid = fork();
		if(pid < 0)
		{
			perror("fork error");
			return -1;
		}
		else if(pid == 0)
		{
			printf("Child: pid = [%d], fpid = [%d]\n", getpid(), getppid());
			break;
		}

	}
	
	if(i == 0)
	{
		printf("I am child [%d]\n", getpid());
		sleep(2);
	}
	else if(i == 1)
	{
		printf("I am child [%d]\n", getpid());
		sleep(1);
	}
	else if(i == 2)
	{
		printf("I am child [%d]\n", getpid());
		sleep(2);
	}
	else if(i == 3)
	{
		sleep(4);
		// 注册信号处理函数
		struct sigaction act;
		act.sa_handler = sighandler;
		sigemptyset(&act.sa_mask);
		act.sa_flags = 0;
		sigaction(SIGCHLD, &act, NULL);

		// 取消阻塞
		sigprocmask(SIG_UNBLOCK, &set, NULL);

	}

	return 0;
}

7. SIGUSR1与SIGUSR2

在系统编程的时候，我们不能随便乱使用kill函数去对某个进行发送一个系统的信号，因此操作系统提供用户两个信号使用。接下来我们使用这个两个信号完成两个进程交替数数。示例代码如下：

// 使用SIGUSR实现交替数数
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

int num = 0;
int flag;

// 信号处理函数
void sigusr1handler(int signo)
{
	printf("USR1: [%d]\n", num);
	num += 2;
	flag = 0;
	sleep(1);
}

void sigusr2handler(int signo)
{
	printf("USR2: [%d]\n", num);
	num += 2;
	flag = 0;
	sleep(1);
}

int main()
{
	// 创建子进程
	pid_t pid = fork();
	if(pid < 0)
	{
		perror("fork error");
		return -1;
	}
	else if(pid == 0)
	{
		// 注册信号处理函数
		struct sigaction act;
		act.sa_handler = sigusr2handler;
		sigemptyset(&act.sa_mask);
		act.sa_flags = 0;
		sigaction(SIGUSR2, &act, NULL);

		num = 2;
		flag = 0;
		while(1)
		{
			if(flag == 0)
			{
				kill(getppid(), SIGUSR1);
				flag = 1;
			}
		}
	}
	else 
	{
		// 注册信号处理函数
		struct sigaction act;
		act.sa_handler = sigusr1handler;
		sigemptyset(&act.sa_mask);
		act.sa_flags = 0;
		sigaction(SIGUSR1, &act, NULL);

		num = 1;
		flag = 1;
		while(1)
		{
			if(flag == 0)
			{
				kill(pid, SIGUSR2);
				flag = 1;
			}
		}
	}

	return 0;
}

运行结果为：

在这里插入图片描述
在上面的代码之中，我们分别通过信号处理函数来控制while循环中的if语句是否执行。两个进程分别互相发送信号就可以完成进程的交替输出。由于flag变量和num变量需要在信号处理函数中能够访问，所以定义成了全局变量。具体的运行过程可以通过分析程序结构理解理解。

月仙儿
关注
  • 24
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux操作系统day01.pdf
03-28
Linux操作系统day01.pdf
Linux系统编程Day07
weixin_46412362的博客
03-11 102
1.匿名映射实现父子进程通信 通过使用我们发现，使用映射区来完成文件读写操作十分方便，父子进程间通信也 较容易。但缺陷是，每次创建映射区一定要依赖一个文件才能实现。 通常为了建立映射区要open一个temp文件，创建好了再unlink、close掉，比较 麻烦。 可以直接使用匿名映射来代替。 其实Linux系统给我们提供了创建匿名映射区的方法，无需依赖一个文件即可创建 映射区。同样需要借助标志位参数flags来指定。 使用MAP_ANONYMOUS (或MAP_ANON)。 int *p =
Linux环境编程day07
weixin_61180910的博客
08-31 298
关于进程间通信
Linux环境编程Day07
weixin_53854228的博客
09-10 58
进程的正常退出： 1、在main函数中执行returnn,该返回值可以被父进程接收到的，在main函数中与exit几乎等价的 2、进程调用了exit函数，该函数是标准库函数 voidexit(intstatus); 功能：在任何时候调用此函数都可以结束进程 status：结束状态码 EXIT_SUCCESS EXIT_FAILURE ...
Day03 linux高级系统编程--进程
aisheisadas的博客
12-06 907
程序与进程程序:本质上一个可执行文件静态的进程:一个正在进程的程序动态的占据运行内存单道程序与多道程序单道程序:同时只能做一件事,A阻塞,B等待多道程序:同时可以做多件事,A阻塞,B正常执行并行与并发并行:有多核每个进程一个核同时执行并发:一个核多个进程交替执行在宏观上来看是并行在微观上来看是交替执行进程号父进程号进程组号会话号终端每个进程系统都会为其分配一个编号,该编号就是进程号进程号取值范围:0~32767。
Linux系统编程day5知识点总结回顾2
qq_40858438的博客
03-12 122
Linux系统编程day5知识点总结回顾21.消费者和生产者模型1.1 没加锁情况1.2 加 条件变量 与 互斥锁 代码2.信号量相关2.1 互斥锁 和 信号量 对比2.2 信号量3. 使用 信号量 完成生产者和消费者模型3.1 实现思路3.2 实现代码4. 练习：哲学家就餐问题思路 1.消费者和生产者模型 1.1 没加锁情况 框架先搭起来 生产者代码 消费者代码 1.2 加 条件变量 与...
Linux系统编程Day08
weixin_46412362的博客
03-13 112
1.终端的概念 进程中，控制终端是保存在PCB中的信息，而fork会复制PCB中的信息，因此由Shell 进程启动的其它进程的控制终端也是这个终端。 默认情况下（没有重定向），每个进程的标准输入、标准输出和标准错误输出都指向 控制终端，进程从标准输入读也就是读用户的键盘输入，进程往标准输出或标准错误输出 写也就是输出到显示器上。 在控制终端输入一些特殊的控制键可以给前台进程发信号，例如Ctrl+C表示SIGINT， Ctrl+\表示SIGQUIT。 函数说明： #include <un
Linux系统编程Day09
weixin_46412362的博客
03-14 56
1.互斥锁 1.1 同步与互斥概述 现代操作系统基本都是多任务操作系统，即同时有大量可调度实体在运行。在多任 务操作系统中，同时运行的多个任务可能： 1.都需要访问/使用同一种资源. 2.多个任务之间有依赖关系，某个任务的运行依赖于另一个任务 这两种情形是多任务编程中遇到的最基本的问题，也是多任务编程中的核心问题， 同步和互斥就是用于解决这两个问题的。 互斥：是指散步在不同任务之间的若干程序片断，当某个任务运行其中一个程序片 段时，其它任务就不能运行它们之中的任一程序片段，只能等到该任务运行完这
Linux系统编程Day05
weixin_46412362的博客
03-05 152
1.文件操作 1.1 fcnlt函数 #include <unistd.h> #include <fcntl.h> ​ int fcntl(int fd, int cmd, ... /* arg */); 功能：改变已打开的文件性质，fcntl针对描述符提供控制。 参数： fd：操作的文件描述符 cmd：操作方式 arg：针对cmd的值，fcntl能够接受第三个参数int arg。 返回值： 成功：返回某个其他值 失败：-1 fcnt
Linux系统编程 day06 进程间通信
月仙儿的博客
11-28 868
进程间通信的概念、匿名管道pipe、命名管道FIFO、内存映射区mmap
达内linux高级编程day2经典案例
09-08
达内linux高级编程day2经典案例
linux从零基础系统编程开始视频教程.zip
07-05
目录网盘文件永久链接 Day1（命令基础，软件安装与卸载） Day2 （vim、动静态库） ...Day8 （信号、信号捕捉） Day9 （守护进程、线程、线程控制、线程属性） Day10 （线程同步、信号量、条件变量）
day07-Elasticsearch03
12-13
day07-Elasticsearch03
day03.rar_Linux/Unix编程_Unix_Linux_
08-11
这是一个在linux系统下求平均数的简单小程序，希望对初接触linux的同学有用
linux下的调试工具gdb的详细使用介绍
最新发布
qq_75270497的博客
05-06 968
详细介绍在linux下使用gdb的方法，每个步骤都举例说明，适合复习和新手入门，希望能为能够帮助到大家。
【Linux】开始认识软硬链接
JLX_1的博客
04-29 3319
本文通过对文件系统的总结，讲解了Linux中的软硬链接
Linux 第十八章
一怀明月的博客
05-01 1348
程序地址空间 区间的地址分布 真正理解同一个地址进行读取不同内容 地址空间 虚拟地址和物理地址 虚拟地址： 物理地址： struct mm_struct 页表
Linux的基本指令
道阻且长，行则将至，关注我，和我一起奔赴下一场山海!
05-03 604
先讲基本概念:在Linux当中，它的路径分隔符是斜杠/ Linux当中的文件和目录其实是一棵。可以删文件,但是在删的过程中，系统会给提示时问你确定还是否,如果觉得麻烦，可以直接。05.touch 具体文档格式名（创建一个普通的文件）centos系统中，所有的普通用户都会放在home目录下。大佬的支持和鼓励，将是我成长路上最大的动力。大佬的支持和鼓励，将是我成长路上最大的动力。01.ls指令（查看当前文件下所有列表）可以用来定位当前目录下的一个文件）作用:创建一个普通的文件。04.cd（改变目录）
linux daya
09-16
在Linux中，数据是指在网络连接上控制谁可以与您的Linux系统通信以及他们如何进行通信的方法。这对于在互联网这个庞大的无法受控制的网络中，攻击可能来自任何角落的情况下非常重要。除此之外，Linux Daya是一个GNU ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值