 |
|
|
|
Процессы и нити
Процессы и нити В данной статье я расскажу о работе с процессами в многозадачных операционных системах, в частности о программировании процессов и нитей в Windows и POSIX-совместимых системах. Как вы знаете, Windows NT – это многозадачная ОС, а это значит, что вы можете создавать программным путём другие процессы и нити внутри процесса. Для создания процесса могут использоваться две основные функции: WinExec и CreateProcess. Первая очень проста в применении, имеет только два параметра и может использоваться для создания оконных процессов (к ним можно отнести и консольные программы). Однако возможности WinExec сильно ограничены, и Microsoft громогласно объявила, что вместо этого следует использовать функцию CreateProcess. Но рассмотреть WinExec всё же надо, хотя бы для быстрого написания простых программ. int WinExec(char *command_line, unsigned int show_mode); Функция выполняет программу сommand_line в режиме отображения окна show_mode и ждёт, пока дочерний процесс вызовет функцию GetMessage или пока не прошло время ожидания (это может вызвать задержку выполнения). При успешном выполнении функция возвращает значение, большее 31; меньшее значение сигнализирует об ошибке:
Режимы отображения окна будут описаны далее. Функция CreateProcess принимает большое количество параметров и может использоваться для указания множества атрибутов порождаемым процессам, например, можно сделать оболочку для DOS-программы с графическим интерфейсом ввода/вывода данных, переопределив STDIN и STDOUT и многое другое. Но использовать данную функцию достаточно непросто, так как приходится учитывать некоторые нюансы, а можно ещё и мучиться с атрибутами безопасности, но это уже на любителя... Итак, вот что написано в MSDN: BOOL CreateProcess( // Имя исполняемого файла LPCTSTR lpApplicationName, // Командная строка LPTSTR lpCommandLine, // Атрибуты безопасности процесса LPSECURITY_ATTRIBUTES lpProcessAttributes, // Атрибуты безопасности потока LPSECURITY_ATTRIBUTES lpThreadAttributes, // Наследует ли дочерний процесс дескрипторы родителя BOOL bInheritHandles, // Флаги создания процесса DWORD dwCreationFlags, // Указатель на environment для дочернего процесса LPVOID lpEnvironment, // Текущая директория для процесса LPCTSTR lpCurrentDirectory, // Структура для запуска процесса LPSTARTUPINFO lpStartupInfo, // Указатель, получающий данные о дочернем процессе LPPROCESS_INFORMATION lpProcessInformation ); Краткое объяснение параметров: LPCTSTR lpApplicationName – путь (полный или относительный) к исполняемому файлу. Если путь длинный или содержит пробелы, то необходимо заключить его в кавычки: ""C:very long pathvery long filename.exe"". Учтите, что в WindowsNT для запуска 16-ти разрядных программ необходимо указывать путь к файлу в lpCommandLine, а данный параметр должен равняться NULL (в Win9x 16-ти разрядные файлы выполняются, как и все другие). LPTSTR lpCommandLine – параметры, передаваемые порождаемому процессу в командной строке для 16-ти разрядных приложений в WinNT. При указании пути к 16-ти разрядному приложению надо путь к нему заключать в кавычки, чтобы отделить конец самого пути и начало передаваемых аргументов командной строки. Но такой метод срабатывает и для 32-х разрядных приложений. Поэтому параметр lpApplicationName оставляют в NULL, а в данном параметре прописывают полную командную строку, предварённую путём к файлу. При этом учтите, что если путь неполный и файл не найден относительно текущей директории, то происходит поиск в следующих местах:
LPSECURITY_ATTRIBUTES lpProcessAttributes – атрибуты безопасности процесса. Для большинства случаев следует писать NULL, т.е. атрибуты безопасности наследуются порождаемым процессом. LPSECURITY_ATTRIBUTES lpThreadAttributes – атрибуты безопасности потока, тоже обычно NULL. BOOL bInheritHandles – флаг, определяющий наследует ли дочерний процесс дескрипторы родителя. Данный флаг удобно применять для межпроцессовых коммуникаций через неименованные трубки (pipe) и для совместного использования файлов. Общее правило: если процесс собирается общаться с потомком, этот параметр должен быть TRUE. DWORD dwCreationFlags – флаги создания процесса. Битовая маска, определяющая различные параметры создания процесса. Обычно используется для указания приоритета процесса:
Есть ещё интересные параметры для отладки приложений, позволяющие применять функции непосредственного доступа к памяти процесса ReadProcessMemory и WriteProcessMemory, но описание этого выходит за рамки данной статьи. LPVOID lpEnvironment – указатель на environment для дочернего процесса, представляет собой блок строк, заканчивающихся NULL, содержащих в себе описание переменных окружения для дочернего процесса в формате «имя=значение». Если данный параметр NULL, то по традиции он наследуется от родительского процесса. LPCTSTR lpCurrentDirectory – текущая директория для процесса. LPSTARTUPINFO lpStartupInfo – структура для запуска процесса – это самая интересная часть CreateProcess, будет описана далее. LPPROCESS_INFORMATION lpProcessInformation – указатель, получающий данные о дочернем процессе в формате: struct PROCESS_INFORMATION{ HANDLE hProcess; – дескриптор порождённого процесса; HANDLE hThread; – дескриптор главного потока дочернего процесса; DWORD dwProcessId; – идентификатор порождённого процесса; DWORD dwThreadId; – идентификатор порождённого потока. } А теперь я приведу описание структуры STARTUPINFO, и многие поймут, почему системных программистов Windows возводят в ранг великомучеников. struct STARTUPINFO { DWORD cb; LPTSTR lpReserved; LPTSTR lpDesktop; LPTSTR lpTitle; DWORD dwX; DWORD dwY; DWORD dwXSize; DWORD dwYSize; DWORD dwXCountChars; DWORD dwYCountChars; DWORD dwFillAttribute; DWORD dwFlags; WORD wShowWindow; WORD cbReserved2; LPBYTE lpReserved2; HANDLE hStdInput; HANDLE hStdOutput; HANDLE hStdError; }; Теперь «краткое» описание полей:
Параметры размера игнорируются, если только в dwFlags не установлен атрибут STARTF_USEPOSITION и/или STARTF_USESIZE.
Тут могу посоветовать одно: обнуляйте структуру перед использованием, а затем заполняйте нужные поля, остальные установятся по умолчанию. Ну что же, пришло время для чего-нибудь интересного. Итак, примеры. Для начала запустим какой-нибудь notepad и загрузим в него какой-нибудь файл, в данном примере test.txt: // Информация о процессе STARTUPINFO si; // Обнуление структуры memset(&si, 0, sizeof(STARTUPINFO)); // Заполнение полей si.cb = sizeof(STARTUPINFO); // Флаги si.dwFlags = STARTF_USESHOWWINDOW; // Показываем окошко si.wShowWindow = SW_SHOWNORMAL; // Информация о процессе PROCESS_INFORMATION pi; // Вот и всё! Теперь блокнот запущен CreateProcess(NULL, "notepad.exe test.txt", NULL, NULL, FALSE, 0, 0, 0, &si, ?); А теперь более интересный пример – создание оболочки для программы MS-DOS. Для общения с консольной программой можно использовать только неименованные каналы (pipe). Проблема в том, что в WinNT неименованные каналы не наследуются порождаемым процессом. Для того чтобы наследовать неименованные каналы, необходимо установить соответствующие параметры безопасности. Но я подробно на этом останавливаться не буду – просто примите это на веру, так как дескрипторы безопасности – это отдельная большая тема. SECURITY_DESCRIPTOR sd; // Дескриптор безопасности SECURITY_ATTRIBUTES sa; // и его атрибуты LPSECURITY_ATTRIBUTES lpsa = NULL; // Это Windows NT if (GetVersion() < 0x80000000) { // Инициализация дескриптора InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION); SetSecurityDescriptorDacl(&sd, true, NULL, false); sa.nLength = sizeof(SECURITY_ATTRIBUTES); // Разрешаем наследование дескрипторов sa.bInheritHandle = true; sa.lpSecurityDescriptor = &sd; // А вот это уже нормальный дескриптор безопасности lpsa = &sa; } // Создаём неименованный канал и получаем дескрипторы чтения/записи HANDLE hReadPipe; HANDLE hWritePipe; // Создание канала CreatePipe(&hReadPipe, &hWritePipe, lpsa,25000); // Ну а это инициализация STARTUPINFO STARTUPINFO si; // Обнуление memset(&si, 0, sizeof(STARTUPINFO)); si.cb = sizeof(STARTUPINFO); // Флаг перенаправления дескрипторов si.dwFlags = STARTF_USESHOWWINDOW |STARTF_USESTDHANDLES; // Прячем окошко si.wShowWindow = SW_HIDE; // Указатели stdout и stderr перенаправляются в канал si.hStdOutput = hWritePipe; si.hStdError = hWritePipe; PROCESS_INFORMATION pi; if(CreateProcess(NULL, "bcc -otest test.c", NULL, NULL, TRUE, 0, 0, 0, &si, &pi)){ // Закрываем дескриптор потока CloseHandle(pi.hThread); // Ждём завершения дочернего процесса 90 сек. WaitForSingleObject(pi.hProcess, 90000); // Читаем из канала данные DWORD BytesRead; // Количество считанных байт char dest[4000]; // Вот в этот буфер писать и будем int LoopDone = 0; int FBreak = 0; // Цикл чтения данных из канала, с защитой от тайм-аута, т.к. чтение неблокирующее while (!LoopDone) { memset(dest, 0, 4000); ReadFile(hReadPipe, &dest, sizeof(dest), &BytesRead, NULL); if (BytesRead < 4000 || FBreak > 150) LoopDone = -1; else LoopDone = 0; FBreak++; } } А теперь приведу пример взаимодействия сервиса с рабочим столом, например, сервис, вызывающий explorer с привилегиями LocalSystem (фактически привилегии операционной системы): PROCESS_INFORMATION pi; // Ну а это инициализация STARTUPINFO STARTUPINFO si; memset(&si, 0, sizeof(STARTUPINFO)); // Обнуление si.cb = sizeof(STARTUPINFO); // И установка полей si.lpDesktop = "WinSta0\\Default"; // Это рабочий стол по умолчанию! si.dwFlags = STARTF_USESHOWWINDOW; si.wShowWindow = SW_SHOW; if (CreateProcess(NULL, "explorer", NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) { // Закрываем все дескрипторы в конце программы CloseHandle(pi.hProcess); CloseHandle(pi.hThread); } После создания дочернего процесса собственного написания для взаимодействия с сервисом наиболее удобно использовать именованные каналы, но это уже другая тема... Теперь я расскажу о нитях. Вообще термин thread очень сложно однозначно перевести, но я буду называть их нити или потоки. Поток – это функция, которая выполняется внутри процесса одновременно с другими функциями, т.е. процесс разделяется на нити, выполняющиеся одновременно и использующими одно и то же адресное пространство, что нужно для создания нескольких параллельных потоков, работающих над одной задачей, чтобы не тратить много времени на перегонку результатов через именованные и неименованные каналы... Когда процессы разные, важно, чтобы один другому не мешал и не мог бы его случайно повредить и прочее. Когда же процесс один, но многопотоковый, наоборот, нужно одно общее адресное пространство. Для создания потока в WinNT необходимо применить функцию CreateThread. Учтите, что работа с потоками кардинальным образом отличается от работы с процессами, т.к. нет необходимости применять межпроцессные коммуникации ОС и с потоком можно работать также, как и с любой другой функцией, например, передавать в неё параметры. Кроме этого, так как все потоки используют общее адресное пространство, то глобальные и статические переменные одинаковы во всех нитях (иногда встают проблемы синхронизации потоков), хотя межпроцессные коммуникации также возможны (у нити есть собственный дескриптор), что делает нить неким «гибридом» между функцией и процессом по способу взаимодействия. HANDLE CreateThread( // Атрибуты безопасности (NULL) LPSECURITY_ATTRIBUTES lpThreadAttributes, // Размер стека для потока (если 0, то используется умолчание DWORD dwStackSize, // Указатель на функцию потока LPTHREAD_START_ROUTINE lpStartAddress, // Аргументы, передаваемые потоку LPVOID lpParameter, // Флаги создания DWORD dwCreationFlags, // Получает ID потока LPDWORD lpThreadId ); Синтаксис данной команды довольно простой, но я хотел бы рассказать следующее: если вы передаёте нити аргументы, то их нужно прямо приводить к типу void *, а в самом потоке делать обратное преобразование. Данный способ позволяет передать потоку абсолютно любые параметры. Если вы не хотите, чтобы поток сразу же запускался, то укажите флаг CREATE_SUSPENDED, тогда нить создастся, но запускаться не будет. Функция CreateThread возвращает дескриптор потока или NULL при ошибке. Функция потока имеет вид DWORD WINAPI ThreadFunc(LPVOID data), где data – передаваемые параметры. Для управления состоянием потоков используются функции SuspendThread и ResumeThread для соответственно приостанавливания и восстановления потоков. Функции принимают один аргумент – дескриптор потока и возвращают 1 в случае ошибки. Для убиения потока используется функция TerminateThread, она принимает два параметра: дескриптор потока и код ошибки. Если поток хочет сообщить вызывающему потоку код завершения, то он должен использовать функцию ExitThread(DWORD dwExit-Code), а вызывающий поток должен вызвать GetExitThread-Code(HANDLE hThread, LPDWORD lpdwExitCode), и поле lpdwExitCode заполняется кодом завершения потока. Пример создания простого сервиса: // Формат функции потока жёстко задан DWORD WINAPI ThreadFunc(LPVOID lpParam) { char szMsg[80]; wsprintf( szMsg, "Поток: параметр = %d ", *lpParam ); MessageBox( NULL, szMsg, "Поток создан.", MB_OK ); return 0; } int main(void) { //Параметр для потока DWORD dwThreadId, dwThrdParam = 1; HANDLE hThread; hThread = CreateThread( NULL, // безопасность по умолчанию 0, // размер стека по умолчанию ThreadFunc, // функция потока (void *) &dwThrdParam, // параметр для функции нити 0, // нет специальных флагов создания &dwThreadId); // получает ID нити // Проверяем правильность работы потока. if (hThread == NULL) return -1; // Негласное правило – закрываем дескрипторы вручную CloseHandle(hThread); return 0; } Потоки – это мощное и хорошо реализованное в WinNT средство. Потоки очень часто применяются в серверных приложениях, сервисах и прочих программах, использующих «разделение труда». Потоки легко использовать и управлять ими. Единственное, о чём приходится заботиться, – это синхронизация данных между потоками, работающими одновременно, для этого существуют механизмы семафоров и мьютексов, но опять же это другая тема... В других операционных системах также есть свои функции создания процессов и потоков. Наиболее переносимой является семейство функций exec*, которые производят запуск дочернего процесса в адресном пространстве родительского, т.е. после выполнения exec дочерний процесс заменяет родительский. Данная функция есть практически во всех ОС: POSIX, Windows, DOS, OS/2. Формат функции зависит от суффикса функции, например: execl, execlp, execve. Буквы l и v обозначают способ передачи аргументов дочернему процессу: в виде массива строк (суффикс v) или в виде последовательных строк, заканчивающихся нулевой строкой (суффикс l). Суффикс e сигнализирует, что дочернему процессу также передаётся массив строк окружения (имя_переменной=значение). Суффикс p означает, что нужно произвести поиск исполняемого файла в PATH. Итак, общий формат функции: // указываем переменные окружения int execve(char *path, char *args[], char *env[]) // идет поиск в PATH int execlp(char *path, char *arg1, char *arg2 ... char *argn, NULL) При удачном выполнении функция не возвращает ничего (возвращать-то некому! родительский процесс уже заменён на дочерний), иначе произошла ошибка. Замечу, что в DOS, Windows и OS/2 есть ещё семейство функций spawn*, подобных exec*, но не заменяющих родительский процесс, а создающих параллельный. Причём возвращают они идентификатор процесса. Кроме этого, функции семейства spawn принимают первым параметром режим запуска, который может принимать следующие значения:
Ещё раз повторяю: функции spawn* не поддерживаются POSIX-стандартом. Для ожидания окончания дочернего процесса используется функция pid_t wait(int *process_stat). Данная функция дожидается окончания дочернего процесса и заполняет параметр process_stat. При нормальном завершении дочернего процесса старшие биты данной структуры содержат код завершения программы, иначе устанавливаются биты 1, 2, 3. Если дочерний процесс уже завершился, то функция wait немедленно возвращается, а ресурсы, занятые потомком, освобождаются. В POSIX-системах возможно также применение функции wait к нитям, но об этом далее. Пример использования функций exec и spawn: int main() { //Формирование массива аргументов char *ar[2] = {"test.c" "-otest"}; //А теперь нашего процесса уже нет, он заменился gcc return execvp("gcc", ar); } --------------------------------------------------------- int main() { //Запускаем gcc параллельно spawnlp(P_NOWAIT, "gcc", "test.c", "-otest", NULL); // Для чего-то ждём завершения gcc и выходим return wait(NULL); } В POSIX определён также замечательный системный вызов fork, который выполняет «разделение» существующего процесса. После вызова fork происходит полное копирование адресного пространства существующего процесса, и далее продолжают выполняться 2 процесса, отличающихся только идентификатором процесса. Причём родителю fork возвращает идентификатор дочернего процесса, а дочернему – 0. Так можно определить тип процесса: родитель или потомок. У двух процессов после fork идентично содержимое памяти, стека, файловых дескрипторов, идентификаторов пользователя процесса (UID), каналов и т. д. Не наследуются только те участки памяти, которые были закреплены с помощью mlock(void *mem, size_t size). Можно сказать, что после вызова fork происходит разделение исходного процесса на два идентичных, но при этом между собой не связанных процесса (т.е. адресное пространство у них разное). Далее обычно дочерний и родительский процессы начинают вести себя по-разному, в зависимости от значения, возвращённого fork. C помощью fork можно выполнить множество полезных действий, например, создание демонов, сокетных серверов и т. д. Например, с помощью функции fork можно организовать поведение, аналогичное spawn в win32: void main() { pid_t pid; // Идентификатор процесса pid = fork(); // А теперь уже 2 процесса if(pid == -1) // Произошла ошибка return;
if(pid == 0){ // Это дочерний процесс execlp("gcc", "test.c", "-otest", NULL); } else{ printf("Compiling now\n"); // Так как ждём мы другой процесс, то надо указать его PID waitpid(pid, NULL, 0); printf("That`s all\n"); } } Кроме вышеперечисленных функций существуют также функции system и popen, выполняющие команды средствами операционной системы. Первая из них int system(char * command) выполняет файл command и возвращает вызывающей программе код завершения. Функция блокирует выполнение родительского процесса до завершения работы потомка. В системах POSIX command выполняется вызовом /bin/sh –c command. Функция system не должна употребляться с программами, устанавливающими биты suid sgid, во избежание «странного» поведения. Функция popen используется в POSIX-системах аналогично system (выполняется /bin/sh –c), но данная функция возвращает файловый поток, связанный с дочерней программой (аналог конвейера | в shell), что позволяет взаимодействовать с потомком. FILE *popen(char *path, char *mode), где mode – режим открытия канала, аналогичный режимам открытия файла в fopen (учтите, что нельзя открывать такой поток одновременно для чтения и записи), при этом реально создается неименнованный канал. После этого возможно взаимодействие с потомком через этот поток стандартными функциями работы с файлами (fprintf, fscanf, fread, fwrite). Работа с потоком является буферизованной и блокирующей, поэтому всегда надо готовиться к худшему (к получению сигнала SIGCHILD). Если потомок завершился, то попытки чтения из трубы неудачны, а feof возвращает не ноль. Поток, открытый popen, должен завершаться функцией pclose, ждущей окончания процесса и закрывающей созданный канал. int main() { char buf[1024]; FILE *f = NULL; //Открываем канал в режиме чтения f = popen("ls -l", "r"); if(f==NULL){ //Что-то не так perror("Failed to execute ls!"); return -1; } while(!feof){ //Пока потомок работает fgets(buf, 1024, f); //Читаем из канала printf("%s", buf); } pclose(f); //Закрываем канал return 0; } В форуме журнала был вопрос, связанный с поиском файлов в UNIX. Одним из решений может служить взаимодействие со стандартной утилитой find при помощи функции popen("find some_file", "r"). В качестве альтернативы можно также использовать команды locate и whereis. Во многих UNIX-подобных системах (в частности в Linux) организована поддержка нитей. К сожалению, возможность эта ещё пока недостаточно отлажена и использовать её не так-то просто. Но я, тем не менее, расскажу об основных принципах создания нитей в UNIX. Нити в UNIX представляют собой особый вид процессов и создание нити очень похоже на вызов fork. Для создания нити необходимо применять функции библиотеки pthread. Для каждого потока схема создания следующая: инициализация атрибутов нити, создание нити, уничтожение нити и уничтожение её атрибутов. int pthread_attr_init(pthread_attr_t *a) – установка атрибутов по умолчанию в структуре a. Далее можно устанавливать приоритет потока и другие его атрибуты функциями, специальными для каждого атрибута (таких функций 5 пар, отвечающих за включение и выключение отдельных атрибутов). int pthread_create(pthread_t *thread, pthread_attr_t *attr, void * (*start_func)(void *), void *arg) – создаёт нить с атрибутами attr на основе функции start_func и передающей этой функции параметры arg типа void * (здесь всё, как и в WinNT). Если создание нити прошло удачно, функция возвращает 0, а поле thread заполняется идентификатором потока. int pthread_join(pthread_t thread, void **retval) – данный поток приостанавливает своё исполнение и ждёт завершения потока thread, который заполняет поле retval. void pthread_exit(void *retval) – завершает текущий поток и записывает результат выхода retval. int pthread_attr_destroy(pthread_attr_t *attr) – очистка структуры атрибутов нити. Итак, приведу простенький пример создания нити в Linux. #include <pthread.h> void *thread_func(void *arg) { printf("Thread is running\n"); //Выходим из потока pthread_exit(NULL); } int main() { //Атрибуты pthread_attr_t a; //Два потока pthread_t thread1; pthread_t thread2; //Создаём атрибуты по умолчанию pthread_attr_init(&a); //Создаём потоки pthread_create(&thread1, &a, thread_func, NULL); pthread_create(&thread2, &a, thread_func, NULL); //Ждём завершения 2-го потока pthread_join(thread2, NULL); //Убиваем атрибуты pthread_attr_destroy(&a); return 0; } Компилируем так: gcc test_thread.c -lpthread |
ВСЕВОЛОД СТАХОВКомментарии отсутствуют
| Добавить комментарий |
|
Комментарии могут оставлять только зарегистрированные пользователи |
|
