Розетками: Разветвители и переходники с 4 розетками купить по низкой цене

Что такое герметичные розетки?

Нет ничего более важного, чем безопасность Вашей семьи, сотрудников или клиентов Вашей фирмы. Именно поэтому в помещениях, подверженных воздействию влаги или контакту с водой, а именно в ванных комнатах, кухнях и подвалах, на протяжении многих лет используются герметичные розетки, также известные как влагозащищенные розетки.

Характерной особенностью герметичной розетки является встроенная в розетку защитная крышка.   Она эффективно блокирует воздействие интенсивной влажности или капель воды непосредственно на электрический контакт. Герметичные розетки также используются в школах и детских садах, поскольку они препятствуют непосредственному доступу детей к электрическим контактам и понижают риск поражения электрическим током.

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

Также не стоит забывать об эстетических качествах. Сегодня влагозащищенные розетки доступны в различных цветах и ​​моделях, поэтому они могут вписаться в большинство интерьеров, независимо от стиля помещения.  

Наружные герметичные розетки — это розетки, которые могут быть установлены непосредственно на поверхности стены без необходимости прокладки электропроводки в стене. Такие розетки использовались до сих пор в основном в гаражах, подвалах и складах. Однако с недавних пор, с приходом моды на промышленный стиль, эти розетки стали популярны среди дизайнеров интерьеров и все чаще встречаются в современных аранжировках.

Встраиваемые герметичные розетки — это розетки, которые устанавливаются в стене. Их электропроводка полностью скрыта. Эти розетки наиболее часто используются в квартирах и домах, а также везде, где важна дискретность электрических контактов.

Заземление предотвращает долгосрочное поддержание электрического потенциала на корпусах электрооборудования. Это защитная система, которая направлена ​​на обеспечение безопасной и правильной работы электрооборудования.   Благодаря моделям, оснащенным заземлением, мы защищаем наше электрооборудование ещё надежнее.  Подключенное к источнику питания устройство не будет повреждено, если произойдет прорыв.

Нам встречается много маркировок герметичных розеток: IP44, IP45, IP55 i IP65. Классификация IP – это, проще говоря, различие степеней защиты электрических устройств, гарантированных корпусом этих устройств. А именно:

IP44:

• защита от посторонних предметов диаметром более 1 мм
• защиты от брызг

IP45:

• защита от посторонних предметов диаметром более 1 мм
• защиты от струи воды 12л/мин, направленной на корпус устройства

IP55:

• защиты от пыли
• защиты от струи воды 12л/мин, направленной на корпус устройства

IP65:

• полная защита от пыли
• защиты от струи воды 12л/мин, направленной на корпус устройства

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

Компания Ospel уже многие годы занимается производством влагозащищенных розеток. В производстве мы используем новейшие технологии, высококачественные материалы, а также мы заботимся об эстетическом внешнем виде наших розеток. В коллекциях OSPEL мы подготовили влагозащищенные розетки в модной цветовой гамме для каждого типа и стиля помещения. Мы уделили особое внимание безопасности. Крышки и прокладки наших розеток изготовлены из качественных и, прежде всего, прочных материалов. Более того, наши розетки полностью польского производства. Мы уверены, что клиенты по достоинству оценят качество и исполнение наших розеток.

Эволюция электрических розеток.

В то время бытовые электроприборы обычно включали в патроны ламп. Несомненно, такое подключение было неудобно и небезопасно, поэтому требовалась разработака специальных разъёмов.

Бытовая электрическая штепсельная розетка возникла, по сути, благодаря сочетанию двух факторов – появлению электробытовых приборов и возникновению необходимости подключать их в удобном для пользователя месте. Т.е. если не родителями штепсельной пары вилка-розетка, то причиной ее быстрого и широкого распространения стало появление мобильных бытовых электрических приборов.

Первым, патент на электрическую розетку в 1904 году получил Харви Хаббелл II (Harvey Hubbell II), U.S. patent No. 774,250. Кроме того, он добился принятия единого стандарта. Запатентованная Хаббелом штепсельная пара отличается от распространённой в настоящее время (преимущественно в Европе и России) только формой штырей вилки. У «Хаббеловского» изделия штыри представляют собой плоские фигурные пластины и соответствующей формы разъемы в розетке. Стоит отметить, что плоские контакты также имеют распространение (например, американский и японский, стандарты Великобритании и Израиля).

Другие производители приняли разъём Хаббелла и к 1915 году он стал широко распространён, хотя и в 1920х годах, и даже значительно позднее переходники для патронов Эдисона пользовались популярностью. Хоть и нечасто, но такие переходники можно найти в продаже и сегодня.

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

Изначально, розетка не была приспособлена для закрепления на стене. Подобный тип розеток дожил до наших дней, например, в виде розеток на бытовых удлинителях. Чуть позже розетки стали монтировать на стену, еще позже, при переходе к скрытой проводке, в углубление в стене. Такое направление эволюции розеток можно объяснить двумя причинами. Первоначально, электричество приходило в уже существующие здания, проводка устраивалась по поверхности стен, поскольку это не требовало объемных строительных работ. С другой стороны, низкое качество изоляции проводников, подверженность ее старению, требовало иметь возможность визуально контролировать и по мере надобности обслуживать и заменять провода и места их соединений. В настоящее время, преимущественно используются медные провода, как наиболее подходящие, имеющие низкое сопротивление и высокую долговечность, что позволило в большинстве перейти к использованию внутренней проводки.

С момента выдачи патента на изобретение Хаббела, до идеи объединения в одном корпусе более чем одной розетки прошло 14 лет. В 1918 году основатель компании «Matsushita Electric» Коносокэ Мацусита вышел на японский рынок с двойной розеткой. Такое решение позволяло упростить монтаж и сэкономить место на стене.

Следующей важной вехой в истории развития электрических розеток стало изобретение Альбертом Бюттнером розетки с заземляющим контактом (Schuko). Патент на это изобретение вступил в силу в 1926 году.

«Schuko» (Шуко) это разговорное название системы cиловых вилок и розеток для переменного тока, официально определённой в стандарте CEE 7/4 или известной неофициально как «Тип F». «Schuko» — это сокращение от немецкого термина Schutzkontakt (Шутцконтакт, дословно: «защитный контакт»), что просто указывает на то, что вилка и розетка снабжены контактами защитного заземления (в виде скоб, а не штырей).Разъёмы Schuko обычно используются в цепях на 230 В, 50 Гц, для токов силой до 16 А.

По состоянию на 2011 год система используется в более чем 40 странах, включая большую часть континентальной Европы.

В странах бывшего CCCР вилку Schuko часто называют «евровилкой», а розетку — «евророзеткой», видимо из-за того, что приборы, поставляемые из Европы (в данном случае Германии) комплектовались вилкой Schuko.

Розетки Schuko критикуют за то, что они не снабжены предохранителем, неполяризованы по своей конструкции (хотя необходимость поляризации тоже подвергается сомнению), за значительное усилие для подключения и отключения вилки, что для некоторых людей является проблемой, и за большие габариты. Стандарт IEC 60906-1, возможно, вытеснит Schuko в будущем.

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

Большинство производителей перешло к модульным типам устройств. Такие устройства позволяют комбинировать розетки с рамками под количество мест от 1 до 5 и организовывать, таким образом, места подключений с необходимым количеством розеток.

Изначально розетки ставились на достаточной большой высоте от пола. Впоследствии, в России был разработан стандарт, регламентирующий установку розеток на расстоянии 80 – 90 см от пола (в настоящее время ПЭУ определяет положение розеток не выше 180 см). Другие стандарты определяют ещё более низкое положение розеток, 20 – 30 см от пола. «Плинтусные розетки», имеющие соответствующую форму, устанавливаются непосредственно на плинтус, в кабель-канале которого прокладываются провода.

Розетки и наборы розеток | DEWALT

Гнезда DEWALT ^® оснащены декоративными кольцами с накаткой, которые помогают уменьшить проскальзывание при обращении, и маркировкой с лазерной гравировкой для облегчения идентификации.

Ваш выбор

41 результат Очистить все

Нет текущих выборов

Товаров не найдено.

{{{Navigation_Title}}}

{{ModelName}}

Межпроцессное взаимодействие в Linux: сокеты и сигналы

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

Розетки

Точно так же, как трубы бывают двух видов (именованные и безымянные), так и сокеты. Сокеты IPC (также известные как сокеты домена Unix) обеспечивают связь на основе каналов для процессов на одном и том же физическом устройстве (хост , ), тогда как сетевые сокеты позволяют использовать этот вид IPC для процессов, которые могут выполняться на разных хостах, тем самым задействуя сеть.Сетевые сокеты нуждаются в поддержке базового протокола, такого как TCP (протокол управления передачей) или UDP (протокол дейтаграмм пользователя) нижнего уровня.

Напротив, сокеты IPC полагаются на ядро ​​локальной системы для поддержки связи; в частности, IPC-сокеты обмениваются данными, используя локальный файл в качестве адреса сокета. Несмотря на эти различия в реализации, API-интерфейсы сокетов IPC и сетевых сокетов по сути идентичны. В следующем примере рассматриваются сетевые сокеты, но примеры серверных и клиентских программ могут работать на одном компьютере, поскольку сервер использует сетевой адрес localhost (127. 0.0.1), адрес локальной машины на локальной машине.

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

[Загрузить полное руководство по межпроцессному взаимодействию в Linux]

Итерационный сервер , который подходит только для разработки, обрабатывает подключенных клиентов по одному до завершения: первый клиент обрабатывается от начала до конца, затем второй и так далее.Обратной стороной является то, что обработка конкретного клиента может зависнуть, что затем истощает всех ожидающих клиентов. Сервер производственного уровня будет иметь одновременных , обычно с использованием некоторого сочетания многопроцессорной обработки и многопоточности. Например, веб-сервер Nginx на моем настольном компьютере имеет пул из четырех рабочих процессов, которые могут обрабатывать клиентские запросы одновременно. В следующем примере кода беспорядок сводится к минимуму за счет использования итеративного сервера; Таким образом, основное внимание уделяется базовому API, а не параллелизму.

Наконец, API сокетов значительно эволюционировал с появлением различных усовершенствований POSIX. Текущий пример кода для сервера и клиента намеренно прост, но подчеркивает двунаправленный аспект потокового сокетного соединения. Вот краткое описание потока управления, когда сервер запускается в терминале, затем клиент запускается в отдельном терминале:

Пример 1. Сервер сокетов

 #include  
 #include  
 #include  
 #include  
 #include  
 #include  
 #include  
 # include  
 #include "sock.h" 
 void report (const char * msg, int terminate) {
 perror (msg); 
 если (завершить) выход (-1); / * сбой * / 
} 
 
 int main () {
 int fd = socket (AF_INET, / * сеть по сравнению с AF_LOCAL * / 
 SOCK_STREAM, / * надежный, двунаправленный, произвольный размер полезной нагрузки * / 
 0); / * система выбирает базовый протокол (TCP) * / 
 if (fd <0) report ("socket", 1); / * завершение * / 
 
 / * привязка локального адреса сервера в памяти * / 
 struct sockaddr_in saddr; 
 memset (& saddr, 0, sizeof (saddr)); / * очищаем байты * / 
 saddr. sin_family = AF_INET; / * по сравнению с AF_LOCAL * / 
 saddr.sin_addr.s_addr = htonl (INADDR_ANY); / * порядок байтов от хоста к сети * / 
 saddr.sin_port = htons (PortNumber); / * для прослушивания * / 
 
 if (bind (fd, (struct sockaddr *) & saddr, sizeof (saddr)) <0) 
 report ("bind", 1); / * завершение * / 
 
 / * прослушивание сокета * / 
 if (listen (fd, MaxConnects) <0) / * прослушивание клиентов, вплоть до MaxConnects * / отчет 
 ("прослушивание", 1); / * terminate * / 
 
 fprintf (stderr, "Прослушивание порта% i для клиентов... \ n ", PortNumber); 
 / * сервер традиционно слушает бесконечно * / 
 while (1) {
 struct sockaddr_in caddr; / * адрес клиента * / 
 int len ​​= sizeof (caddr); / * длина адреса может изменить * / 
 
 int client_fd = accept (fd, (struct sockaddr *) & caddr, & len); / * принять блоки * / 
 if (client_fd <0) {
 report ("accept", 0); / * don ' t terminate, хотя есть проблема * / 
 continue; 
} 
 
 / * чтение с клиента * / 
 int i; 
 for (i = 0; i  char buffer [BuffSize + 1]; 
 memset (buffer, '\ 0', sizeof (buffer)); 
 int count = read (client_fd, buffer, sizeof (buffer)); 
 if (count> 0) {
 put (buffer); 
 write (client_fd , buffer, sizeof (buffer)); / * вывод в качестве подтверждения * / 
} 
} 
 close (client_fd); / * разрыв соединения * / 
} / * while (1) * / 
 return 0; 
} 
 

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

1. socket (…) : получить дескриптор файла для соединения с сокетом
2. bind (…) : привязать сокет к адресу на хосте сервера
3. слушать (…) : слушать запросы клиентов
4. accept (…) : принять конкретный запрос клиента

Розетка вызов в полном объеме:

 
 int sockfd = socket (AF_INET, / * по сравнению с AF_LOCAL * / 
 SOCK_STREAM, / * надежный, двунаправленный * / 
 0); / * протокол выбора системы (TCP) * / 
 

Первый аргумент определяет сетевой сокет, а не IPC-сокет.Для второго аргумента существует несколько вариантов, но наиболее часто используются SOCK_STREAM и SOCK_DGRAM (дейтаграмма). Потоковый сокет поддерживает надежный канал, по которому сообщается о потерянных или измененных сообщениях; канал является двунаправленным, и полезная нагрузка от одной стороны к другой может быть произвольного размера. Напротив, сокет на основе дейтаграмм ненадежен ( лучше всего ), однонаправлен и требует полезной нагрузки фиксированного размера. Третий аргумент socket указывает протокол.Для задействованного здесь потокового сокета есть единственный вариант, который представляет ноль: TCP. Поскольку успешный вызов socket возвращает знакомый файловый дескриптор, сокет записывается и читается с тем же синтаксисом, что и, например, локальный файл.

Вызов bind является наиболее сложным, поскольку он отражает различные уточнения в API сокетов. Интересно то, что этот вызов связывает сокет с адресом памяти на сервере. Однако вызов listen прост:

  если (прослушивание (fd, MaxConnects) <0)  

Первый аргумент - это файловый дескриптор сокета, а второй указывает, сколько клиентских подключений может быть выполнено до того, как сервер выдаст сообщение , в котором отказано в соединении, ошибка при попытке подключения. ( MaxConnects имеет значение 8 в файле заголовка sock.h .)

Для accept по умолчанию установлено ожидание блокировки : сервер ничего не делает, пока клиент не попытается подключиться, а затем продолжит работу. Функция accept возвращает -1 , чтобы указать на ошибку. Если вызов завершается успешно, он возвращает другой дескриптор файла - для сокета чтения / записи , в отличие от , принимающего сокет , на который ссылается первый аргумент в вызове accept .Сервер использует сокет чтения / записи для чтения запросов от клиента и для обратной записи ответов. Принимающий сокет используется только для приема клиентских подключений.

По умолчанию сервер работает бесконечно. Соответственно, сервер может быть остановлен с помощью Ctrl + C из командной строки.

Пример 2. Клиент сокета

 #include  
 #include  h> 
 #include  
 #include  
 #include  
 #include  
 #include  
 #include  
 #include  
 #include  
 #include "sock.h" 
 const char * books [] = {"Война и мир", 
 "Гордость и предубеждение", 
 "Звук и ярость"}; 
 
 недействительный отчет (const char * msg, int terminate) {
 perror (msg); 
 если (завершить) выход (-1); / * сбой * / 
} 
 
 int main () {
 / * fd для сокета * / 
 int sockfd = socket (AF_INET, / * по сравнению с AF_LOCAL * / 
 SOCK_STREAM, / * надежный, двунаправленный * / 
 0) ; / * система выбирает протокол (TCP) * / 
 if (sockfd <0) report ("socket", 1); / * terminate * / 
 
 / * получение адреса хоста * / 
 struct hostent * hptr = gethostbyname (Host); / * локальный: 127.0.0.1 * / 
 if (! Hptr) report ("gethostbyname", 1); / * hptr NULL? * / 
 if (hptr-> h_addrtype! = AF_INET) / * по сравнению с AF_LOCAL * / 
 report ("неверное семейство адресов", 1); 
 
 / * подключиться к серверу: настроить адрес сервера 1st * / 
 struct sockaddr_in saddr; 
 memset (& saddr, 0, sizeof (saddr)); 
 saddr. sin_family = AF_INET; 
 saddr.sin_addr.s_addr = 
 ((struct in_addr *) hptr-> h_addr_list [0]) -> s_addr; 
 saddr.sin_port = htons (номер порта); / * номер порта с прямым порядком байтов * / 
 
 if (connect (sockfd, (struct sockaddr *) & saddr, sizeof (saddr)) <0) 
 report ("connect", 1); 
 
 / * Напишите что-нибудь и прочтите эхо.* / 
 put ("Подключиться к серверу, собираюсь написать кое-что ..."); 
 int i; 
 for (i = 0; i  if (write (sockfd, books [i], strlen (books [i]))> 0) {
 / * получить подтверждение от сервера и распечатать * / 
 буфер символов [BuffSize + 1]; 
 memset (буфер, '\ 0', sizeof (буфер)); 
 if (read (sockfd, buffer, sizeof (buffer))> 0) 
 put (buffer); 
} 
} 
 put ("Клиент готов, выходит... "); 
 close (sockfd); / * закрываем соединение * / 
 return 0; 
} 
 

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

  if (connect (sockfd, (struct sockaddr *) & saddr, sizeof (saddr)) <0)  

Вызов connect может завершиться ошибкой по нескольким причинам; например, у клиента неправильный адрес сервера или слишком много клиентов уже подключено к серверу. Если операция connect завершается успешно, клиент записывает запросы, а затем считывает отраженные ответы в цикле для . После разговора и сервер, и клиент закрывают сокет чтения / записи, хотя операции закрытия с любой стороны достаточно, чтобы закрыть соединение. После этого клиент завершает работу, но, как отмечалось ранее, сервер остается открытым для работы.

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

Сигналы

Сигнал прерывает выполняющуюся программу и, в этом смысле, связывается с ней.Большинство сигналов можно либо игнорировать (блокировать), либо обрабатывать (с помощью назначенного кода), с двумя заметными исключениями SIGSTOP (пауза) и SIGKILL (немедленно завершить). Символьные константы, такие как SIGKILL , имеют целочисленные значения, в данном случае 9.

Сигналы могут возникать при взаимодействии с пользователем. Например, пользователь нажимает Ctrl + C из командной строки, чтобы завершить программу, запущенную из командной строки; Ctrl + C генерирует сигнал SIGTERM . SIGTERM для terminate , в отличие от SIGKILL , может быть либо заблокирован, либо обработан. Один процесс также может сигнализировать другому, тем самым превращая сигналы в механизм IPC.

Подумайте, как многопроцессорное приложение, такое как веб-сервер Nginx, может корректно завершаться другим процессом. kill функция:

  int kill (pid_t pid, int signum); / * декларация * /  

может использоваться одним процессом для завершения другого процесса или группы процессов.Если первый аргумент функции kill больше нуля, этот аргумент обрабатывается как pid (идентификатор процесса) целевого процесса; если аргумент равен нулю, аргумент идентифицирует группу процессов, к которым принадлежит отправитель сигнала.

Второй аргумент kill - это либо стандартный номер сигнала (например, SIGTERM или SIGKILL ), либо 0, что делает вызов сигнала запросом о том, действительно ли pid в первом аргументе действительный.Таким образом, плавное завершение работы многопроцессорного приложения может быть выполнено путем отправки сигнала terminate - вызова функции kill с SIGTERM в качестве второго аргумента - группе процессов, составляющих приложение. (Главный процесс Nginx может завершить рабочие процессы вызовом kill , а затем выйти из себя.) Функция kill , как и многие другие библиотечные функции, обладает мощью и гибкостью в простом синтаксисе вызова.

Пример 3. Изящное завершение работы многопроцессорной системы

 #include  
 #include  
 #include  
 #include  
 #include  
 void graceful (int signum) { 
 printf ("\ tChild, подтверждающий полученный сигнал:% i \ n", signum); 
 put ("\ tChild собирается завершить работу ..."); 
 сон (1); 
 put ("\ tChild сейчас завершается ..."); 
 _exit (0); / * быстрое уведомление родителя * / 
} 
 
 void set_handler () {
 struct sigaction current; 
 sigemptyset (& current.sa_mask); / * очищаем набор сигналов * / 
 current.sa_flags = 0; / * разрешает установку sa_handler, а не sa_action * / 
 current.sa_handler = graceful; / * указываем обработчик * / 
 sigaction (SIGTERM, & current, NULL); / * регистрируем обработчик * / 
} 
 
 void child_code () {
 set_handler (); 
 
 while (1) {/ ** цикл до прерывания ** / 
 sleep (1); 
 put ("\ t Ребенок только что проснулся, но снова засыпает. "); 
} 
} 
 
 void parent_code (pid_t cpid) {
 put ("Родитель спит какое-то время... "); 
 sleep (5); 
 
 / * Попытка завершить дочерний элемент. * / 
 if (-1 == kill (cpid, SIGTERM)) {
 perror (" kill "); 
 exit (-1 ); 
} 
 wait (NULL); / ** ждать завершения дочернего процесса ** / 
 put ("Мой дочерний элемент завершен, я собираюсь выйти из себя ..."); 
} 
 
 int main () {
 pid_t pid = fork (); 
 if (pid <0) {
 perror ("fork"); 
 return -1; / * ошибка * / 
} 
 if (0 == pid) 
 child_code (); 
 else 
 parent_code (pid); 
 return 0; / * нормальный * / 
} 
 

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

• Родительский процесс пытается разветвить дочерний процесс. Если вилка завершается успешно, каждый процесс выполняет свой собственный код: дочерний процесс выполняет функцию child_code , а родительский элемент выполняет функцию parent_code .
• Дочерний процесс входит в потенциально бесконечный цикл, в котором дочерний процесс на секунду спит, печатает сообщение, возвращается в режим сна и так далее. Именно сигнал SIGTERM от родителя заставляет потомок выполнять функцию обратного вызова обработки сигнала graceful .Таким образом, сигнал прерывает дочерний процесс из его цикла и устанавливает плавное завершение как дочернего, так и родительского процессов. Ребенок печатает сообщение перед завершением.
• Родительский процесс после разветвления дочернего процесса засыпает на пять секунд, чтобы потомок мог некоторое время выполняться; конечно, ребенок в основном спит в этой симуляции. Затем родительский объект вызывает функцию kill с SIGTERM в качестве второго аргумента, ожидает завершения дочернего процесса и затем завершает работу.

Вот результат пробного запуска:

 
% ./shutdown 
 Родитель спит какое-то время ... 
 Ребенок только что проснулся, но снова засыпает. 
 Ребенок только что проснулся, но снова засыпает. 
 Ребенок только что проснулся, но снова засыпает. 
 Ребенок только что проснулся, но снова засыпает. 
 Дочерний объект, подтверждающий получение сигнала: 15 ## SIGTERM is 15 
 Дочерний объект собирается корректно завершить работу ... 
 Дочерний объект завершается сейчас... 
 Мой ребенок умер, собираюсь уйти ... 
 

Для обработки сигналов в примере используется функция библиотеки sigaction (рекомендуется POSIX), а не устаревшая функция signal , которая имеет проблемы с переносимостью. Вот наиболее интересные сегменты кода:

• Если вызов fork завершается успешно, родительский элемент выполняет функцию parent_code , а дочерний элемент выполняет функцию child_code . Родитель ждет пять секунд, прежде чем подать сигнал ребенку:

   put ("Родитель спит какое-то время... "); 
  
  сон (5); 
   если (-1 == kill (cpid, SIGTERM)) {
  
  ... 

  Если вызов kill завершается успешно, родитель выполняет ожидания при завершении дочернего процесса, чтобы предотвратить превращение ребенка в постоянного зомби; после ожидания родитель выходит.
• Функция child_code сначала вызывает set_handler , а затем переходит в свой потенциально бесконечный цикл ожидания. Вот функция set_handler для обзора:

   
   void set_handler () {
   struct sigaction current; / * текущая настройка * / 
   sigemptyset (& current.sa_mask); / * очищаем набор сигналов * / 
   current.sa_flags = 0; / * для установки sa_handler, а не sa_action * / 
   current.sa_handler = graceful; / * указываем обработчик * / 
   sigaction (SIGTERM, & current, NULL); / * регистрируем обработчик * / 
  } 
   

  Первые три строчки - подготовка. Четвертый оператор устанавливает в обработчике функцию graceful , которая печатает некоторые сообщения перед вызовом _exit для завершения. Пятый и последний оператор затем регистрирует обработчик в системе через вызов sigaction .Первым аргументом для sigaction является SIGTERM для terminate , вторым является текущая настройка sigaction , а последний аргумент ( NULL в данном случае) может использоваться для сохранения предыдущей настройки sigaction , возможно для дальнейшего использования.

Использование сигналов для IPC - действительно минималистский подход, но при этом уже проверенный. IPC через сигналы явно входит в набор инструментов IPC.

Завершение серии

В этих трех статьях по IPC на примерах кода рассмотрены следующие механизмы:

• Общие файлы
• Общая память (с семафорами)
• Трубы (названные и безымянные)
• Очереди сообщений
• Розетки
• Сигналы

Даже сегодня, когда языки, ориентированные на потоки, такие как Java, C # и Go, стали настолько популярными, IPC остается привлекательным, потому что параллелизм через многопроцессорность имеет очевидное преимущество перед многопоточностью: каждый процесс по умолчанию имеет свой собственный адресное пространство, которое исключает условия гонки на основе памяти при многопроцессорной обработке, если не задействован механизм IPC совместно используемой памяти. (Общая память должна быть заблокирована как для многопроцессорной, так и для многопоточной обработки для безопасного параллелизма.) Любой, кто написал хотя бы элементарную многопоточную программу с обменом данными через общие переменные, знает, насколько сложно написать потокобезопасный, но понятный, эффективный код. Многопроцессорная обработка с однопоточными процессами остается жизнеспособным - действительно, весьма привлекательным - способом использования преимуществ современных многопроцессорных машин без неотъемлемого риска состояний гонки на основе памяти.

Конечно, нет однозначного ответа на вопрос, какой из механизмов IPC является лучшим.Каждый из них предполагает компромисс, типичный для программирования: простота или функциональность. Например, сигналы - это относительно простой механизм IPC, но они не поддерживают полноценные диалоги между процессами. Если такое преобразование необходимо, то более подходящим вариантом будет один из других вариантов. Совместно используемые файлы с блокировкой довольно просты, но общие файлы могут не работать достаточно хорошо, если процессам необходимо совместно использовать большие потоки данных; каналы или даже сокеты с более сложными API-интерфейсами могут быть лучшим выбором. Пусть ваша проблема будет руководить выбором.

Хотя пример кода (доступен на моем веб-сайте) полностью написан на C, другие языки программирования часто предоставляют тонкие оболочки для этих механизмов IPC. Я надеюсь, что примеры кода короткие и достаточно простые, чтобы побудить вас поэкспериментировать.

Экземпляры этого класса являются потокобезопасными.

404 - Не найдено - Hilti USA