Как запустить два процесса одновременно
Здравствуйте! Мне необходимо запустить одновременную трансляцию видео- и аудиопотоков на определенный IP. Подскажите пожалуйста, как запустить два процесса одновременно:
arecord -f cd -D plughw:1,0 | ffmpeg -i — -acodec libmp3lame -ab 8k -ac 1 -re -f rtp rtp://192.168.0.101:8082
avconv -f video4linux2 -s 160×120 -v debug -i /dev/video0 -vcodec mpeg2video -r 25 -pix_fmt yuv420p -me_method epzs -b 2600k -bt 256k -f rtp rtp://192.168.0.101:8083
Каждый из них безостановочно вываливает кучу сообщений и запустить второй процесс одновременно с первым, пока тот не закончится, не получается. Подскажите пожалуйста, как это организовать в скрипте.
Как запустить одновременно два процесса linux
Всякая выполняющаяся в Linux программа называется процессом. Linux как многозадачная система характеризуется тем, что одновременно может выполняться множество процессов, принадлежащих одному или нескольким пользователям. Вывести список исполняющихся в текущее время процессов можно командой ps , например, следующим образом:
/home/larry# ps PID TT STAT TIME COMMAND 24 3 S 0:03 (bash) 161 3 R 0:00 ps /home/larry#
Обратите внимание, что по умолчанию команда ps выводит список только тех процессов, которые принадлежат запустившему её пользователю. Чтобы посмотреть все исполняющиеся в системе процессы, нужно подать команду ps -a . Номера процессов (process ID, или PID ), указанные в первой колонке, являются уникальными номерами, которые система присваивает каждому работающему процессу. Последняя колонка, озаглавленная COMMAND, указывает имя работающей команды. В данном случае в списке указаны процессы, которые запустил сам пользователь larry . В системе работает ещё много других процессов, их полный список можно просмотреть командой ps -aux . Однако среди команд, запущенных пользователем larry , есть только bash (командная оболочка для пользователя larry ) и сама команда ps . Видно, что оболочка bash работает одновременно с командой ps . Когда пользователь ввёл команду ps , оболочка bash начала её исполнять. После того, как команда ps закончила свою работу (таблица процессов выведена на экран), управление возвращается процессу bash . Тогда оболочка bash выводит на экран приглашение и ждёт новой команды.
Работающий процесс также называют заданием (job). Понятия процесс и задание являются взаимозаменяемыми. Однако, обычно процесс называют заданием, когда имеют ввиду управление заданием (job control). Управление заданием — это функция командной оболочки, которая предоставляет пользователю возможность переключаться между несколькими заданиями.
В большинстве случаев пользователи запускают только одно задание — это будет та команда, которую они ввели последней в командной оболочке. Однако многие командные оболочки (включая bash и tcsh ) имеют функции управления заданиями (job control), позволяющие запускать одновременно несколько команд или заданий (jobs) и, по мере надобности, переключаться между ними.
Управление заданиями может быть полезно, если, например, вы редактируете большой текстовый файл и хотите временно прервать редактирование, чтобы сделать какую-нибудь другую операцию. С помощью функций управления заданиями можно временно покинуть редактор, вернуться к приглашению командной оболочки и выполнить какие-либо другие действия. Когда они будут сделаны, можно вернуться обратно к работе с редактором и обнаружить его в том же состоянии, в котором он был покинут. У функций управления заданиями есть ещё много полезных применений.
Передний план и фоновый режим
Задания могут быть либо на переднем плане (foreground), либо фоновыми (background). На переднем плане в любой момент времени может быть только одно задание. Задание на переднем плане — это то задание, с которым вы взаимодействуете; оно получает ввод с клавиатуры и посылает вывод на экран (если, разумеется, вы не перенаправили ввод или вывод куда-либо ещё). Напротив, фоновые задания не получают ввода с терминала; как правило, такие задания не нуждаются во взаимодействии с пользователем.
Некоторые задания исполняются очень долго, и во время их работы не происходит ничего интересного. Пример таких заданий — компилирование программ, а также сжатие больших файлов. Нет никаких причин смотреть на экран и ждать, когда эти задания выполнятся. Такие задания следует запускать в фоновом режиме. В это время вы можете работать с другими программами.
Для управления выполнением процессов в Linux предусмотрен механизм передачи сигналов. Сигнал — это способность процессов обмениваться стандартными короткими сообщениями непосредственно с помощью системы. Сообщение-сигнал не содержит никакой информации, кроме номера сигнала (для удобства вместо номера можно использовать предопределённое системой имя). Для того, чтобы передать сигнал, процессу достаточно задействовать системный вызов kill() , а для того, чтобы принять сигнал, не нужно ничего. Если процессу нужно как-то по-особенному реагировать на сигнал, он может зарегистрировать обработчик, а если обработчика нет, за него отреагирует система. Как правило, это приводит к немедленному завершению процесса, получившего сигнал. Обработчик сигнала запускается асинхронно , немедленно после получения сигнала, что бы процесс в это время ни делал.
Два сигнала — номер 9 ( KILL ) и 19 ( STOP ) — всегда обрабатывает система. Первый из них нужен для того, чтобы убить процесс наверняка (отсюда и название). Сигнал STOP приостанавливает процесс: в таком состоянии процесс не удаляется из таблицы процессов, но и не выполняется до тех пор, пока не получит сигнал 18 ( CONT ) — после чего продолжит работу. В командной оболочке Linux сигнал STOP можно передать активному процессу с помощью управляющей последовательности Ctrl — Z .
Сигнал номер 15 ( TERM ) служит для прерывания работы задания. При прерывании (interrupt) задания процесс погибает. Прерывание заданий обычно осуществляется управляющей последовательностью Ctrl — C [1] . Восстановить прерванное задание никаким образом невозможно. Следует также знать, что некоторые программы перехватывают сигнал TERM (при помощи обработчика), так что нажатие комбинации клавиш Ctrl — C (о) может не прервать процесс немедленно. Это сделано для того, чтобы программа могла уничтожить следы своей работы прежде, чем она будет завершена. На практике, некоторые программы вообще нельзя прервать таким способом.
Перевод в фоновый режим и уничтожение заданий
Начнём с простого примера. Рассмотрим команду yes, которая на первый взгляд может показаться бесполезной. Эта команда посылает бесконечный поток строк, состоящих из символа y на стандартный вывод. Посмотрим, как работает эта команда:
/home/larry# yes y y y y y
Последовательность таких строк будет бесконечно продолжаться. Уничтожить этот процесс можно, отправив ему сигнал прерывания, т. е. нажав Ctrl — C . Поступим теперь иначе. Чтобы на экран не выводилась эта бесконечная последовательность перенаправим стандартный вывод команды yes на /dev/null . Как вы, возможно, знаете, устройство /dev/null действует как « чёрная дыра »: все данные, посланные в это устройство, пропадают. С помощью этого устройства очень удобно избавляться от слишком обильного вывода некоторых программ.
/home/larry# yes > /dev/null
Теперь на экран ничего не выводится. Однако и приглашение командной оболочки также не возвращается. Это происходит потому, что команда yes все ещё работает и посылает свои сообщения, состоящие из букв y на /dev/null . Уничтожить это задание также можно, отправив ему сигнал прерывания.
Допустим теперь, что вы хотите, чтобы команда yes продолжала работать, но при этом и приглашение командной оболочки должно вернуться на экран, так чтобы вы могли работать с другими программами. Для этого можно команду yes перевести в фоновый режим, и она будет там работать, не общаясь с вами.
Один способ перевести процесс в фоновый режим — приписать символ & к концу команды. Пример:
/home/larry# yes > /dev/null & [1]+ 164 /home/larry#
Сообщение [1] представляет собой номер задания (job number) для процесса yes. Командная оболочка присваивает номер задания каждому исполняемому заданию. Поскольку yes является единственным исполняемым заданием, ему присваивается номер 1. Число 164 является идентификационным номером, соответствующим данному процессу ( PID ), и этот номер также дан процессу системой. Как мы увидим дальше, к процессу можно обращаться, указывая оба этих номера.
Итак, теперь у нас есть процесс команды yes, работающий в фоне, и непрерывно посылающий поток из букв y на устройство /dev/null . Для того, чтобы узнать статус этого процесса, нужно исполнить команду jobs , которая является внутренней командой оболочки.
/home/larry# jobs [1]+ Running yes >/dev/null & /home/larry#
Мы видим, что эта программа действительно работает. Для того, чтобы узнать статус задания, можно также воспользоваться командой ps , как это было показано выше.
Для того, чтобы передать процессу сигнал (чаще всего возникает потребность прервать работу задания) используется утилита kill . В качестве аргумента этой команде даётся либо номер задания, либо PID . Необязательный параметр — номер сигнала, который нужно отправить процессу. По умолчанию отправляется сигнал TERM . В рассмотренном выше случае номер задания был 1, так что команда kill %1 прервёт работу задания. Когда к заданию обращаются по его номеру (а не PID ), тогда перед этим номером в командной строке нужно поставить символ процента (« % »).
Теперь введём команду jobs снова, чтобы проверить результат предыдущего действия:
/home/larry# jobs [1] Terminated yes >/dev/null
Фактически задание уничтожено, и при вводе команды jobs следующий раз на экране о нем не будет никакой информации.
Уничтожить задание можно также, используя идентификационный номер процесса ( PID ). Этот номер, наряду с идентификационным номером задания, указывается во время старта задания. В нашем примере значение PID было 164, так что команда kill 164 была бы эквивалентна команде kill %1 . При использовании PID в качестве аргумента команды kill вводить символ « % » не требуется.
Приостановка и продолжение работы заданий
Запустим сначала процесс командой yes на переднем плане, как это делалось раньше:
/home/larry# yes > /dev/null
Как и ранее, поскольку процесс работает на переднем плане, приглашение командной оболочки на экран не возвращается.
Теперь вместо того, чтобы прервать задание комбинацией клавиш Ctrl — C , задание можно приостановить (suspend, буквально — подвесить ), отправив ему сигнал STOP . Для приостановки задания надо нажать соответствующую комбинацию клавиш, обычно это Ctrl — Z .
/home/larry# yes > /dev/null Ctrl-Z[1]+ Stopped yes >/dev/null /home/larry#
Приостановленный процесс попросту не выполняется. На него не тратятся вычислительные ресурсы процессора. Приостановленное задание можно запустить выполняться с той же точки, как будто бы оно и не было приостановлено.
Для возобновления выполнения задания на переднем плане можно использовать команду fg (от слова foreground — передний план).
/home/larry# fg yes >/dev/null
Командная оболочка ещё раз выведет на экран название команды, так что пользователь будет знать, какое именно задание он в данный момент запустил на переднем плане. Приостановим это задание ещё раз нажатием клавиш Ctrl — Z , но в этот раз запустим его в фоновый режим командой bg (от слова background — фон). Это приведёт к тому, что данный процесс будет работать так, как если бы при его запуске использовалась команда с символом & в конце (как это делалось в предыдущем разделе):
/home/larry# bg [1]+ yes $>$/dev/null & /home/larry#
При этом приглашение командной оболочки возвращается. Сейчас команда jobs должна показывать, что процесс yes действительно в данный момент работает; этот процесс можно уничтожить командой kill , как это делалось раньше.
Для того, чтобы приостановить задание, работающее в фоновом режиме, нельзя воспользоваться комбинацией клавиш Ctrl — Z . Прежде, чем приостанавливать задание, его нужно перевести на передний план командой fg и лишь потом приостановить. Таким образом, команду fg можно применять либо к приостановленным заданиям, либо к заданию, работающему в фоновом режиме.
Между заданиями в фоновом режиме и приостановленными заданиями есть большая разница. Приостановленное задание не работает — на него не тратятся вычислительные мощности процессора. Это задание не выполняет никаких действий. Приостановленное задание занимает некоторый объем оперативной памяти компьютера, через некоторое время ядро откачает эту часть памяти на жёсткий диск « до востребования ». Напротив, задание в фоновом режиме выполняется, использует память и совершает некоторые действия, которые, возможно, вам требуются, но вы в это время можете работать с другими программами.
Задания, работающие в фоновом режиме, могут пытаться выводить некоторый текст на экран. Это будет мешать работать над другими задачами.
/home/larry# yes &
Здесь стандартный вывод не был перенаправлен на устройство /dev/null , поэтому на экран будет выводится бесконечный поток символов y . Этот поток невозможно будет остановить, поскольку комбинация клавиш Ctrl — C не воздействует на задания в фоновом режиме. Для того чтобы остановить эту выдачу, надо использовать команду fg , которая переведёт задание на передний план, а затем уничтожить задание комбинацией клавиш Ctrl — C .
Сделаем ещё одно замечание. Обычно командой fg и командой bg воздействуют на те задания, которые были приостановлены последними (эти задания будут помечены символом + рядом с номером задания, если ввести команду jobs ). Если в одно и то же время работает одно или несколько заданий, задания можно помещать на передний план или в фоновый режим, задавая в качестве аргументов команды fg или команды bg их идентификационный номер (job ID). Например, команда fg %2 помещает задание номер 2 на передний план, а команда bg %3 помещает задание номер 3 в фоновый режим. Использовать PID в качестве аргументов команд fg и bg нельзя.
Более того, для перевода задания на передний план можно просто указать его номер. Так, команда %2 будет эквивалентна команде fg %2 .
Важно помнить, что функция управления заданием принадлежит оболочке. Команды fg , bg и jobs являются внутренними командами оболочки. Если, по некоторой причине, вы используете командную оболочку, которая не поддерживает функции управления заданиями, то вы в ней этих (и подобных) команд не отыщете.
[1] Прерывающая комбинация клавиш может быть установлена с помощью команды stty .
Как запустить два процесса одновременно?
Задача про Producer&Consumer. Цель задачи в том, что есть два процесса и один общий буфер информации. Один процесс заполняет буфер, а другой берет оттуда информацию. Как я понял нужно использовать fork(). Если буфер пуст, то взять инфу нельзя, а если полон, то нельзя заполнять.
Я разобрался с fork(), при вызову этого метода, мы дублируем весь процесс после него. Один выполняется отцом, а другой сыном. Сейчас, когда я пишу, то всегда сначала выполняется отец, а потом сын. Как сделать что-бы они работали одновременно? Ну, или чередовались хаотично а не 1010101010 (1 — отец, 0 — сын)
- Вопрос задан более трёх лет назад
- 1090 просмотров
Комментировать
Решения вопроса 0
Ответы на вопрос 3
Igor Deyashkin @Lobotomist
Software Developer
Такое ощущение, что вы пытаетесь придумать свой конвейер (pipe). Возможно, я вас не так понял, но думаю, что проще всего, чтобы у вас было две программы:
1. Producer, генерит какие-то данные в stdout
2. Consumer, принимает данные из stdin
И запускаете их таким макаром:
Ответ написан более трёх лет назад
Нравится 1 9 комментариев
annozzer @annozzer Автор вопроса
Не совсем, загвоздка в том, что Consumer и Producer должны быть в одной программе, и как я понял в конвеере мы получаем output в виде 1010101010 или 11111100000 (возможно я не прав).
Igor Deyashkin @Lobotomist
Думаю, вам стоит добавить немного конкретики в ваш вопрос — что именно делает ваша программа. Потому что пока я плохо представляю зачем вам может понадобиться передавать данные между экземплярами одной программы.
annozzer @annozzer Автор вопроса
Igor Deyashkin: Представим что есть, за которым сидят два человека, один повар, другой клиент. Посреди стола стоит тарелка(представим что в тарелку вмещается только 5 стейков) куда повар кладет стейки, а клиент их съедает. приготовил-съел-приготовил-съел это 1010. Мне нужно сделать так, что-бы выходной output получился наподобие 111010011000(дальше он есть не может так как тарелка пуста поэтому процесс клиент должен уснуть а повар работать, и наоборот если тарелка полная.) Проблема заключается в том, что я могу сделать так, что-бы тарелка заполнялась и пустела по определенной закономерности, например приготовил 2 стейка, съел один и так далее пока тарелка не заполнится, и наоборот после заполнения. Но мне нужно сделать, что-бы они ели и готовили с разной скорость которая постоянно меняется. Например повар приготовил 4 стейка, клиент 3, приготовил еще 3, клиент съел все 4, а потом повар приготовил 1 стейк, он и его съел, а потом сразу 5, но почему-то клиент съел только 2, а потом повар приготовил еще один.
annozzer @annozzer Автор вопроса
Igor Deyashkin @Lobotomist
По-моему, конвейером это решается. Я имел ввиду не аналогию — а описать, что вы пытаетесь в своей программе сделать. Что это за поток данных? Почему вам это нужно, чтобы одна и та же программа была и поваром и клиентом? Чем не подходит вариант сделать две программы — одну повора, другую клиента?
Урок 8. Объединение команд — последовательное и параллельное выполнение в bash
Мы уже изучили достаточно команд и наверняка возникал вопрос как применить данные команды сразу к группе файлов. Например, за раз скопировать несколько файлов в каталог или наоборот удалить ненужные файлы. Делать одну и ту же операцию один за другим довольно утомительное и ненужное занятие.
Поэтому в Linux имеются специальные символы, которые позволяют проводить данные операции над несколькими файлами.
Символ “*” указывает на любой символ в любом количестве. Поясним на примере.
У нас имеются следующие файлы:
/image/image1.jpg
/image/image2.jpg
/image/image3.jpg
/image/ image1.txt
/image/ image2.txt
/image/ image.pdf
Необходимо скопировать файлы image в каталог photo/. Для этого достаточно выполнить:
cp image* photo/
Символ «*« в данном случае означает любые символы после слова image, то есть image1.jpg, image2.jpg и так далее, включая image1.txt, image2.txt и image.pdf.
Чтобы лучше понять данный принцип рассмотрим возможные применения данного символа в таблице:
| Команда | Результат |
| cp image* photo/ | Все файлы image1.jpg-image3.jpg, image1.txt, image2.txt, image.pdf |
| cp image*.jpg photo/ | Только файлы image1.jpg — image3.jpg |
| cp *.jpg photo/ | Все файлы jpg: image1.jpg — image3.jpg |
| cp * photo/ | Абсолютно все файлы в текущем каталоге |
Символ “?” указывает на любой одиночный символ. Например, команда cp image?.jpg photo/ скопирует файлы с image1.jpg по image3.jpg, то есть между image и .jpg рассматривается только один знак.
Рассмотрим возможные применения данного символа:
| Команда | Результат |
| cp image?.jpg photo/ | Только с image1.jpg по image9.jpg |
| cp image1?.jpg photo/ | Только с image10.jpg по image15.jpg |
| cp image? photo/ | В нашем случае выдаст ошибку, так такого файла или каталога не существует |
| cp image?.* photo/ | image1.jpg — image9.jpg, image1.txt и image2.txt |
Следующий символ групповых операций — это квадратные скобки []. Внутри скобок помещается определенной выражение.
Например, [12] означает, что в условии должен совпасть один из символов, указанных в скобках, то есть либо 1 либо 2. Также можно задать целый диапазон значений — [1-5], то есть любой символ из указанного диапазона.
Поясним сказанное на примерах:
| Команда | Результат |
| cp image[12].jpg photo/ | Только файлы image1.jpg и image2.jpg |
| cp image1[1-5].jpg photo/ | Только файлы image11.jpg — image15.jpg |
| cp image[12]* photo/ | image1.jpg, image2.jpg, image1.txt, image2.txt |
| cp image?[13].jpg photo/ | Только файлы image11.jpg — image13.jpg |
Как видно с помощью данных символов можно гибко управлять файлами. Данные символы можно использовать с любыми командами. В последующих разделам мы будем часто с ними встречаться.
Объединение команд.
Теперь рассмотрим, как можно объединить между собой сразу несколько команд, заставив их выполнять действие последовательно друг за другом либо параллельно.
Последовательное безусловное выполнение
Иногда при выполнении задач в Linux может потребоваться выполнить сразу целую последовательность команд.
Например, нам нужно создать каталог, скопировать группу файлов student*.jpg в данный каталог и проверить размер данного каталога в килобайтах.
Для этого мы выполним следующее:
mkdir photo
cp student*.jpg photo/
ls -lh
Пришлось последовательно вводить команду, затем ждать ее завершения и вводить следующую. Однако данный процесс можно оптимизировать, введя все команды одну за другой, отделив каждую точкой с запятой:
mkdir photo; cp student*.jpg photo/; ls -lh
Результат будет тот же, но в данном случае мы все сделали гораздо быстрее. Это особенно актуально, если приходится использовать команды, на выполнение которых может уходить больше времени.
Следует помнить, что выполнение всегда передается следующей команде даже, если выполнение предыдущей команды завершилось с ошибкой.
Последовательное выполнение при соблюдении условия
Может возникнуть ситуация, когда от успешного выполнения первых команд зависит выполнение последующих команд. То есть, если первая команда завершилась с ошибкой, то вторую команду выполнять не будем.
Например, из каталога photo/ нам нужно скопировать файлы на внешний носитель, а затем удалить их из каталога photo/. В принципе можно воспользоваться указанной ниже последовательностью
cp student*.jpg /media/StudentFlash; rm student*.jpg
И все будет работать, однако здесь одно НО. Если мы забудем подключить флэшку и выполним вышеуказанную последовательность, то потеряем все файлы student*.jpg, так как несмотря на ошибку система все равно выполнит вторую команду.
Чтобы избежать подобных ситуаций можно воспользоваться конструкцией:
cp student*.jpg /media/StudentFlash && rm student*.jpg
То есть вместо символа «;» (точка с запятой) мы используем «&&«. Проще говоря, если первая команда завершилась с ошибкой (неважно какая), то система не выполнит вторую команду. Если первая команда завершилась успешно, то будет выполнена вторая команда.
Следующий символ объединения «||« используется, когда из 2-х (или более) команд нужно выполнить либо первую либо вторую команду. То есть, если первая команда завершилась с ошибкой, то ход переходит следующей команде, а если первая команда все же успешно завершилась, то вторая команда выполняться не будет.
Например, перейдем в каталог music/, если его не существует то создадим его:
cd music/ || mkdir music
В нашем случае каталог music/ не существует и система выдала ошибку, поэтому будет выполнена команда mkdir music.
Передача выхода одной команды на вход другой команды
Иногда при работе с командой ls выводится слишком много информации, которая не помещается на всем экране и приходится прокручивать текст, чтобы увидеть начало.
Чтобы постранично просматривать результат выполнения команд можно перенаправить вывод ls на вход команды less. Как мы уже знаем она используется для постраничного просмотра текстовых файлов. Для этого воспользуемся символом «|«:
ls | less
Теперь попробуем в системе найти файл под названием icon с помощью команды locate (рассмотрим подробнее позже):
locate * icon
Система может выдать сотни и тысячи значений. Здесь тоже можем воспользоваться символом «|«:
locate * icon | less
Разумеется все это частные случаи. В процессе изучения новых команд и работе в Linux тебе придется не раз встречаться с ситуациями, когда будет необходимо воспользоваться символом «|«.
А можно результат работы locate записать в файл и уже потом просмотреть его содержимое с помощью less?
Конечно можно. Для этого существует другой символ объединения команд «>«:
locate * icon > search_result.txt
В данном случаем символом «>» мы записываем результат выполнения locate в файл search_result.txt.
А файл search_result.txt нужно предварительно создавать?
Нет, если его нет, то система создаст его автоматически. А если он есть, то система перезапишет все его содержимое.
То есть мы можем все потерять по неосторожности?
Совершенно верно, но есть 2 способа избежать этого.
1-й способ.
Можно установить специальную опцию noclobber:
set -o noclobber
Теперь, если файл существует, то система выдаст сообщение об ошибке.
Чтобы отключить эту опцию выполни
set +o noclobber
2-й способ.
Вместо символа «>» воспользуйся символом «>>«. Когда указан этот символ система запишет данные в конец файла, тем самым сохранив предыдущие данные.
Подстановка вывода одной команды под аргумент второй команды
Некоторые команды не могут использоваться самостоятельно без указания аргументов. В качестве аргументов обычно выступают файлы, каталоги либо различные шаблоны и условия (об этом немного позже).
Вместо аргументов в некоторых случаях можно использовать и результаты выполнения некоторых команд.
К примеру, у нас имеется текстовый файл links.txt, где хранится простая текстовая строка.
Попробуем подставить данную строку, чтобы создать каталоги согласно указанной строке. Для этого можно воспользоваться конструкцией типа $():
mkdir $(cat links.txt)
Вывод команды cat был подставлен под аргумент команды mkdir.
mkdir $(date “+%d.%m”)
Данная последовательность создает каталог по текущей дате.