Салимóненко Дмитрий Александрович

Задание 5: Многопроцессность в Linux с помощью функции fork()

(C++, Linux)

Программный код, иллюстрирующий многопроцессность

Давайте сразу посмотрим исходный код (назовем его fork.c):

1. #include <stdio.h>
2. #include <errno.h>
3. #include <sys/types.h>
4. #include <unistd.h>
5. #include <string.h>
6. #include <stdlib.h>
7. #include <time.h>
8. #include <sys/time.h>
9. #include <sys/wait.h>

10. int main(int argc, char **argv)
11. {
12. pid_t pid, old_ppid, new_ppid;
13. pid_t child, parent, parent_init;
14. time_t timer;
15. char* time_str;
16. int err_val = 555;
17. int sl, status;

18. parent = getpid(); /* определяем pid самой программы-родителя перед вызовом fork() */
19. parent_init = getppid(); // Определяем pid родительского процесса для данной программы-родителя

20. FILE* fd = fopen("file.txt", "w" );  // Это файл с "логами" программы
21. timer = time(NULL);  // Запускаем таймер
22. time_str = ctime(&timer);
23. fprintf(fd, "До вызова fork(): %s\n", time_str);
24. fflush(fd);

25. if ((child = fork()) < 0) { // Если ошибка при выполнении функции fork()
26. fprintf(stderr, " fork of child failed: %s\n", strerror(errno));
27. exit(1);

28. } else if (child == 0) { // Начинает выполняться процесс-ПОТОМОК
29. printf("Child process begining... \n");
30. sleep(3); // Пока потомок ожидает 2 секунды, может выполняться процесс-родитель

31. timer = time(NULL);
32. time_str = ctime(&timer);
33. fprintf(fd, "Потомок (Child): %s \n", time_str);
34. fflush(fd);

35. /* это выполняет только порожденный процесс-потомок */
36. printf("pid родительского процесса для программы-родителя: %d\n", parent_init);
37. printf("pid родительского процесса: %d\n", parent);
38. printf("pid для потомка: %d\n", getpid());
39. err_val = 777;  
40. //err_val = 1/0; // Здесь программа не выводит ошибку, потомок просто прекращает работу

41. printf("err_val value-CHILD:  %d  %p\n", err_val, &err_val);  // Будет ли выполняться эта команда? Почему?
42. timer = time(NULL);  
43. time_str = (char*)ctime(&timer);
44. fprintf(fd, "Потомок после 1/0 (Child): %s\n", time_str);
45. fflush(fd); // Принудительно делаем запись в файл, очищаем буфер, в котором хранится переменная time_str

46. //exit(0);
47. // Конец исходного кода процесса-потомка  
48. } else { // Если child>0, то начинает выполняться процесс-РОДИТЕЛЬ

49. printf("Parent process begining... \n");
50. sl = atoi(argv[1]); // Задаем время задержки родительского процесса из 2-го аргумента командной строки
51. printf("sleep: %d (для родительского процесса)\n", sl);  
52. sleep(sl);

53. timer = time(NULL);  
54. time_str = ctime(&timer);
55. fprintf(fd, "Родитель (Parent): %s \n", time_str);
56. fflush(fd);
57. //err_val = 1/0; // Раскомментируйте эту строчку, проанализируйте результат; получается, что родительский процесс реагирует иначе, чем потомок
58. printf("err_val value-PARENT: %d  %p\n", err_val, &err_val); // Какое значение err_val выведет эта команда, почему?
59. // Сравните значение и, главное, адрес переменной err_val, выводимый потомком и родителем. Почему наблюдается совпадение адресов? Ведь значения-то этой переменной в потомке отличается от ее значения в родителе... а виртуальные адреса, что, совпадают?...
60. // printf("Родительский процесс ждет завершения потомка... Время: %s сек. \n", time_str);  
61. // wait(&status);
62. timer = time(NULL);  
63. time_str = ctime(&timer);
64. printf("Родительский процесс отработал. Время: %s сек. \n", time_str);    
65. //exit(0); /* родитель завершается после fork() */
66. }

67. printf("err_val value (родитель или потомок?): %d  %p\n", err_val, &err_val); // Какое значение err_val выведет эта команда, почему?  
68. //exit(0);
69. }

Здесь потребуется детально разобраться с особенностями работы процессов: родителя и потомка, запускаемых из одного и того же программного кода. Потребуется запускать программу с различными параметрами.

Кстати, чтобы ускорить тестирование программы, целесообразно запускать ее компиляцию и, собственно, выполнение в одну строчку примерно таким образом:

g++ -o fork fork.c && ./fork 1

Здесь параметр «1» означает, как обычно, argv[1]. В данном случае, это – время задержки родительского процесса (в секундах).

Теоретические аспекты

Процесс-потомок наследует следующие признаки родителя:

• сегменты кода, данных и стека программы;
• таблицу файлов, в которой находятся состояния флагов дескрипторов файла, указывающие, читается ли файл или пишется. Кроме того, в таблице файлов содержится текущая позиция указателя записи-чтения;
• рабочий и корневой каталоги;
• реальный и эффективный номер пользователя и номер группы;
• приоритеты процесса (администратор может изменить их через nice);
• контрольный терминал;
• маску сигналов;
• ограничения по ресурсам;
• сведения о среде выполнения;
• разделяемые сегменты памяти.

Потомок не наследует от родителя следующих признаков:

• идентификатора процесса (PID, PPID);
• израсходованного времени ЦП (оно обнуляется);
• сигналов процесса-родителя, требующих ответа;
• блокированных файлов (record locking).

Поэтому, в частности, нет необходимости объявлять переменную, используемую и потомком, и родителем, дважды. Потомок, при успешном создании, получит ее копию. При этом он сможет изменять ее по своему усмотрению, у родителя же останется принадлежащая ему копия этой переменной, он также может изменять ее независимо от потомка (см. строчки 16, 39).

Весь код после fork() выполняется ДВАЖДЫ, как в процессе-потомке, так и в процессе-родителе.

Зомби — это процесс, который завершился, но не был удален. Удаление зомби возлагается на родительский процесс.

Как тестировать программу

Следует проанализировать ее работу при следующих наборах (вариантах) условий:

1. Разные времена задержки родительского процесса: 1 и 3. В первом случае родительский процесс завершается быстрее, чем потомок; во втором случае – наоборот (итого – 2 варианта).

Примечание: время задержки процесса-потомка всегда фиксировано и равно 2 секунды (см. строчку 30).

2. По очереди раскомментировать заведомо ошибочные строчки 40 и 57 (итого - 4 варианта).
3. По очереди раскомментировать строчки 46, 65, осуществляющие завершение процессов потомка и родительского, соответственно (итого – 4 варианта).

Всего получается, по максимуму, 2*4*4 = 32 варианта. По мере тестирования окажется, что (большую) часть вариантов можно будет пропустить в силу очевидности. В таблице их проводить также не следует.

Конечно, можно также поэкспериментировать и с другими аспектами, но эти, на мой взгляд, являются основными.

Результаты тестирования целесообразно оформить, например, в виде таблицы следующего вида:

№ варианта	Быстрее завершается:	Попытка выполнения заведомо неверной команды err_val = 1/0;	Завершение через exit(0);	Комментарий (выявленные Вами особенности)
1	Потомок	-	-
2	Родитель	-	-
3	Потомок	Потомок	-
4	Потомок	Потомок	Потомок
5	Потомок	Потомок	Родитель
6	Потомок	Потомок	Потомок и Родитель
…

Обсудим наиболее важные особенности работы родителя и потомка

1. Время задержки

В последнем случае мы можем видеть, что, несмотря на завершение родителя и появление, как обычно, командной строки, вдруг (через секунду), как из небытия, возникает процесс потомок и продолжает свою работу…

Как видим, программу можно условно разделить на 3 части:

1. Родитель (строчки 1…27, 46…66),
2. Потомок (строчки 28…47),
3. Оставшаяся часть (строчки 67…69).

Кто же (потомок или родитель) будет выполнять строчки 67…69?

Оказывается, и потомок, и родитель. Но, порядок выполнения будет разным, в зависимости от того, кто будет первым или последним. Это можно увидеть по выводу значения переменной err_val: для родителя выведется значение 555, тогда как для потомка – 777. Вот типичный пример:

Раньше завершился (строчки 46, 65 – закомментированы):
Родитель	Потомок
VirtualBox:~/Рабочий стол/programs_fork$ g++ -o fork fork.c && ./fork 1 Parent process begining... sleep: 1 (для родительского процесса) Child process begining... Error value-PARENT: 555 Родительский процесс работал 1 сек. и сейчас будет завершен. Error value (родитель или потомок?): 555 VirtualBox:~/Рабочий стол/programs_fork$ pid родительского процесса для программы-родителя: 9577 pid родительского процесса: 20598 pid для потомка: 20599 Error value-CHILD: 777 Error value (родитель или потомок?): 777 ^C	VirtualBox:~/Рабочий стол/programs_fork$ g++ -o fork fork.c && ./fork 3 Parent process begining... sleep: 3 (для родительского процесса) Child process begining... pid родительского процесса для программы-родителя: 9577 pid родительского процесса: 20803 pid для потомка: 20804 Error value-CHILD: 777 Error value (родитель или потомок?): 777 Error value-PARENT: 555 Родительский процесс работал 3 сек. и сейчас будет завершен. Error value (родитель или потомок?): 555 VirtualBox:~/Рабочий стол/programs_fork$
Пришлось прервать потомка-зомби при помощи сигнала Ctrl + C	Программа полностью завершилась сама, поэтому появилась командная строка

Как видим, значение Error value является разным в обоих случаях. Причем, оставшийся код программы (строчки 67…69) выполняется ДВАЖДЫ: и потомком, и родителем. Причина тому – отсутствие самостоятельного завершения и того, и другого в силу отсутствия команды типа exit(). А вот порядок выполнения зависит, естественно, от того, кто успеет первым.

2. Самостоятельное завершение

Для того, чтобы и родитель, и потомок самостоятельно завершались, необходимо раскомментировать строчки 46, 65. Вот что получится:

Раньше завершился (строчки 46, 65 – раскомментированы):
Родитель	Потомок
VirtualBox:~/Рабочий стол/programs_fork$ g++ -o fork fork.c && ./fork 1 Parent process begining... sleep: 1 (для родительского процесса) Child process begining... Error value-PARENT: 555 Родительский процесс работал 1 сек. и сейчас будет завершен. VirtualBox:~/Рабочий стол/programs_fork$ pid родительского процесса для программы-родителя: 9577 pid родительского процесса: 21388 pid для потомка: 21389 Error value-CHILD: 777 ^C	VirtualBox:~/Рабочий стол/programs_fork$ g++ -o fork fork.c && ./fork 3 Parent process begining... sleep: 3 (для родительского процесса) Child process begining... pid родительского процесса для программы-родителя: 9577 pid родительского процесса: 21396 pid для потомка: 21397 Error value-CHILD: 777 Error value-PARENT: 555 Родительский процесс работал 3 сек. и сейчас будет завершен. VirtualBox:~/Рабочий стол/programs_fork$
Пришлось прервать потомка-зомби при помощи сигнала Ctrl + C	Программа полностью завершилась сама, поэтому появилась командная строка

Как видим, теперь строчки 66…69 не выполняются. Остальное, по сути, осталось без изменений.

3. Идентификаторы процессов

Это – так называемый pid. В программе используются три вида идентификаторов (см. предыдущую таблицу, правый столбец):

1. Исходного (системного) процесса операционной системы, который является родительским для нашей программы (pid=9557),
2. Непосредственно родительский процесс (pid=21396),
3. Процесс-потомок (pid=21397).

Можно сделать выводы:

1. pid исходного системного процесса, который является прародителем всех остальных процессов, не меняется и в моей операционной системе составляет 9577.
2. pid_{потомка} = pid_{родителя} + 1. Однако, это не касается исходного (прародительского) процесса и родительского, так как 9557+1 ≠ 21396.

Таким образом, каждый потомок получает pid на 1 больший. Вы можете поэкспериментировать, создав еще одного потомка. Это следует делать, дополнив код еще одной конструкцией вида

4. Как не допустить появление процесса-зомби в случае, если потомок завершится раньше, чем родитель?

Для этого используется системный вызов wait(). Он заставит ждать родителя до тех пор, пока не завершится первый из всех возможных потомков. Используется этот вызов примерно так:

Системный вызов wait() следует вставить там, где должен остановиться процесс-родитель в ожидании, пока потомок не закончит свою работу. Т.е. следует раскомментировать строчки 60, 61. Вот что получилось в результате:

Как видим, несмотря на то, что родительский процесс мог бы закончить свою работу в 01:12:59, тем не менее, он ждал, пока завершится процесс-потомок. Определим время, которое должен был ожидать родитель и сравним его с фактическим.

Вначале, после запуска программы, родитель работал 1 сек. В тоже самое время потомок работал в течение 2 сек. Поэтому родителю, после того, как он дошел до команды wait(), осталось ждать 2-1=1 сек. И, действительно, родительский процесс отработал в 01:13:00. Вы можете установить другое время, например, не 2 сек., а 5 сек., тогда разница будет видна яснее.

5. Обработка ошибок родителем и потомком

Для демонстрации обработки критических ошибок в программу введены строчки 40, 57, пока закомментированные. Следует их раскомментировать и изучить, что изменится в работе программы. При этом наличие критических ошибок в родителе приводит к аварийному останову программы и дампу памяти, тогда как критическая ошибка в потомке вызывает лишь его останов.

И, наконец, о виртуальных адресах

Как Вы заметили, виртуальные адреса переменной err_val и в потомке, и в родителе... совпадают. Создается (ложное) впечатление, что у них виртуальные адресные пространства - общие. И здесь надо бы сделать пояснения. См. также задание 3, где показан пример получения виртуальных адресов для функций, переменных, используемых процессом.

При создании родителем процесса-потомка при помощи функции fork(), для последнего операционная система создает копию адресного пространства его родителя. Копия создается, естественно, именно для того адресного пространства, которое присутствовало у родителя на момент создания потомка (т.е. на момент выполнения функции fork()). Именно по этой причине виртуальный адрес переменной err_val является одним и тем же как у родителя, так и у потомка. Вместе с тем, НЕЛЬЗЯ говорить, что оба этих адресных пространства являются общими. Общими они будут, к примеру, для разных потоков одного и того же процесса. Тогда как для разных процессов они будут независимыми, различными, хотя и полностью совпадающими на момент создания потомка. В "штатном режиме" выполнения программы доступ, к примеру, родителя к адресному пространству потомка (или, наоборот) невозможен. Если такой доступ все же необходим, следует применять специальные средства, например, запуск программы при помощи функции exec().