进程相关操作

最新推荐文章于 2024-05-17 20:39:26 发布
最新推荐文章于 2024-05-17 20:39:26 发布
阅读量918 收藏 19
点赞数 24
文章标签： 算法 linux 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/VJOEE/article/details/135440674
版权

Linux下编程

产生进程

调用fork函数创建子进程

exit - 终止正在执行的进程

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

#include <unistd.h>
#include <stdio.h>
#include<stdlib.h>

int main()
{
    pid_t fpid;//fpid表示fork函数返回的值
    int count = 0;
    int status = 0;

    fpid=fork();

    if (fpid < 0)
        printf("error in fork!");
    else if (fpid == 0) {
        printf("i am the child process, my process id is %d\n",getpid());
        printf("I’m children\n");
        count +=2;
        exit(2);
    }
    else {
        printf("i am the parent process, my process id is %d\n",getpid());
        printf("I’m parent.\n");
        count++;
    }
    printf("统计结果是: %d\n",count);
    //父进程捕捉子进程的状态

    wait(&status);
    printf("parent : status : %d\n", WEXITSTATUS(status));
    return 0;
}

多进程

#define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdint.h>

#include<sys/wait.h>

typedef void (*spawn_proc_pt) (void *data);
static void worker_process_cycle(void *data);
static void start_worker_processes(int n);
pid_t spawn_process(spawn_proc_pt proc, void *data, char *name); 

int main(int argc,char **argv){
start_worker_processes(4);
//管理子进程
    wait(NULL);
}

void start_worker_processes(int n){
    int i=0;
    for(i = n - 1; i >= 0; i--){
       spawn_process(worker_process_cycle,(void *)(intptr_t) i, "worker process");
    }
}

pid_t spawn_process(spawn_proc_pt proc, void *data, char *name){

    pid_t pid;
    pid = fork();

    switch(pid){
    case -1:
        fprintf(stderr,"fork() failed while spawning \"%s\"\n",name);
        return -1;
    case 0:
          proc(data);
          return 0;
    default:
          break;
    }   
    printf("start %s %ld\n",name,(long int)pid);
    return pid;
}


static void worker_process_init(int worker){
    cpu_set_t cpu_affinity;
    //worker = 2;
	//多核高并发处理  4core  0 - 0 core 1 - 1  2 -2 3 -3  
    CPU_ZERO(&cpu_affinity);
    CPU_SET(worker % CPU_SETSIZE,&cpu_affinity);// 0 1 2 3 
    //sched_setaffinity
    if(sched_setaffinity(0,sizeof(cpu_set_t),&cpu_affinity) == -1){
       fprintf(stderr,"sched_setaffinity() failed\n");
    }
}

void worker_process_cycle(void *data){
     int worker = (intptr_t) data;
    //初始化
     worker_process_init(worker);

    //干活
    for(;;){
      sleep(10);
      printf("pid %ld ,doing ...\n",(long int)getpid());
    }
}

 这段代码是一个简单的多进程管理程序，它创建了多个子进程并让它们在不同的CPU核心上运行。

  1. start_worker_processes函数：这个函数用于启动多个工作进程。它接收一个整数参数n，表示要启动的工作进程数量。然后使用spawn_process函数创建了n个工作进程。

  2. spawn_process函数：这个函数使用fork创建一个新的子进程。如果fork失败，它会返回-1。如果是子进程，它会调用传入的proc函数，并传入data参数。如果是父进程，它会打印出子进程的PID并返回该PID。

  3. worker_process_init函数：这个函数用于初始化工作进程。它接收一个整数参数worker，表示工作进程的编号。然后使用sched_setaffinity函数将工作进程绑定到特定的CPU核心上。

  4. worker_process_cycle函数：这个函数是一个无限循环，表示工作进程的主循环。它首先调用worker_process_init函数来初始化工作进程，然后进入一个无限循环，在循环中每隔10秒打印一次进程的PID。

        在main函数中，start_worker_processes函数被调用来启动4个工作进程，然后使用wait函数来等待所有子进程结束。整体上，这段代码实现了创建多个工作进程并让它们在不同的CPU核心上运行的功能。

孤儿 僵尸 守护 进程

孤儿进程

        孤儿进程是指一个子进程在父进程结束后仍然在系统中运行的进程。产生孤儿进程的主要原因是父进程先于子进程结束，导致子进程成为孤儿进程。孤儿进程会被系统init进程接管，并由init进程负责回收其资源，因此不会对系统造成影响。

僵尸进程

     僵尸进程是指一个子进程在结束后，父进程没有及时回收其资源，导致子进程的进程描述符仍然保留在系统中，但进程已经不再运行。产生僵尸进程的主要原因是父进程没有正确处理子进程的结束信号。如果系统中存在大量的僵尸进程，会导致系统资源的浪费。僵尸进程是非常特殊的一种，它已经放弃了几乎所有内存空间，没有任何可执行代码，也不能被调度，仅仅在进程列表中保留一个位置，记载该进程的退出状态等信息供其他进程收集，除此之外，僵尸进程不再占有任何内存空间

    解决孤儿进程和僵尸进程的方法是通过正确的进程管理和信号处理。

        父进程在创建子进程后应该及时等待子进程的结束，并回收其资源。可以使用wait()或waitpid()系统调用来等待子进程的结束，并回收其资源。另外，父进程还可以使用信号处理机制来处理子进程的结束信号，及时回收其资源。通过正确的进程管理和信号处理，可以有效避免孤儿进程和僵尸进程的产生。

怎么查看僵尸进程：

　　利用命令ps，可以看到有标记为<defunct>的进程就是僵尸进程。

怎样来清除僵尸进程：

  改写父进程，在子进程死后要为它收尸。具体做法是接管SIGCHLD信号。子进程死后，会发送SIGCHLD信号给父进程，父进程收到此信号后，执行waitpid()函数为子进程收尸。这是基于这样的原理：就算父进程没有调用 wait，内核也会向它发送SIGCHLD消息，尽管对默认处理是忽略，如果想响应这个消息，可以设置一个处理函数。

  把父进程杀掉。父进程死后，僵尸进程成为"孤儿进程"，过继给1号进程init，init始终会负责清理僵尸进程。它产生的所有僵尸进程也跟着消失。

守护进程

        是在后台运行的进程，通常用于执行一些系统任务或服务。守护进程通常在系统启动时启动，并且在系统关闭时结束。守护进程通常不与用户交互，而是在后台默默地执行任务。

  不与任何终端关联的进程，通常情况下守护进程在系统启动时就在运行，它们以root用户或者其他特殊用户(apache和postfix)运行，并能处理一些系统级的任务。守护进程脱离于终端，是为了避免进程在执行过程中的信息在任何终端上显示，并且进程也不会被任何终端所产生的终端信息所打断（比如关闭终端等）。那如何成为一个守护进程呢？ 步骤如下：

  1. 1.调用fork(),创建新进程,它会是将来的守护进程.
  2. 2.在父进程中调用exit,保证子进程不是进程组长
  3. 3.调用setsid()创建新的会话区
  4. 4.将当前目录改成根目录(如果把当前目录作为守护进程的目录,当前目录不能被卸载他作为守护进程的工作目录)
  5. 5.将标准输入,标准输出,标准错误重定向到/dev/null.
#include <fcntl.h>
#include <unistd.h>

int daemon(int nochdir, int noclose)
{
    int fd;

    switch (fork()) {
    case -1:
        return (-1);
    case 0:
        break;
    default:
        _exit(0);
    }

    if (setsid() == -1)
        return (-1);

    if (!nochdir)
        (void)chdir("/");

    if (!noclose && (fd = open("/dev/null", O_RDWR, 0)) != -1) {
        (void)dup2(fd, STDIN_FILENO);
        (void)dup2(fd, STDOUT_FILENO);
        (void)dup2(fd, STDERR_FILENO);
        if (fd > 2)
            (void)close (fd);
    }
    return (0);
}

 进程间通信

 信号

        信号是一种用来通知进程发生了某种事件的机制。信号可以用来中断进程、传递信息、处理异常等。当一个进程接收到一个信号时，它可以选择忽略信号、执行默认操作、或者执行自定义操作。常见的信号包括SIGINT（中断信号，通常由Ctrl+C发送）、SIGKILL（强制终止信号）、SIGTERM（终止信号）等。通过发送信号，进程可以与其他进程进行通信和协作。

        信号是给程序提供一种可以处理异步事件的方法，它利用软件中断来实现。不能自定义信号，所有信号都是系统预定义的。

+--------+------------+--------------------------------------------------------+
| 信号   | 信号编号   | 含义                                                   |
+--------+------------+--------------------------------------------------------+
| SIGHUP | 1          | 终端挂起或控制进程终止                                   |
| SIGINT | 2          | 中断进程，通常由用户在终端按下Ctrl+C时发送                |
| SIGQUIT| 3          | 类似SIGINT，但是在用户请求时产生core dump                |
| SIGILL | 4          | 检测非法指令                                            |
| SIGTRAP| 5          | 断点调试，由调试器生成                                   |
| SIGABRT| 6          | 调用abort函数生成的信号，用于异常终止进程                 |
| SIGBUS | 7          | 非法地址访问                                            |
| SIGFPE | 8          | 浮点异常，如被零除或者浮点溢出                           |
| SIGKILL| 9          | 强制终止进程，不能被捕获或忽略                           |
| SIGUSR1| 10         | 用户自定义信号1                                         |
| SIGSEGV| 11         | 无效的内存引用，如访问不存在的内存                       |
| SIGUSR2| 12         | 用户自定义信号2                                         |
| SIGPIPE| 13         | 向一个没有读取进程的管道写入数据                         |
| SIGALRM| 14         | 由alarm函数设置的定时器到期时发送                        |
| SIGTERM| 15         | 请求进程终止，可以被捕获和处理                           |
+--------+------------+--------------------------------------------------------+

信号的处理

        忽略此信号；

        捕捉信号，指定信号处理函数进行处理执行系统默认动作；

        大多数都是终止进程。

信号的捕获

    信号的捕获，是指，指定接受到某种信号后，去执行指定的函数。

    注意：SIGKILL和SIGSTOP不能被捕获，即，这两种信号的响应动作不能被改变。

    1) 使用signal

        用法：man 2 signal

         typedef void (*sighandler_t)(int);

         sighandler_t signal(int signum, sighandler_t handler)

        注：signal的返回类型，和它的第二个参数，都是函数指针类型

        signal的参数2可去以下特殊值：

        SIG_IGN     忽略信号

        SIG_DFL     恢复默认行为

 使用SIG_DFL时，仅当第一次调用自定义的行为后马上使用SIG_DFL就可恢复，如果连续捕获多次后，就不确定。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

void myhandle(int sig) 
{
	static int cnt = 0;
    if(cnt == 2)
    {
        signal(SIGINT, SIG_DFL); //等同于signal(sig, SIG_DFL);恢复默认的SIGINT信号
    }
	printf("Catch a signal : %d\n", sig);
    printf("cnt = %d\n", cnt);
    cnt = cnt + 1;
}

int main(void) 
{
	signal(SIGINT, myhandle);

	while (1) {
        sleep(1);
	}

	return 0;
}

        使用signal函数来注册一个名为myhandle的自定义信号处理函数来处理SIGINT信号。当程序接收到SIGINT信号时，myhandle函数将被调用，并打印出“Catch a signal : %d”这样的信息，其中%d将被替换为接收到的信号值。

        在myhandle函数中，使用了static变量cnt来记录接收到的信号次数，并在函数中打印出接收到的信号值。signal(SIGINT, SIG_DFL);这句代码的作用是将对SIGINT信号的处理方式设置为默认行为。在这个例子中，它将SIGINT信号的处理方式设置为默认行为，即当程序接收到SIGINT信号时，将会终止程序的执行。

        代码中连续在终端按下Ctrl+c就会恢复默认的信号处理

  2) 使用sigaction  （项目实战强烈推荐使用）

    建议使用sigaction

      用法：man 2 sigaction

       结构struct sigaction 

struct sigaction {
    void (*sa_handler)(int);   /* 信号的响应函数 */
    sigset_t   sa_mask;          /* 屏蔽信号集 */                         
    int sa_flags;                /* 当sa_flags中包含 SA_RESETHAND时，接受到该信号并调用指定的信号处理函数执行之后，把该信号的响应行为重置为默认行为SIG_DFL */
            ...}

        补充：

        当sa_mask包含某个信号A时，则在信号处理函数执行期间，如果发生了该信号A，

         则阻塞该信号A(即暂时不响应该信号），直到信号处理函数执行结束。

         即，信号处理函数执行完之后，再响应该信号A

sigaction改写之前的代码例子

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

void myhandle(int sig) 
{
    // 信号处理函数，当接收到指定信号时被调用
	printf("Catch a signal : %d\n", sig);
}

int main(void) 
{
    // 定义一个sigaction结构体变量act
	struct sigaction act;

    // 将myhandle函数设置为SIGINT信号的处理函数
	act.sa_handler = myhandle;

    // 清空信号集
	sigemptyset(&act.sa_mask);

    // 设置信号处理的标志。在这里使用了SA_RESETHAND标志，表示当信号处理函数被调用时，系统将自动将信号的处理方式重置为默认行为
	act.sa_flags = SA_RESETHAND;

    // 使用sigaction函数注册信号处理函数，并设置相关标志
	sigaction(SIGINT, &act, 0);

	while (1) {
        // 进入一个无限循环，使程序持续运行
	}

	return 0;
}

        这段代码使用了sigaction函数来设置对SIGINT信号的处理方式。具体来说，它将myhandle函数设置为SIGINT信号的处理函数，并且设置了SA_RESETHAND标志，表示当myhandle函数被调用后，系统将自动将SIGINT信号的处理方式重置为默认行为。这样做的好处是，当myhandle函数被调用后，不需要手动将信号的处理方式重置为默认行为，系统会自动完成这个操作。

信号的发送

信号的发送方式：

      在shell终端用快捷键产生信号

      使用kill，killall命令。

      使用kill函数和alarm函数

    1) 使用kill函数

     给指定的进程发送指定信号

     用法：man 2 kill

     注意：

            给指定的进程发送信号需要“权限”：

            普通用户的进程只能给该用户的其他进程发送信号

             root用户可以给所有用户的进程发送信号

     kill失败

         失败时返回-1

         失败原因：

               权限不够

               信号不存在

               指定的进程不存在

    

    创建一个子进程,子进程每秒中输出字符串“child process work!",父进程等待用户输入，如果用户按下字符A, 则向子进程发信号SIGUSR1, 子进程的输出字符串改为大写; 如果用户按下字符a, 则向子进程发信号SIGUSR2, 子进程的输出字符串改为小写

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

// 标志位，用于控制子进程的工作状态
int workflag = 0;

// SIGUSR1 信号处理函数，设置 workflag 为 1，表示子进程应该工作
void work_up_handle(int sig) 
{
    workflag = 1;
}

// SIGUSR2 信号处理函数，设置 workflag 为 0，表示子进程应该停止工作
void work_down_handle(int sig) 
{
    workflag = 0;
}

int main(void) 
{
    pid_t pd;
    char c;

    // 创建子进程
    pd = fork();
    if (pd == -1) 
    {
        printf("fork error!\n");
        exit(1);
    } 
    else if (pd == 0) 
    {
        // 子进程
        char *msg;
        struct sigaction act; 
        act.sa_flags = 0;
        
        // 设置 SIGUSR1 信号处理函数为 work_up_handle
        act.sa_handler = work_up_handle;
        sigemptyset(&act.sa_mask);		
        sigaction(SIGUSR1, &act, 0);
        
        // 设置 SIGUSR2 信号处理函数为 work_down_handle
        act.sa_handler = work_down_handle;
        sigaction(SIGUSR2, &act, 0);
        
        while (1) 
        {
            // 根据 workflag 输出不同的消息
            if (!workflag) 
            {
                msg = "child process work!";
            } 
            else 
            {
                msg = "CHILD PROCESS WORK!";
            }
            printf("%s\n", msg);
            sleep(1);
        }
    } 
    else 
    {
        // 父进程
        while(1) 
        {
            // 读取用户输入字符
            c = getchar();
            if (c == 'A') 
            {
                // 向子进程发送 SIGUSR1 信号
                kill(pd, SIGUSR1);
            } 
            else if (c == 'a') 
            {
                // 向子进程发送 SIGUSR2 信号
                kill(pd, SIGUSR2);
            }
        }
    }

    return 0;
}

这段代码是一个简单的父子进程通信的例子。父进程和子进程通过信号来控制子进程的工作状态。

  1. 首先定义了一个全局变量workflag，用来表示子进程的工作状态。

  2. 接着定义了两个信号处理函数work_up_handle和work_down_handle，分别用来处理SIGUSR1和SIGUSR2信号，当收到这两个信号时，改变workflag的值。

  3. 在main函数中，首先调用fork函数创建一个子进程。如果fork失败，则打印错误信息并退出。

  4. 在子进程中，设置了两个信号处理函数，分别处理SIGUSR1和SIGUSR2信号。然后进入一个无限循环，根据workflag的值输出不同的信息，然后休眠1秒。

  5. 在父进程中，也进入一个无限循环，不断读取用户输入。当用户输入大写字母'A'时，向子进程发送SIGUSR1信号；当用户输入小写字母'a'时，向子进程发送SIGUSR2信号。

    2)使用alarm函数

        作用：在指定时间之内给该进程本身发送一个SIGALRM信号。

        用法：man 2 alarm

        注意：时间的单位是“秒”

                 实际闹钟时间比指定的时间要大一点。  

                 如果参数为0，则取消已设置的闹钟。

                 如果闹钟时间还没有到，再次调用alarm,则闹钟将重新定时

                 每个进程最多只能使用一个闹钟

        返回值：

                 失败：返回-1

                 成功：返回上次闹钟的剩余时间（秒）

   3) 使用raise

        给本进程自身发送信号。

        原型： int  raise (int sig)

 发送多个信号

    某进程正在执行某个信号对应的操作函数期间（该信号的安装函数），如果此时，该进程又多次收到同一个信号（同一种信号值的信号），

则：如果该信号是不可靠信号（<32），则只能再响应一次。

如果该信号是可靠信号（>32），则能再响应多次（不会遗漏）。但是，都是都必须等该次响应函数执行完之后，才能响应下一次。

       

    某进程正在执行某个信号对应的操作函数期间（该信号的安装函数），如果此时，该进程收到另一个信号（不同信号值的信号），则：

    如果该信号被包含在当前信号的signaction的sa_mask（信号屏蔽集）中，则不会立即处理该信号。直到当前的信号处理函数执行完之后，才去执行该信号的处理函数。

    否则：

则立即中断当前执行过程（如果处于睡眠，比如sleep, 则立即被唤醒）而去执行这个新的信号响应。新的响应执行完之后，再在返回至原来的信号处理函数继续执行。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

// 信号处理函数
void myhandle(int sig) 
{
    printf("捕获到信号：%d\n", sig);

    // 模拟处理信号的耗时操作
    int i;
    for (i = 0; i < 10; i++) {
        sleep(1);
    }

    printf("信号处理结束：%d\n", sig);
}

int main(void) 
{
    struct sigaction act, act2;

    // 设置SIGINT信号的处理函数为myhandle
    act.sa_handler = myhandle;

    // 清空信号集
    sigemptyset(&act.sa_mask);

    // 将SIGUSR1信号加入到信号集
    sigaddset(&act.sa_mask, SIGUSR1);

    // 设置标志位为0
    act.sa_flags = 0;

    // 注册信号处理函数
    sigaction(SIGINT, &act, 0);

    // 设置SIGUSR1信号的处理函数为myhandle
    act2.sa_handler = myhandle;

    // 清空信号集
    sigemptyset(&act2.sa_mask);

    // 设置标志位为0
    act2.sa_flags = 0;

    // 注册信号处理函数
    sigaction(SIGUSR1, &act2, 0);

    while (1) {
        // 主程序循环
    }

    return 0;
}

sigaction函数用于设置信号处理函数，并指定了信号处理时的行为。SIGINT和SIGUSR1信号都注册了相同的处理函数myhandle。在信号处理函数中，通过sleep(1)模拟了处理信号的耗时操作。

信号集

    1). 什么是信号集

        信号集，用sigset_t类型表示，实质是一个无符号长整形。

        用来表示包含多个信号的集合。

    2). 信号集的基本操作

        sigemptyset       把信号集清空

        sigfillset          把所有已定义的信号填充到指定信号集

        sigdelset         从指定的信号集中删除指定的信号

        sigaddset        从指定的信号集中添加指定的信号

        sigismember   判断指定的信号是否在指定的信号集中

                              如果是，    返回 1

                              如果不是， 返回 0

                              信号无效， 返回-1

            

        详细用法见  man

    3) 进程的“信号屏蔽字”

        进程的“信号屏蔽字”是一个信号集

        想目标进程发送某信号时，如果这个信号在目标进程的信号屏蔽字中，

        则目标进程将不会捕获到该信号，即不会执行该信号的处理函数。

        当该进程的信号屏蔽字不再包含该信号时，则会捕获这个早已收到的信号（执行对应的函数）

        修改进程的“信号屏蔽字”

        使用sigprocmask

        int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

        参数:

             how:

                   SIG_BLOCK      把参数set中的信号添加到信号屏蔽字中

                   SIG_UNBLOCK  把参数set中的信号从信号屏蔽字中删除

                   SIG_SETMASK  把参数set中的信号设置为信号屏蔽字

             oldset

                  返回原来的信号屏蔽字

   4) 获取未处理的信号

       当进程的信号屏蔽字中信号发生时，这些信号不会被该进程响应，

       可通过sigpending函数获取这些已经发生了但是没有被处理的信号

       用法： man sigpending

       返回值：成功则返回0

                   失败则返回-1

   5) 阻塞式等待信号

       (1) pause

            阻塞进程，直到发生任一信号后

       (2) sigsuspend

            用指定的参数设置信号屏蔽字，然后阻塞时等待信号的发生。

            即，只等待信号屏蔽字之外的信号

管道

        管道（Pipe）是一种用于进程通信的机制，通常用于在父进程和子进程之间传递数据。它是一种半双工的通信方式，允许一个进程向管道写入数据，同时另一个进程从管道读取数据。管道提供了一种在不同进程之间传递信息的简单而有效的方法。

        在Unix/Linux系统中，管道可以通过pipe系统调用创建。以下是关于管道的一些基本概念和使用方法：

 

创建管道：

#include <unistd.h>

int pipe(int pipefd[2]);

pipe函数创建一个管道，pipefd是一个包含两个文件描述符的整数数组，pipefd[0]用于读取数据，pipefd[1]用于写入数据。数据在管道中通过内核缓冲区传递。

 

写入和读取：

使用write函数从管道写入数据，使用read函数从管道读取数据。

#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
ssize_t read(int fd, void *buf, size_t count);

对于管道，fd应为pipefd[1]（写入）或pipefd[0]（读取）。

进程间通信：

管道通常在父子进程间使用，其中父进程创建管道后，通过fork创建子进程。子进程继承了父进程的文件描述符，可以通过管道进行通信。

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>

int main(void)
{
    int pipefd[2];
    char buffer[20];

    //创建管道
    if(pipe(pipefd) == -1)
    {
        printf("create pipe error\n");
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    //创建子进程
    pid_t pid = fork();

    if(pid == -1)
    {
        printf("fork error\n");
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if(pid == 0)    //子进程
    {
        close(pipefd[1]);               //关闭写入端
        read(pipefd[0],buffer,20);      //读取管道内容
        printf("child process read from pipe:%s\n",buffer);
        close(pipefd[0]);               //关闭读取端
    }

    else            //父进程
    {
        close(pipefd[0]);                       //关闭读端
        const char* buffer2 = "hello child!";
        write(pipefd[1],buffer2,strlen(buffer2));     //将数据写入管道
        printf("parent process write to pipe\n");
        close(pipefd[1]);                       //关闭写端
    }

    return 0;
}

上述示例中，父进程通过write向管道写入数据，子进程通过read从管道读取数据。

关闭不使用的文件描述符：

在使用完管道后，应该关闭不再需要的文件描述符，以防止资源泄漏。

close(pipefd[0]);  // 关闭读取端
close(pipefd[1]);  // 关闭写入端

 

消息队列

        消息队列是一种进程间通信的机制，用于在不同进程之间传递数据。它允许一个进程向队列中写入消息，而另一个进程则可以从队列中读取消息。消息队列通常用于实现进程之间的异步通信，其中一个进程可以在不等待另一个进程的响应的情况下继续执行。

消息队列的创建：

        在使用消息队列进行进程通信之前，需要创建消息队列。在UNIX/Linux系统中，可以使用msgget函数创建消息队列。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int msgget(key_t key, int msgflg);
  • key是一个用于唯一标识消息队列的键。
  • msgflg是一组标志，用于指定消息队列的创建方式。

消息的定义：

        消息队列中的消息是一个结构体，其格式由用户定义。在结构体中，通常包含一个标识消息类型的字段和实际的消息数据。

struct my_msg {
    long msg_type;
    char text[256];
};

消息的发送：

        使用msgsnd函数向消息队列发送消息。

#include <sys/msg.h>

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
  • msqid是消息队列的标识符。
  • msgp是指向要发送消息的指针。
  • msgsz是消息的大小。
  • msgflg是一组标志，用于指定发送消息的方式。

 消息的接收：

使用msgrcv函数从消息队列接收消息。

#include <sys/msg.h>

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
  • msqid是消息队列的标识符。
  • msgp是指向存储接收消息的缓冲区的指针。
  • msgsz是缓冲区的大小。
  • msgtyp是要接收的消息类型，如果为0，则接收队列中的第一个消息。
  • msgflg是一组标志，用于指定接收消息的方式。

消息队列的删除：

使用msgctl函数删除消息队列。

#include <sys/msg.h>

int msgctl(int msqid, int cmd, struct msqid_ds *buf);
  • msqid是消息队列的标识符。
  • cmd是指定要执行的操作，如删除等。
  • buf是一个指向msqid_ds结构体的指针，用于提供或接收关于消息队列的信息。

msg_send.cpp

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#include<string.h>

#define MSG_SIZE 256

//定义消息结构体
struct my_msg
{
    long msg_type;          //消息类型
    char text[MSG_SIZE];    //消息内容
};

int main(void)
{

    key_t key;
    int msgid;
    my_msg message;

    //生成一个唯一的键值
    key = ftok("msg_sned.c",'A');

    //创建消息队列
    msgid = msgget(key, 0666 | IPC_CREAT);
    if(msgid == -1)
    {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    //设置消息类型为1
    message.msg_type = 1;

    //输入要发送的消息
    printf("Enter some text to send: ");
    fgets(message.text, MSG_SIZE, stdin);

    //发送到消息队列
    if(msgsnd(msgid, (void *)&message, MSG_SIZE, 0) == -1)
    {
        perror("msgsnd");
        exit(EXIT_FAILURE);
    }

    printf("Data send is: %s\n", message.text);

    return 0;
    
}

 msg_receive.cpp

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>

#define MSG_SIZE 256

// 定义消息结构体
struct my_msg {
    long msg_type;  // 消息类型
    char text[MSG_SIZE];  // 消息内容
};

int main() {
    key_t key;
    int msgid;
    struct my_msg message;

    // 生成一个唯一的键值
    key = ftok("msg_send.c", 'A');

    // 获取消息队列标识符
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    // 接收消息
    if (msgrcv(msgid, (void*)&message, MSG_SIZE, 0, 0) == -1) {
        perror("msgrcv");
        exit(EXIT_FAILURE);
    }

    printf("Message received: %s", message.text);

    // 删除消息队列
    if (msgctl(msgid, IPC_RMID, NULL) == -1) {
        perror("msgctl");
        exit(EXIT_FAILURE);
    }

    return 0;
}

信号量

        信号量（Semaphore）是一种用于进程间通信和同步的机制，通常用于控制对共享资源的访问。信号量可以看作是一个计数器，用于控制多个进程对共享资源的访问。它提供了两个主要的操作：增加和减少。

在信号量中，通常有两种类型的操作：

  1. P 操作（Wait 操作）：

    • 当一个进程要访问共享资源时，它必须执行 P 操作。如果信号量的值大于 0，那么它减 1 并允许访问；如果值为 0，那么进程就必须等待，直到有其他进程释放资源。

  2. V 操作（Signal 操作）：

    • 当一个进程访问完共享资源时，它执行 V 操作。这会增加信号量的值，表示资源现在可用。如果有其他进程正在等待资源，其中一个将被唤醒并获得访问权限。

信号量的特性和使用方式：

  • 计数器：

    • 信号量的值是一个计数器，用于跟踪资源的可用数量。

  • 原子操作：

    • P 和 V 操作是原子操作，确保在多进程环境中不会出现竞争条件。

  • 二进制和计数信号量：

    • 二进制信号量只有两个状态，0 和 1，通常用于互斥。计数信号量的值可以大于 1，用于控制多个资源。

  • 互斥和同步

    • 信号量可以用于实现互斥，确保同一时刻只有一个进程能够访问共享资源。它也可以用于同步，确保进程按照预定的顺序执行。

共享内存机制

        共享内存是 Linux 下一种高效的进程间通信方式，它允许多个进程访问同一块物理内存空间。相比于管道、消息队列等通信方式，共享内存无需在内核中传递数据，而是直接将数据存在共享的内存区域中，因此速度更快。

创建共享内存：

        使用 shmget 函数创建一个新的共享内存区域或获取一个已经存在的共享内存区域的标识符。通常，需要提供一个键值（key），一个大小（size）和一些权限标志。

#include <sys/ipc.h>
#include <sys/shm.h>

key_t key = ftok(".", 's');
int shm_id = shmget(key, 1024, IPC_CREAT | 0666);

连接到共享内存：

        使用 shmat 函数将共享内存连接到进程的地址空间。该函数返回共享内存的起始地址。

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

void *shm_addr = shmat(shm_id, NULL, 0);

访问共享内存：

  • 通过访问指针 shm_addr 可以读写共享内存中的数据。
strcpy(shm_addr, "Hello, shared memory!");

分离共享内存：

  • 使用 shmdt 函数将共享内存从进程的地址空间分离。
shmdt(shm_addr);

删除共享内存：

  • 使用 shmctl 函数来删除共享内存。
shmctl(shm_id, IPC_RMID, NULL);

下面是一个简单的例子，包括两个程序，一个用于写入共享内存，另一个用于读取共享内存。

write_shared_memory.cpp

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main() {
    // 生成一个用于创建/获取共享内存的键值
    key_t key = ftok(".", 's');

    // 创建或获取共享内存区域的标识符
    int shm_id = shmget(key, 1024, IPC_CREAT | 0666);

    if (shm_id == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }

    // 将共享内存连接到进程的地址空间
    void *shm_addr = shmat(shm_id, NULL, 0);

    if (shm_addr == (void *)-1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    // 写入数据到共享内存
    strcpy((char *)shm_addr, "Hello from the writer!");

    // 分离共享内存
    shmdt(shm_addr);

    printf("Data has been written to shared memory.\n");

    return 0;
}

read_shared_memory.cpp

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main() {
    // 生成一个用于创建/获取共享内存的键值
    key_t key = ftok(".", 's');

    // 获取共享内存区域的标识符
    int shm_id = shmget(key, 1024, 0666);

    if (shm_id == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }

    // 将共享内存连接到进程的地址空间
    void *shm_addr = shmat(shm_id, NULL, 0);

    if (shm_addr == (void *)-1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    // 从共享内存读取数据并输出
    printf("Data read from shared memory: %s\n", (char *)shm_addr);

    // 分离共享内存
    shmdt(shm_addr);

    return 0;
}

Airwave1
关注
  • 24
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
操作系统实验实验进程管理
06-19
接下来的三个参数与进程和它的主线程以及返回的指向该对象的句柄的安全性有关。 然后是标志参数，用以在dwCreationFlags参数中指明系统应该给予新进程什么行为。经常使用的标志是CREATE_SUSPNDED，告诉主线程立刻...
操作系统进程间通信实验
11-22
通过对进程间通信同步/互斥问题的编程实现，加深理解信号量和 P、V 操作的原理； 对 Windows 或 Linux 涉及的几种互斥、同步机制有更进一步的了解；熟悉 Windows 或 Linux 中定义的与互斥、同步有关的函数。
C语言中进程信号集的相关操作函数详解
01-01
C语言sigismember()函数：测试某个信号是否已加入至信号 头文件：#include 定义函数：int sigismember(const sigset_t *set, int signum); 函数说明：sigismember()用来测试参数signum 代表的信号是否已加入至参数...
进程管理 操作系统
01-19
操作系统进程的管理
Linux操作系统进程管理相关知识
09-04
Linux操作系统进程管理相关知识
【算法】NOIP2003神经网络
littlegengjie的博客
05-13 597
图中，X1—X3是信息输入渠道，Y1－Y2是信息输出渠道，C1表示神经元目前的状态，Ui是阈值，可视为神经元的一个内在参数。然后根据拓扑排序一次遍历该图的所有点（例如便利到点1，会遍历所有以点1位直接前驱的点），遍历点1之后，3、4、5的状态均为1，遍历点2之后3、4、5均为2，将所有输出点的状态减去阈值，就为最终状态。现在，给定一个神经网络，及当前输入层神经元的状态（Ci），要求你的程序运算出最后网络输出层的状态。再下面P行，每行由两个整数i，j及一个整数Wij，表示连接神经元i、j的边权值为Wij。
day09
2202_76101487的博客
05-17 460
正值少年的日常打卡！！！
【算法】二分算法——x的平方根
2302_79031646的博客
05-17 506
用二分边界算法来求解——x的平方根，从暴力求解到二分的优化细说
​​​【收录 Hello 算法】5.3 双向队列
让学习成为一种习惯
05-13 739
回顾上一节内容，我们使用普通单向链表来实现队列，因为它可以方便地删除头节点（对应出队操作）和在尾节点后添加新节点（对应入队操作）。如图 5-8 所示，我们将双向链表的头节点和尾节点视为双向队列的队首和队尾，同时实现在两端添加和删除节点的功能。请注意，“撤销”的核心逻辑仍然遵循栈的先入后出原则，只是双向队列能够更加灵活地实现一些额外逻辑。双向队列的常用操作如表 5-3 所示，具体的方法名称需要根据所使用的编程语言来确定。如图 5-9 所示，与基于数组实现队列类似，我们也可以使用环形数组来实现双向队列。
C动态内存管理
aqiangdeba的博客
05-17 190
malloccallocreallocfree原则：谁申请，谁释放，防止内存泄漏在C语言中，当你传递一个指针给一个函数时，你实际上是传递了指针的副本，而不是指针本身。这意味着，虽然你在函数内部可以通过这个指针修改指向的内存，但对于指针本身的修改（例如将它指向一个新的内存地址），这种修改不会影响到函数外部指针的值。
嵌入式学习第三十五天！（算法）
weixin_52799506的博客
05-14 245
解决特定问题求解步骤。
C语言笔记14
qq_64446190的博客
05-14 612
指针1
力扣阶段练习(1).消失的数字
2301_79475128的博客
05-11 840
恰好。这便是使用异或寻找缺失数的思路。
AtCoder Beginner Contest 353
2301_78527293的博客
05-11 1000
abc
LeetCode 669. 修剪二叉搜索树
最新发布
2301_80211119的博客
05-17 703
给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。 可以证明，存在 唯一的答案 。 所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。
技艺高超的魔法师：Java运算符
epitomizelu的专栏
05-14 779
Java运算符是构建复杂程序的基础，掌握它们的使用和优先级对于写出高效、清晰的代码至关重要。通过本文的介绍和实例，希望能帮助读者更好地理解和运用这些运算符，让代码表达更加精准和高效。记住，实践是学习的最好方式，不断编写代码并探索不同的场景，你会越来越熟练地掌握它们。
基于MSWA相继加权平均的交通流量分配算法matlab仿真
熟悉python,matlab,C,C++,JAVA等
05-15 365
基于MSWA（Modified Successive Weighted Averaging）相继加权平均的交通流量分配算法，是交通工程领域中用于预测和分析城市路网中交通流量分布的一种方法。在交通流量分配问题中，核心目标是确定在给定的路网结构、出行需求和用户行为准则下，如何合理分配交通需求到路网中的各个路径上，以达到用户均衡状态。每一轮迭代中，算法依据当前的流量分配情况，动态调整各路径的权重，以反映其相对拥挤程度，然后基于调整后的权重重新分配交通流量。经枚举可得每个OD对间存在3条无折返有效路径，共27条。
day24 235. 二叉搜索树的最近公共祖先 701.二叉搜索树中的插入操作 450.删除二叉搜索树中的节点
m0_68259754的博客
05-17 204
利用回溯从底向上搜索，遇到一个节点的左子树里有p，右子树里有q，那么当前节点就是最近公共祖先。因为是有序树，所以 如果 中间节点是 q 和 p 的公共祖先，那么 中节点的数组 一定是在 [p, q]区间的。即 中节点 > p && 中节点 < q 或者 中节点 > q && 中节点 < p。递归遍历顺序，本题就不涉及到 前中后序了（这里没有中节点的处理逻辑，遍历顺序无所谓了）。
leetcode算法常用函数
qq_42936379的博客
05-14 155
核心关注算法逻辑，其他的常见操作用标准库里函数即可，不用浪费时间。Java语言作为参考，记录刷题时常用的函数。
c语言进程操作相关函数
08-09
c语言提供了一些用于进程操作的相关函数。下面简要介绍几个常用的函数。 1. fork()函数：该函数用于创建新的进程。调用该函数会复制当前进程，使得原进程和新进程同时运行。原进程称为父进程，新进程称为子进程。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值