我试图获得一个程序来创建n个子进程来读取文件,并且父进程不断循环遍历它们,并尝试发送信号以继续读取文件(如果该进程是免费的)。否则,如果该进程被占用,它将移至下一个进程。这是我使用信号的方法,但是输出是意外的。如果我使用printf在父级的while循环中调试代码,我只会得到printf语句本身。为什么会这样呢?
据我了解,预期的输出应该是所有n个子进程几乎一次读取文件(文件很小),然后间隔1秒,然后再次发生。这是正确的,还是由于比赛条件而不确定?
我知道使用管道可能会有更好的方法,但是使用信号可以实现吗?提前致谢。
我知道手册页中提到的signal()的使用不如sigaction()那样,但是仍然可以解决吗?
由printf引起的意外输出是否可能是由于printf本身对IPC的干扰?
编辑:Pastebin链接进行测试:https://pastebin.com/ZWFnkJDA
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<fcntl.h>
#include<sys/wait.h>
int counter = 0;
int fd;
const char* filename;
int j = 0;
int no_of_children;
int* cpid;
//User define signal handler
static void sig_usr1(int);
static void sig_usr2(int signo, siginfo_t* info, void* context);
static void sig_usr1(int signo)
{
//Now the child process waits for reading the Filename
//Block SIGUSR1 until it's complete
signal(SIGUSR1, SIG_IGN);
printf("Blocked now.\n");
printf("Child no %d is reading now.\n\n",getpid());
fd = open(filename, O_RDONLY | O_CREAT);
char buf = 'a';
int k=0;
char* op = (char*) malloc (255*sizeof(char));
while(read (fd, &buf, 1))
{
if (buf == '\n')
{
op[k] = '\0';
break;
}
else
{
op[k++] = buf;
}
}
//Now wait for a second and then send a signal
sleep(1);
//Print the contents of the buffer via op
printf("Output: %s\n\n", op);
//Now unblock the signal
kill(getppid(), SIGUSR2);
signal(SIGUSR1, sig_usr1);
printf("Unblocked now\n");
}
static void sig_usr2(int signo, siginfo_t* info, void* context)
{
if (signo == SIGUSR2)
{
child_pid = info->si_pid;
printf("Parent Received SIGUSR2. Child Process with PID %d is now free\n\n", child_pid);
}
}
int main(int argc, char* argv[])
{
//Filename is the first argument
filename = argv[1];
//Number of Child Processes to be spawned
no_of_children = atoi(argv[2]);
cpid = (int*) malloc (no_of_children*sizeof(int));
//Create a sigaction() handler for SIGUSR2
struct sigaction sa;
sa.sa_flags = SA_SIGINFO;
sa.sa_sigaction = sig_usr2;
sigaction(SIGUSR2, &sa, NULL);
//Create no_of_children children
for(int i=0; i<no_of_children; i++)
{
cpid[i] = fork();
if (cpid[i] == 0)
{
//Inside a child
printf("Created %dth child process", i);
printf(" with Process ID = %d\n", getpid());
signal(SIGUSR1, sig_usr1);
while(1)
{
pause();
}
//Every child process must exit so control goes back to the parent
exit(0);
}
}
//Returns to the parent process
while(1)
{
int fpid = cpid[j];
//Send the signal to the free child process
//printf("Sending to PID %d\n", fpid); //----> Uncommenting this line only prints this statement. Why does this happen?
kill(fpid, SIGUSR1);
j = (j < no_of_children - 1) ? j + 1 : 0; //----->Does not work as expected if i uncomment this line. I want to switch between PIDs and send signals to all of them
}
return 0;
}
样本输出:
$ ./a.out sample.txt 4
Created 0th child process with Process ID = 15734
Created 1th child process with Process ID = 15735
PID: 15737 -> PID: 15736 -> PID: 15735 -> PID: 15734
Created 2th child process with Process ID = 15736
Blocked now.
Child no 15734 is reading now.
Created 3th child process with Process ID = 15737
Output: This is a sample file
Unblocked now
Parent Received SIGUSR2. Child Process with PID 15734 is now free
Blocked now.
Child no 15734 is reading now.
Blocked now.
Child no 15735 is reading now.
Output: This is a sample file
Unblocked now
Output: This is a sample file
Parent Received SIGUSR2. Child Process with PID 15735 is now free
Blocked now.
Child no 15734 is reading now.
Unblocked now
Parent Received SIGUSR2. Child Process with PID 15736 is now free
Blocked now.
Child no 15735 is reading now.
Blocked now.
Blocked now.
Child no 15736 is reading now.
Child no 15737 is reading now.
^\%
最佳答案
注意:这并不是要作为答案,而只是一些可能导致解决方案的经过编辑的代码和结论。
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<fcntl.h>
#include<sys/wait.h>
int counter = 0;
int fd;
const char* filename;
int j = 0;
int no_of_children;
int* cpid;
int my_pid;
//User define signal handler
static void sig_usr1(int);
static void sig_usr2(int);
static void sig_usr1(int signo)
{
//Now the child process waits for reading the Filename
//Block SIGUSR1 until it's complete
signal(SIGUSR1, SIG_IGN);
printf("%d\tBlocked now.\n", my_pid);
printf("%d\tChild no %d is reading now.\n",my_pid, getpid());
fd = open(filename, O_RDONLY | O_CREAT);
char buf = 'a';
int k=0;
char* op = (char*) malloc (255*sizeof(char));
while(read (fd, &buf, 1))
{
if (buf == '\n')
{
op[k] = '\0';
break;
}
else
{
op[k++] = buf;
}
}
//Now wait for a second and then send a signal
sleep(1);
//Print the contents of the buffer via op
printf("%d\tOutput: %s\n", my_pid, op);
//Now unblock the signal
kill(getppid(), SIGUSR2);
signal(SIGUSR1, sig_usr1);
printf("%d\tUnblocked now\n", my_pid);
}
static void sig_usr2(int signo)
{
if (signo == SIGUSR2)
{
printf("%d\tParent Received SIGUSR2. Child Process with PID %d is now free\n", my_pid, cpid[j]);
kill (cpid[j++], SIGUSR1);
if (j == no_of_children)
{
j = 0;
}
}
}
int main(int argc, char* argv[])
{
my_pid = getpid();
//Filename is the first argument
filename = argv[1];
//Number of Child Processes to be spawned
no_of_children = atoi(argv[2]);
cpid = (int*) malloc (no_of_children*sizeof(int));
signal(SIGUSR2, sig_usr2);
//Create no_of_children children
for(int i=0; i<no_of_children; i++)
{
cpid[i] = fork();
if (cpid[i] == 0)
{
//Inside a child
my_pid = getpid();
printf("%d\tCreated %dth child process", my_pid, i);
printf(" with Process ID = %d\n", getpid());
signal(SIGUSR1, sig_usr1);
while(1)
{
pause();
}
//Every child process must exit so control goes back to the parent
exit(0);
}
printf("%d\tforked %dth child -> %d\n", my_pid, i, cpid[i]);
}
//Returns to the parent process
while(1)
{
int fpid = cpid[j];
//Send the signal to the free child process
printf("%d\tSending to PID %d\n", my_pid, fpid);
kill(fpid, SIGUSR1);
//j = (j < no_of_children - 1) ? j + 1 : 0;
pause();
}
return 0;
}
好,我该怎么办?
在每个
printf()
的开头添加当前进程的PID。为此,添加了变量my_pid
并将其设置在方便的位置。是的,我知道一些输出已经提供了此信息。我不想过多更改OP的来源。在课程中删除了双
\n
。他们没有帮助。要查看
fork()
成功,请打印其结果。最后,在主进程的无限循环中添加
printf
。我想看看哪个进程以哪个速率发出了多少次信号。哇,好多!嗯,可能是主进程向孩子灌入了太多信号,以至于它甚至无法调用
signal()
来临时阻止它吗?最后,在主进程的无限循环中添加
pause()
。现在事情开始起作用,但很可能不是OP想要的方式。无论如何,所有子进程都将被创建并接收其信号,读取文件,发回其信号等等。
系统中似乎有太多信号。这样的算法必须考虑。所以这是我的建议:
慢一点您稍后可以加快速度。
在代码中放置尽可能多的监视点(此处:
printf()
)以跟踪所有事件。特别是对于多处理,请考虑一种可视化结果的方法。我在编辑器中复制了shell输出,并缩进了如下代码:
$ ./signal_repetition signal_repetition.c 4
1901 forked 0th child -> 1902
1902 Created 0th child process with Process ID = 1902
1901 forked 1th child -> 1903
1903 Created 1th child process with Process ID = 1903
1901 forked 2th child -> 1904
1904 Created 2th child process with Process ID = 1904
1901 forked 3th child -> 1905
1901 Sending to PID 1902
1902 Blocked now.
1902 Child no 1902 is reading now.
1905 Created 3th child process with Process ID = 1905
1902 Output: #include<stdio.h>
1902 Unblocked now
1901 Parent Received SIGUSR2. Child Process with PID 1902 is now free
1901 Sending to PID 1903
1902 Blocked now.
1902 Child no 1902 is reading now.
1903 Blocked now.
1903 Child no 1903 is reading now.
1902 Output: #include<stdio.h>
1902 Unblocked now
1901 Parent Received SIGUSR2. Child Process with PID 1903 is now free
1901 Sending to PID 1904
1904 Blocked now.
1903 Output: #include<stdio.h>
1904 Child no 1904 is reading now.
1903 Unblocked now
1903 Blocked now.
1903 Child no 1903 is reading now.
1901 Parent Received SIGUSR2. Child Process with PID 1904 is now free
1901 Sending to PID 1905
1905 Blocked now.
1905 Child no 1905 is reading now.
1903 Output: #include<stdio.h>
1904 Output: #include<stdio.h>
1903 Unblocked now
1904 Unblocked now
1904 Blocked now.
1904 Child no 1904 is reading now.
1901 Parent Received SIGUSR2. Child Process with PID 1905 is now free
您可以在其自己的日志文件中为每个进程创建一个日志。添加至少具有毫秒分辨率的时间戳,以便以后同步所有日志。这样,可以避免
stdout
上的输出混淆的问题。还有很多其他事情可以解决。玩得很开心!还有祝你好运!