Разница между двоичным семафором и мьютексом

Ответ 1

Они НЕ то же самое. Они используются для разных целей!
Хотя оба типа семафоров имеют полное/пустое состояние и используют один и тот же API, их использование очень отличается.

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

Семафор Mutex "принадлежит" выполняемой им задачей. Если задание B пытается сгенерировать мьютекс, находящийся в настоящее время в задаче A, вызов B вызовет ошибку и завершится с ошибкой.

Мьютексы всегда используют следующую последовательность:

  - SemTake
  - Critical Section
  - SemGive

Вот простой пример:

  Thread A                     Thread B
   Take Mutex
     access data
     ...                        Take Mutex  <== Will block
     ...
   Give Mutex                     access data  <== Unblocks
                                  ...
                                Give Mutex

Двоичный семафор
Двоичный Семафор обращается к совершенно другому вопросу:

• Задание B задерживается, ожидая чего-то (например, сбой датчика).
• Проводятся расчеты датчиков и процедура обслуживания прерываний. Он должен уведомлять о задаче поездки.
• Задача B должна выполняться и предпринимать соответствующие действия для отключения датчика. Затем вернитесь к ожиданию.

   Task A                      Task B
   ...                         Take BinSemaphore   <== wait for something
   Do Something Noteworthy
   Give BinSemaphore           do something    <== unblocks

Обратите внимание, что с двоичным семафором ОК для того, чтобы B взял семафор и A, чтобы дать ему.
Опять же, двоичный семафор НЕ защищает ресурс от доступа. Акт сдачи и принятия семафора принципиально развязан.
Как правило, для одной и той же задачи мало смысла, так что дайте и возьмите один и тот же двоичный семафор.

Ответ 2

Пример туалета - это приятная аналогия:

мьютекса:

Является ключом к туалету. Один человек может иметь ключ - занимать туалет - на время. Когда закончите, человек дает (освобождает) ключ к следующему человека в очереди.

Официально: "Мьютексы, как правило, используется для сериализации доступа к разделу кода повторного входа, который не может быть выполняемые одновременно более чем одним нить. Объект mutex позволяет только один нить в контролируемый участок, принуждение других потоков, которые пытаются получить доступ к этому разделу, чтобы подождать пока первая нить не выйдет из этот раздел." Ссылка: Symbian Developer Библиотека

(Мьютекс - действительно семафор с значение 1.)

Семафор:

Является ли количество свободных идентичных туалетов ключи. Например, скажем, у нас есть четыре туалеты с одинаковыми замками и ключами. Семафорный счет - счет keys - устанавливается в начале 4 (все четыре туалета являются бесплатными), то счет значение уменьшается, поскольку люди входя. Если все туалеты полны, то есть. свободных ключей не осталось, семафор равен 0. Теперь, когда уравнение один человек выходит из туалета, семафор увеличен до 1 (один свободный ключ) и передается следующему лицу в очередь.

Официально: "Семафор ограничивает количество одновременных пользователей общий ресурс до максимума номер. Темы могут запрашивать доступ к ресурс (уменьшение семафор), и может сигнализировать, что они закончили использование ресурса (увеличивая семафор). Ref: Библиотека разработчиков Symbian

Ответ 3

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

В Windows двоичные семафоры больше похожи на объекты событий, чем мьютексы.

Ответ 4

Хорошие статьи по теме:

• MUTEX VS. СЕМАФОРЫ - ЧАСТЬ 1: СЕМАФОРЫ
• MUTEX VS. SEMAPHORES - ЧАСТЬ 2: MUTEX
• MUTEX VS. СЕМАФОРЫ - ЧАСТЬ 3 (ЗАКЛЮЧИТЕЛЬНАЯ ЧАСТЬ): ПРОБЛЕМЫ ВЗАИМНОГО ИСКЛЮЧЕНИЯ

Из части 2:

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

Ответ 5

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

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

Семафор является сигнальным механизмом ("Я закончил, вы можете продолжить"). Например, если вы слушаете песни (считаете, что это одно задание) на своем мобильном телефоне, и в то же время ваш друг звонил вам, будет запущено прерывание, при котором подпрограмма обработки прерываний (ISR) будет сигнализировать о пробуждении задачи обработки вызова.,

Источник: http://www.geeksforgeeks.org/mutex-vs-semaphore/

Ответ 6

Их семантика синхронизации очень различна:

• мьютексы позволяют сериализовать доступ к данному ресурсу, т.е. несколько потоков ждут блокировки, по одному за раз и, как сказано ранее, поток владеет блокировкой до тех пор, пока она не будет выполнена: только этот конкретный поток может разблокировать его.
• двоичный семафор - это счетчик со значением 0 и 1: задача блокирует его, пока любая задача не выполняет sem_post. Семафор сообщает, что ресурс доступен, и он обеспечивает механизм ожидания, пока он не будет объявлен как доступный.

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

Ответ 7

• Mutex по определению используется для сериализации доступа к фрагменту кода re -entrant, который не может быть выполнен одновременно более чем одним потоком.

• Семафор по определению ограничивает количество одновременных пользователей общего ресурса до максимального числа

• Семафор может быть Mutex, но Mutex никогда не может быть семафором. Это просто означает, что двоичный семафор может использоваться как Mutex, но Mutex никогда не может демонстрировать функциональность семафора.

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

• В случае Mutex, поток, которому принадлежит Mutex, ответственен за его освобождение. Однако в случае семафоров это условие не требуется. Любой другой поток может подать сигнал на освобождение семафора с помощью smps (function.e_ot)

• Другое различие, которое имело бы значение для разработчиков, состоит в том, что семафоры являются системными и остаются в форме файлов в файловой системе, если не очищены иным образом. Mutex распространяется на весь процесс и автоматически очищается при выходе из процесса.

• Природа семафоров позволяет использовать их при синхронизации связанных и несвязанных процессов, а также между потоками. Mutex может использоваться только для синхронизации между потоками и, самое большее, между связанными процессами (реализация pthread последнего ядра поставляется с функцией, позволяющей использовать Mutex между связанными процессами).
• Согласно документации ядра, Mutex легче по сравнению с семафорами. Это означает, что программа с использованием семафора имеет больший объем памяти по сравнению с программой, имеющей Mutex.
• С точки зрения использования, Mutex имеет более простую семантику по сравнению с семафорами.

Ответ 8

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

Практическая разница (с точки зрения системных сервисов, связанных с ними) заключается в том, что реализация мьютекса направлена ​​на то, чтобы быть более легким механизмом синхронизации. В оракуле говорят, что мьютексы называются защелки, а семафоры известны как waits.

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

Типичная реализация мьютекса имеет процесс или поток, выполняющий инструкцию test-and-set и оценивающую, установил ли что-нибудь еще мьютекс. Ключевым моментом здесь является отсутствие взаимодействия с планировщиком поэтому мы понятия не имеем (и не заботимся), который установил блокировку, Затем мы либо отказываемся от нашего временного фрагмента, и снова пытаемся его снова, когда задача перепланируется или выполняем spin-lock. Блокировка спина представляет собой алгоритм, подобный:

Count down from 5000:
     i. Execute the test-and-set instruction
    ii. If the mutex is clear, we have acquired it in the previous instruction 
        so we can exit the loop
   iii. When we get to zero, give up our time slice.

Когда мы закончили выполнение нашего защищенного кода (известный как критический раздел), мы просто установили значение mutex равным нулю или что-то другое означает "clear". Если несколько задач пытаются получить мьютекс, следующая задача, которая будет запланирована после выхода мьютекса, получит доступ к ресурсу. Как правило, вы должны использовать мьютексы для управления синхронизированным ресурсом, где эксклюзивный доступ требуется только в течение очень коротких периодов времени, обычно для обновления общей структуры данных.

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

Основной алгоритм семафора выглядит следующим образом:

(somewhere in the program startup)
Initialise the semaphore to its start-up value.

Acquiring a semaphore
   i. (synchronised) Attempt to decrement the semaphore value
  ii. If the value would be less than zero, put the task on the tail of the list of tasks waiting on the semaphore and give up the time slice.

Posting a semaphore
   i. (synchronised) Increment the semaphore value
  ii. If the value is greater or equal to the amount requested in the post at the front of the queue, take that task off the queue and make it runnable.  
 iii. Repeat (ii) for all tasks until the posted value is exhausted or there are no more tasks waiting.

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

EDIT: Как справедливо указал Эван, спин-блокировки замедляют работу одного процессора. Вы бы использовали только спин-блокировку на многопроцессорном ящике, потому что на одном процессоре процесс, содержащий мьютекс, никогда не будет reset, пока выполняется другая задача. Spinlocks полезны только для многопроцессорных архитектур.

Ответ 9

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

Ответ 10

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

1. Замок
2. Используйте критический раздел
3. отпереть

Двоичный семафор: работает на основе сигнала ожидания и сигнала. wait (s) уменьшает значение "s" на единицу, обычно значение "s" инициализируется значением "1", сигнал увеличивает значение "s" на единицу. если значение "s" равно 1, значит, никто не использует критическую секцию, когда значение равно 0, означает, что критическая секция используется. Предположим, что поток T2 использует критическую секцию, затем следует следующие шаги. T2:

1. wait (s)//изначально значение s равно единице после вызова wait это значение уменьшилось на единицу, т.е. 0
2. Использовать критический раздел
3. signal (s)//теперь значение s увеличивается и становится 1

Основное различие между Mutex и двоичным семафором заключается в Mutext, если поток блокирует критическую секцию, тогда он должен разблокировать критическую секцию, никакой другой поток не может разблокировать его, но в случае двоичного семафора, если один поток блокирует критическую секцию, используя функцию wait (s), тогда значение из s становится "0", и никто не может получить к нему доступ, пока значение "s" не станет 1, но предположим, что какой-то другой поток вызывает сигнал (ы), а затем значение "s" становится 1, и это позволяет другой функции использовать критическую секцию следовательно, в двоичном семафорном потоке нет владения.

Ответ 11

В Windows существуют два различия между мьютексами и двоичными семафорами:

• Мьютекс может быть выпущен только потоком, который имеет право собственности, т.е. поток, который ранее назывался функцией Wait (или который владел при создании). Семафор может быть выпущен любым потоком.

• Нить может неоднократно вызывать функцию ожидания на мьютексе без блокировки. Однако, если вы дважды вызываете функцию ожидания в двоичном семафоре, не отпуская между ними семафор, поток будет блокироваться.

Ответ 12

Вы, очевидно, используете мьютекс для блокировки данных в одном потоке, к которому обращается другой поток одновременно. Предположим, что вы только что вызвали lock() и в процессе доступа к данным. Это означает, что вы не ожидаете, что какой-либо другой поток (или другой экземпляр того же потока-кода) получит доступ к тем же данным, которые заблокированы одним и тем же мьютексом. То есть, если это один и тот же код потока, выполняемый в другом экземпляре потока, попадает в блокировку, тогда lock() должен блокировать поток управления там. Это относится к потоку, который использует другой поток-код, который также обращается к тем же данным и который также заблокирован одним и тем же мьютексом. В этом случае вы все еще находитесь в процессе доступа к данным, и вы можете использовать, скажем, еще 15 секунд, чтобы достичь разблокировки мьютекса (так что другой поток, который блокируется в блокировке мьютекса, будет разблокирован и позволит элементу управления доступ к данным). Вы любой ценой разрешаете еще одному потоку просто разблокировать один и тот же мьютекс и, в свою очередь, разрешить поток, который уже ждет (блокирование) в блокировке мьютекса, чтобы разблокировать и получить доступ к данным? Надеюсь, вы получили то, что я говорю здесь? В соответствии с универсальным определением!,

• с "мьютексом" это не может произойти. Ни одна другая нить не может разблокировать блокировку в вашей теме
• с "двоичным семафором" это может случиться. Любой другой поток может разблокировать блокировка в вашей ветке

Итак, если вы очень подробно относитесь к использованию двоичного семафора вместо мьютекса, тогда вы должны быть очень осторожны в "просмотре" блокировок и разблокировок. Я имею в виду, что каждый поток управления, который попадает в каждую блокировку, должен ударять по разблокированному вызову, также не должно быть "первой разблокировки", а должно быть всегда "первой блокировкой".

Ответ 13

Мьютекс используется для "Блокирующих механизмов". один процесс за раз может использовать общий ресурс

тогда

Семафоры используются для "Сигнализационных механизмов" как "Я закончил, теперь можно продолжать"

Ответ 14

Миф:

Пара статей гласит, что "двоичный семафор и мьютексы такие же" или "Семафор со значением 1 - это мьютекс", но основное отличие заключается в том, что Mutex может быть выпущен только потоком, который его приобрел, тогда как вы можете сигнализировать семафор от любого другого нить

Ключевые моменты:

• Нить может приобретать более одного замка (Mutex).

• Мьютекс можно заблокировать более одного раза, только если его рекурсивный мьютекс, здесь блокировка и разблокировка для мьютекса должны быть одинаковыми

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

• Двоичный семафор и мьютекс похожи, но не одинаковы.

• Mutex является дорогостоящей операцией из-за связанных с ней протоколов защиты.

• Основная цель мьютекса - добиться доступа атома или блокировки ресурса

Ответ 15

Mutex контролирует доступ к одному совместно используемому ресурсу. Он предоставляет операции для получения() доступа к этому ресурсу и освобождения() после его завершения.

Семафор управляет доступом к общему пулу ресурсов. Он предоставляет операции Wait(), пока один из ресурсов в пуле не станет доступен, и Signal(), когда он будет возвращен в пул.

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

Таким образом, Семафор представляет собой абстракцию более высокого уровня, чем Mutex. Мьютекс можно реализовать с помощью Семафора, но не наоборот.

Ответ 16

Мьютекс работает над блокировкой критической области, но Семафор работает с подсчетом.

Ответ 17

Модифицированный вопрос: в чем разница между мьютексом A и "двоичным" семафором в "Linux"?

Ans: Ниже приведены различия - i) Область действия - объем мьютекса находится в адресном пространстве процесса, которое его создало и используется для синхронизации потоков. В то время как семафор может использоваться в пространстве процессов и, следовательно, может использоваться для межпроцессной синхронизации.

ii) Мьютекс легкий и быстрый, чем семафор. Futex еще быстрее.

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

Ответ 18

Разница между двоичным семафором и мьютексом: ВЛАДЕНИЕ: Семафоры могут сигнализироваться (отправляться) даже от не текущего владельца. Это означает, что вы можете просто публиковать сообщения из любого другого потока, хотя вы не являетесь его владельцем.

Семафор - это государственная собственность в процессе, она может быть просто отправлена ​​потоком не владельца. Пожалуйста, отметьте это различие буквами BOLD, это много значит.

Ответ 19

http://www.geeksforgeeks.org/archives/9102 подробно обсуждается.

Mutex - механизм блокировки, используемый для синхронизации доступа к ресурсу. Semaphore является сигнальным механизмом.

Это до программиста, если он хочет использовать бинарный семафор вместо мьютекса.

Ответ 20

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

Ответ 21

В окнах разница следующая. Процесс MUTEX:, который успешно выполняет wait, должен выполнить сигнал и наоборот. BINARY SEMAPHORES: Различные процессы могут выполнять операцию wait или signal на семафоре.

Ответ 22

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

Когда мы пытаемся дать семафор, не беря его, он проходит. Но когда вы пытаетесь дать мьютекс, не беря его, это не получается. Я проверил это на платформе Windows. Разрешите USE_MUTEX для запуска того же кода, используя MUTEX.

#include <stdio.h>
#include <windows.h>
#define xUSE_MUTEX 1
#define MAX_SEM_COUNT 1

DWORD WINAPI Thread_no_1( LPVOID lpParam );
DWORD WINAPI Thread_no_2( LPVOID lpParam );

HANDLE Handle_Of_Thread_1 = 0;
HANDLE Handle_Of_Thread_2 = 0;
int Data_Of_Thread_1 = 1;
int Data_Of_Thread_2 = 2;
HANDLE ghMutex = NULL;
HANDLE ghSemaphore = NULL;


int main(void)
{

#ifdef USE_MUTEX
    ghMutex = CreateMutex( NULL, FALSE, NULL);
    if (ghMutex  == NULL) 
    {
        printf("CreateMutex error: %d\n", GetLastError());
        return 1;
    }
#else
    // Create a semaphore with initial and max counts of MAX_SEM_COUNT
    ghSemaphore = CreateSemaphore(NULL,MAX_SEM_COUNT,MAX_SEM_COUNT,NULL);
    if (ghSemaphore == NULL) 
    {
        printf("CreateSemaphore error: %d\n", GetLastError());
        return 1;
    }
#endif
    // Create thread 1.
    Handle_Of_Thread_1 = CreateThread( NULL, 0,Thread_no_1, &Data_Of_Thread_1, 0, NULL);  
    if ( Handle_Of_Thread_1 == NULL)
    {
        printf("Create first thread problem \n");
        return 1;
    }

    /* sleep for 5 seconds **/
    Sleep(5 * 1000);

    /*Create thread 2 */
    Handle_Of_Thread_2 = CreateThread( NULL, 0,Thread_no_2, &Data_Of_Thread_2, 0, NULL);  
    if ( Handle_Of_Thread_2 == NULL)
    {
        printf("Create second thread problem \n");
        return 1;
    }

    // Sleep for 20 seconds
    Sleep(20 * 1000);

    printf("Out of the program \n");
    return 0;
}


int my_critical_section_code(HANDLE thread_handle)
{

#ifdef USE_MUTEX
    if(thread_handle == Handle_Of_Thread_1)
    {
        /* get the lock */
        WaitForSingleObject(ghMutex, INFINITE);
        printf("Thread 1 holding the mutex \n");
    }
#else
    /* get the semaphore */
    if(thread_handle == Handle_Of_Thread_1)
    {
        WaitForSingleObject(ghSemaphore, INFINITE);
        printf("Thread 1 holding semaphore \n");
    }
#endif

    if(thread_handle == Handle_Of_Thread_1)
    {
        /* sleep for 10 seconds */
        Sleep(10 * 1000);
#ifdef USE_MUTEX
        printf("Thread 1 about to release mutex \n");
#else
        printf("Thread 1 about to release semaphore \n");
#endif
    }
    else
    {
        /* sleep for 3 secconds */
        Sleep(3 * 1000);
    }

#ifdef USE_MUTEX
    /* release the lock*/
    if(!ReleaseMutex(ghMutex))
    {
        printf("Release Mutex error in thread %d: error # %d\n", (thread_handle == Handle_Of_Thread_1 ? 1:2),GetLastError());
    }
#else
    if (!ReleaseSemaphore(ghSemaphore,1,NULL) )      
    {
        printf("ReleaseSemaphore error in thread %d: error # %d\n",(thread_handle == Handle_Of_Thread_1 ? 1:2), GetLastError());
    }
#endif

    return 0;
}

DWORD WINAPI Thread_no_1( LPVOID lpParam ) 
{ 
    my_critical_section_code(Handle_Of_Thread_1);
    return 0;
}


DWORD WINAPI Thread_no_2( LPVOID lpParam ) 
{
    my_critical_section_code(Handle_Of_Thread_2);
    return 0;
}

Тот факт, что семафор позволяет вам сигнализировать "это сделано с использованием ресурса", даже если он никогда не владел этим ресурсом, заставляет меня думать, что в случае семафоров существует очень слабая связь между владением и передачей сигналов.

Ответ 23

Различия между двоичным семафором и мьютексом:

Mutex используется исключительно для взаимного исключения. Как взаимное исключение, так и синхронизация могут использоваться двоичным. Задача, использующая мьютекс, может давать только мьютекс. Из ISR нельзя использовать мьютекс. Возможно рекурсивное взятие семафоров взаимного исключения. Это означает, что задача, которая выполняется перед окончательным выпуском семафора, может принимать семафор более одного раза. Параметры для выполнения задачи, которые принимают как DELETE_SAFE, предоставляются Mutex, что означает, что удаление задачи невозможно при удержании мьютекса.

Ответ 24

Существует двусмысленность между двоичным семафором и мьютексом. Мы могли бы столкнуться с тем, что мьютексом является двоичный семафор. Но это не так! Цель мьютекса и семафора различна. Возможно, из-за сходства в их реализации мьютекс будет называться двоичным семафором.

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

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

Ответ 25

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

• Случайное освобождение
• Рекурсивный тупик
• Задача Смертельный тупик

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

например. вы можете включить атрибут проверки ошибок в вашем мьютексе. Ошибка проверки мьютексов возвращает EDEADLK, если вы попытаетесь заблокировать один и тот же дважды и EPERM, если вы разблокируете мьютекс, который не принадлежит вам.

pthread_mutex_t mutex;
pthread_mutexattr_t attr;
pthread_mutexattr_init (&attr);
pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ERRORCHECK_NP);
pthread_mutex_init (&mutex, &attr);

После инициализации мы можем поместить эти проверки в наш код следующим образом:

if(pthread_mutex_unlock(&mutex)==EPERM)
 printf("Unlock failed:Mutex not owned by this thread\n");

Ответ 26

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

Ответ 27

Mutex

Мьютексы обычно используются для сериализации доступа к разделу повторно входящего кода, который не может выполняться одновременно более чем одним потоком. Объект мьютекса позволяет только одному потоку в управляемый раздел, заставляя другие потоки, которые пытаются получить доступ к этому разделу, ждать, пока первый поток не выйдет из этого раздела. Правильное использование мьютекса для защиты общего ресурса может быть опасным непреднамеренный побочный эффект. Любые две задачи RTOS, которые работают с разными приоритетами и координируются через мьютекс, создают возможность для инверсии приоритетов. Mutex работает в пространстве пользователя.

семафор

Семафор - это сигнальный механизм. Семафор ограничивает количество одновременных пользователей общего ресурса до максимального количества. Потоки могут запрашивать доступ к ресурсу (уменьшая семафор) и могут сигнализировать, что они закончили использование ресурса (увеличивая семафор). Он позволяет нескольким потокам получать доступ к совместно используемым ресурсам. Правильное использование семафора предназначено для передачи сигналов от одной задачи к другой. Семафоры также могут использоваться для передачи сигналов от подпрограммы обработки прерываний (ISR) к задаче. Сигнализация семафора является неблокирующим поведением RTOS и, следовательно, безопасна для ISR. Поскольку этот метод устраняет склонность к ошибкам, необходимо отключать прерывания на уровне задач. Это работает в пространстве ядра.

Ответ 28

Ответ может зависеть от целевой ОС. Например, по крайней мере одна реализация RTOS, с которой я знаком, позволит несколько последовательных операций "получить" против одного мьютекса операционной системы, если они все из одного и того же контекста потока. Множественные get должны быть заменены равным количеством пометок, прежде чем другой поток будет разрешен для получения мьютекса. Это отличается от двоичных семафоров, для которых допускается только один доступ за раз, независимо от контекстов потоков.

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

{
    mutexGet();  // Other threads can no longer get the mutex.

    // Make changes to the protected object.
    // ...

    objectModify();  // Also gets/puts the mutex.  Only allowed from this thread context.

    // Make more changes to the protected object.
    // ...

    mutexPut();  // Finally allows other threads to get the mutex.
}

Конечно, при использовании этой функции вы должны быть уверены, что все обращения в одном потоке действительно безопасны!

Я не уверен, насколько распространен этот подход, или применяется ли он за пределами систем, с которыми я знаком. Пример такого мьютекса см. В RTOS ThreadX.

Ответ 29

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

Ответ 30

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

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