标签: fork

举例说明： f.php ：

d$=$_Get['ad'];
 print d$;

索引.php :

 for $i=0 to 200000
     // run f.php?ad=i$

运行 f.php 但不要等待完成 f.php 怎么办？

1. 我找到了php asyncronus但我现在不知道这是真的有效还是现有的其他解决方案，或者这是最好的解决方案？！

2. 何时使用 exec 以及如何使用？

以下代码:

B() { 
   pid_t pid; 
   if ((pid=fork())!= 0) 
       waitpid(pid,NULL,0); 
   printf("2 "); 
   if (fork() == 0) 
      { printf("3 "); exit(0); } 
   printf("5 "); 
   exit(0); 
}

可能有一个输出:我不知道哪一个是正确的输出.

232553
235325
232355
235253
252533

这两行意味着如果pid是父母,那么等待什么？

if ((pid=fork())!= 0) 
           waitpid(pid,NULL,0); 

那么如果是子进程(fork = 0),那么打印3 ..正确吗？

 if (fork() == 0) 
              { printf("3 "); exit(0); }

试图澄清我对fork()和pipe()的理解.我知道pipe()是一种在两个进程之间传输数据的单向方法.如果在父进程中,我在两个整数数组上调用pipe(),然后我将它分叉,这是否有效地创建了两个允许我双向传输数据的管道？(即让父母从标准中读取并且孩子写入标准输出,或者类似地让父母写入标准输出并且孩子从标准中读取？)

如果我使用 execl 是可能需要时间完成的子进程，我什么时候需要使用 waitpid？

当我在父级中使用 waitpid 时，它让我的孩子运行，因为 waitpid 的返回值为 0。一段时间后，我试图在另一个函数中使用 waitpid，它用 ECHILD 返回 -1。如果我不确定天气孩子是否完成，我应该什么时候使用 waitpid？

//pid_t Checksum_pid = fork();
Checksum_pid = fork();

if (Checksum_pid == 0)
{
    execl(path, name, argument as needed, ,NULL);
    exit(EXIT_SUCCESS);     
}
else if (Checksum_pid > 0)
{ 
    pid_t returnValue = waitpid(Checksum_pid, &childStatus, WNOHANG);

    if ( returnValue > 0)
    {
        if (WIFEXITED(childStatus))
        {
            printf("Exit Code: _ WEXITSTATUS(childStatus)") ;               
        }
    }
    else if ( returnValue == 0)
    {
        //Send positive response with routine status running (0x03)
        printf("Child process …

这是输出---

父：我的 pid 是 4525 父：我父母的 pid 是 3350 parant started- 4525 3350 Before Fork Before Fork Child 4526 4525 In parent ---Parent End---

当我尝试执行以下代码时---

void main(int argc, char *argv[])
{
    int status;
    pid_t my_pid, parent_pid,child_pid;

    my_pid = getpid();
    parent_pid = getppid();
    printf("\nParent: my pid is %d", my_pid);
    printf("\nParent: my parent's pid is %d", parent_pid);
    printf("\nparant started- %d    %d",my_pid,parent_pid);
    printf("\nBefore Fork");

    if((child_pid = fork()) < 0 )
    {
        perror("fork failure");
        exit(1);
    }

    if(child_pid == 0)
    {
        printf("\n Child %d %d\n",getpid(),getppid()); …

我正在实现一个服务于多个客户端的服务器,我需要一些服务器的变量在共享内存中,以便客户端实际看到另一个客户端最终编辑的内容.

我试着环顾四周,但我不明白是否有任何方法可以通过使用fork()实现这一点,或者我完全需要改变我处理客户端的方式.特别是我不知道我是否应该实现管道进程或线程.另外,更简单的方法是什么？

这是我在main中声明int var之后的代码:

while(1) {
        printf("Waiting connection...\n");
        if ((connfd = accept(listenfd, (struct sockaddr *) NULL, NULL)) < 0) {
            perror("Accept Error");
            exit(1);
        }

        if ((pid = fork()) == 0) {
            close (listenfd);
            printf("Variable: %d\n", var); // var = 0
            var = 1;
            printf("Variable: %d\n", var); // var = 1
            exit(0);
        }

        close(connfd);
    }

当我与另一个客户端连接时,我再次看到var = 0,因为子进程生成了父进程的副本.

尝试在main()之外使用静态或声明全局变量,但据我所知,它没有任何效果.

我正在尝试使用 linux 的系统（cmd）执行命令（从远程服务器获取密钥）。我的问题是当远程服务器无法访问时，对于少数 IP，它只是等待而不返回，这反过来使“system()”永远挂起。我想处理这种情况。我在想一种方法让我的 system() 等待一段时间，如果命令没有返回，那么 system() 命令必须出来报告不成功的状态。

我的命令看起来像这样：

int status = system("<<<URL of the remote server>>>");
//the above command must wait for a fixed duration before coming out if no response.

我正在尝试通过管道进行2个进程通信.我等待孩子在管道中写一个字符,然后父母将从管道中读取字符并将其显示在屏幕上.问题是我成功地在管道中写入了字符(我做了一个测试,立即从中读取,我看到它在管道中),但是当父管从管道中读取时,它内部没有任何内容.我真的不明白为什么; 一切似乎都很好.

int PID, canal[2];
if(-1 == (PID = fork()))
{
    perror("Error");
    return 0;
}
if(-1 == pipe(canal))
{
    perror("Error");
    return 0;
}
if(PID == 0)
{
    close(canal[0]);
    printf("Child\n");
    char buffer = 'C';
    if( 0 == write(canal[1], &buffer, sizeof(char)))
        printf("Didn't write anything\n");
    close(canal[1]);
}
else
{
    char readBuffer;
    wait(NULL);
    printf("Parent\n");
    close(canal[1]);
    if(read(canal[0], &readBuffer, sizeof(char)))
    {
        printf("I read: ");
        printf("%c\n", readBuffer);
    }
    close(canal[0]);
}

我正在编写一个小C代码,它存在一个变量作为int指针.进程应该做的是减去该变量的值,直到它达到0.问题是每个进程看起来都有自己的变量副本,即使程序打印的地址是相同的.这是否因为每个进程在内存中都有自己的空间？

这是输出:

START
Account address: 0x7ffee5820be0
Parent substracted 10. Account value: 90, address 0x7ffee5820be0
Parent substracted 10. Account value: 80, address 0x7ffee5820be0
Parent substracted 10. Account value: 70, address 0x7ffee5820be0
Parent substracted 10. Account value: 60, address 0x7ffee5820be0
Parent substracted 10. Account value: 50, address 0x7ffee5820be0
Parent substracted 10. Account value: 40, address 0x7ffee5820be0
Parent substracted 10. Account value: 30, address 0x7ffee5820be0
Parent substracted 10. Account value: 20, address 0x7ffee5820be0
Parent substracted 10. Account value: 10, address 0x7ffee5820be0
Parent substracted …

我一直在尝试做的是建立一个分叉两个孩子的程序。父进程从 stdin 读取，然后通过管道将其重定向到其子进程。然后孩子复制管道的读取端，以便它可以从标准输入（而不是管道）读取，然后将其打印到标准输出。这是代码：

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>

int main(int argc, char **argv) {
    char buf[100];
    int pipe_one[2];
//    int pipe_two[2];

    pipe(pipe_one);
//    pipe(pipe_two);

    // First child
    switch(fork()) {
        case -1:
            exit(EXIT_FAILURE);
        case 0:
            close(pipe_one[1]);
            dup2(pipe_one[0], STDIN_FILENO);
            close(pipe_one[0]);
            while (fgets(buf, 100, stdin)) {
                fputs(buf, stdout);
            }
            fflush(stdout);
            exit(EXIT_SUCCESS);
        default:
            break;
    }

    // Second child
/*    switch(fork()) {
        case -1:
            exit(EXIT_FAILURE);
        case 0:
            close(pipe_two[1]);
            dup2(pipe_two[0], STDIN_FILENO);
            close(pipe_two[0]);
            while (fgets(buf, 100, stdin)) {
                fputs(buf, stdout);
            }
            fflush(stdout); …