Уильям Стивенс - UNIX: взаимодействие процессов

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

solaris % client5 /tmp/server5 55

result: 3025

solaris % client5 /tmp/server5 66

result: 4356

solaris % client5 /tmp/server5 77

result: 5929

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

solaris % server5 /tmp/server5

thread id 4, arg = 55

thread id 4, arg = 66

thread id 4, arg = 77

Теперь запустим три экземпляра программы-клиента одновременно:

solaris % client5 /tmp/server5 11 & client5 /tmp/server5 22 & client5 /tmp/server5 33 &

[2] 3812

[3] 3813

[4] 3814

solaris % result: 484

result: 121

result: 1089

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

thread id 4, arg = 22

thread id 5, arg = 11

thread id 6, arg = 33

Затем мы запустим еще два клиента одновременно (первые три уже завершили работу):

solaris % client5 /tmp/server5 11 & client5 /tmp/server5 22 &

[2] 3830

[3] 3831

solaris % result: 484

result: 121

При этом сервер использует созданные ранее потоки:

thread id 6, arg = 22

thread id 5, arg = 11

Этот пример показывает, что серверный процесс (то есть библиотека дверей, подключенная к нему) автоматически создает потоки серверных процедур по мере необходимости. Если приложению требуется контроль над созданием потоков, оно может его осуществить с помощью функций, описанных в разделе 15.9.

Мы также убедились, что сервер в этом случае является параллельным (concurrent): одновременно может выполняться несколько экземпляров процедуры сервера в виде отдельных потоков для обслуживания клиентов. Это следует также из того, что результат работы сервера выводится тремя экземплярами клиента одновременно пять секунд спустя после их одновременного запуска. Если бы сервер был последовательным, первый результат появился бы через 5 секунд после запуска, следующий — через 10, а последний — через 15.

Автоматическое управление потоками сервера: несколько процедур

В предыдущем примере процесс-сервер содержал лишь одну процедуру сервера. Вопрос, которым мы займемся теперь, звучит так: могут ли несколько процедур одного процесса использовать один и тот же пул потоков сервера? Чтобы узнать ответ, добавим к нашему серверу еще одну процедуру, а заодно перепишем наши программы заново, чтобы продемонстрировать более приличный стиль передачи аргументов и результатов между процессами.

Первый файл в этом примере называется squareproc.h. В нем определен один тип данных для входных аргументов функции, возводящей в квадрат, и еще один — для возвращаемых ею результатов. В этом заголовочном файле также определяется полное имя двери для данной процедуры. Его текст его приведен в листинге 15.8.

//doors/squareproc.h

1 #define PATH_SQUARE_DOOR "/tmp/squareproc_door"

2 typedef struct { /* аргументы squareproc() */

3  long arg1;

4 } squareproc_in_t;

5 typedef struct { /* возврат squareproc() */

6  long res1;

7 } squareproc_out_t;

Наша новая процедура будет принимать длинное целое и возвращать квадратный корень из него (типа double). Мы определяем полное имя двери этой процедуры, структуры аргументов и результатов в заголовочном файле sqrtproc.h в листинге 15.9.

//doors/sqrtproc.h

1 #define PATH_SQRT_DOOR "/tmp/sqrtproc_door"

2 typedef struct { /* входные данные sqrtproc() */

3  long arg1;

4 } sqrtproc_in_t;

5 typedef struct { /* возвращаемые sqrtproc() данные */

6  double res1;

7 } sqrtproc_out_t;

Программа-клиент приведена в листинге 15.10. Она последовательно вызывает две процедуры сервера и выводит возвращаемые ими результаты. Эта программа устроена аналогично другим клиентским программам, приведенным в этой главе.

//doors/client7.c

1  #include "unpipc.h"

2  #include "squareproc.h"

3  #include "sqrtproc.h"

4  int

5  main(int argc, char **argv)

6  {

7   int fdsquare, fdsqrt;

8   door_arg_t arg;

9   squareproc_in_t square_in;

10  squareproc_out_t square_out;

11  sqrtproc_in_t sqrt_in;

12  sqrtproc_out_t sqrt_out;

13  if (argc != 2)

14   err_quit("usage: client7 <integer-value>");

15  fdsquare = Open(PATH_SQUARE_DOOR, O_ROWR);

16  fdsqrt = Open(PATH_SQRT_DOOR, O_RDWR);

17  /* подготовка аргументов и вызов squareproc() */

18  square_in.arg1 = atol(argv[1]);

19  arg.data_ptr = (char*)&square_in;

20  arg.data_size = sizeof(square_in);

21  arg.desc_ptr = NULL;

22  arg.desc_num = 0;

23  arg.rbuf = (char*)&square_out;

24  arg.rsize = sizeof(square_out);

25  Door_call(fdsquare, &arg);

26  /* подготовка аргументов и вызов sqrtproc() */

27  sqrt_in.arg1 = atol(argv[1]);

28  arg.data_ptr = (char*)&sqrt_in;

29  arg.data_size = sizeof(sqrt_in);

30  arg.desc_ptr = NULL;

31  arg.desc_num = 0;

32  arg.rbuf = (char*)&sqrt_out;

33  arg.rsize = sizeof(sqrt_out);

34  Door_call(fdsqrt, &arg);

35  printf("result: %ld %gn", square_out.res1, sqrt_out.res1);

36  exit(0);

37 }

Текст двух серверных процедур приведен в листинге 15.11. Каждая из них выводит текущий идентификатор потока и значение аргумента, делает 5-секунд-ную паузу, вычисляет результат и завершает работу.

//doors/server7.c

1  #include "unpipc.h"

2  #include <math.h>

3  #include "squareproc.h"

4  #include "sqrtproc.h"

5  void

6  squareproc(void *cookie, char *dataptr, size_t datasize,

7   door_desc_t *descptr, size_t ndesc)

8  {

9   squareproc_in_t in;

10  squareproc_out_t out;

11  memcpy(&in, dataptr, min(sizeof(in), datasize));

12  printf("squareproc: thread id %ld, arg = %ldn",

13   pr_thread_id(NULL), in.arg1);

14  sleep(5);

15  out.res1 = in.arg1 * in.arg1;

16  Door_return((char *) &out, sizeof(out), NULL, 0);

17 }

18 void

19 sqrtproc(void *cookie, char *dataptr, size_t datasize,

20  door_desc_t *descptr, size_t ndesc)

21 {

22  sqrtproc_in_t in;

23  sqrtproc_out_t out;

24  memcpy(&in, dataptr, min(sizeof(in), datasize));

25  printf("sqrtproc: thread id %ld, arg = %ldn",

26   pr_thread_id(NULL), in.arg1);

27  sleep(5);

28  out.res1 = sqrt((double)in.arg1);

29  Door_return((char *) &out, sizeof(out), NULL, 0);

30 }

Функция main сервера, текст которой приведен в листинге 15.12, открывает дескрипторы дверей и связывает каждый из них с одной из процедур сервера.

//doors/server7.c

31 int

32 main(int argc, char **argv)

33 {

34  int fd;

35  if (argc != 1)

36   err_quit("usage: server7");

37  fd = Door_create(squareproc, NULL, 0);

38  unlink(PATH_SQUARE_DOOR);

39  Close(Open(PATH_SQUARE_DOOR, O_CREAT | O_RDWR, FILE_MODE));

40  Fattach(fd, PATH_SQUARE_DOOR);

41  fd = Door_create(sqrtproc, NULL, 0);

42  unlink(PATH_SQRT_DOOR);

43  Close(Open(PATH_SQRT_DOOR, O_CREAT | O_RDWR, FILE_MODE));

44  Fattach(fd, PATH_SQRT_DOOR);

45  for (;;)

46   pause();

47 }

Запустим программу-клиент и подождем 10 секунд до вывода результатов (как мы и ожидали):

solaris % client7 77

result: 5929 8.77496

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

solaris % server7

squareproc: thread id 4, arg = 77

sqrtproc: thread id 4, arg = 77

Это подтверждает наши предположения о том, что любой поток из пула сервера может использоваться при обработке запросов клиентов для любой процедуры.

Атрибут DOOR_UNREF для серверов

В разделе 15.3 мы отметили, что при вызове door_create для создаваемой двери можно указать атрибут DOOR_UNREF. В документации говорится, что если количество дескрипторов, относящихся к этой двери, уменьшается с двух до одного, осуществляется специальный вызов процедуры сервера. Особенность вызова заключается в том, что второй аргумент процедуры сервера (указатель на данные) при этом является константой DOOR_UNREF_DATA. Мы продемонстрируем три способа обращения к двери.