Perbedaan antara semaphore biner dan mutex

Apakah ada perbedaan antara semaphore biner dan mutex atau mereka pada dasarnya sama?

Mereka BUKAN hal yang sama. Mereka digunakan untuk berbagai tujuan!
Sementara kedua jenis semaphore memiliki keadaan penuh / kosong dan menggunakan API yang sama, penggunaannya sangat berbeda.

Semaphores Pengecualian Mutual Semaphores Pengecualian
Mutual digunakan untuk melindungi sumber daya bersama (struktur data, file, dll.).

Semafor Mutex "dimiliki" oleh tugas yang mengambilnya. Jika Tugas B mencoba untuk memberikan mutasi mutex yang saat ini dipegang oleh Tugas A, panggilan Tugas B akan mengembalikan kesalahan dan gagal.

Mutex selalu menggunakan urutan berikut:

  - Semtake
  - Bagian penting
  - SemGive

Ini adalah contoh sederhana:

  Utas A Utas B
   Ambil Mutex
     mengakses data
     ... Ambil Mutex <== Akan diblokir
     ...
   Berikan data akses Mutex <== Buka blokir
                                  ...
                                Berikan Mutex

Binary Semaphore
Binary Semaphore menjawab pertanyaan yang sangat berbeda:

• Tugas B sedang menunggu menunggu sesuatu terjadi (misalnya sensor sedang tersandung).
• Trip Sensor dan Interupsi Layanan Rutin berjalan. Perlu memberi tahu tugas perjalanan.
• Tugas B harus dijalankan dan mengambil tindakan yang sesuai untuk trip sensor. Kemudian kembali untuk menunggu.

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

Perhatikan bahwa dengan semaphore biner, tidak apa-apa bagi B untuk mengambil semaphore dan A untuk memberikannya.
Sekali lagi, semaphore biner TIDAK melindungi sumber daya dari akses. Tindakan Memberi dan Mengambil semafor secara fundamental dipisahkan.
Biasanya tidak masuk akal untuk tugas yang sama untuk memberi dan menerima semaphore biner yang sama.

• Sebuah mutex bisa dilepaskan hanya dengan benang yang telah diperoleh itu .
  
• Sebuah semaphore biner dapat mengisyaratkan oleh benang (atau proses).

jadi semaphore lebih cocok untuk beberapa masalah sinkronisasi seperti produsen-konsumen.

Pada Windows, semaphore biner lebih seperti objek acara daripada mutex.

Contoh Toilet adalah analogi yang menyenangkan:

Mutex:

Merupakan kunci toilet. Satu orang dapat memiliki kunci - menempati toilet - pada saat itu. Setelah selesai, orang tersebut memberikan (membebaskan) kunci ke orang berikutnya dalam antrian.

Secara resmi: "Mutex biasanya digunakan untuk membuat serial akses ke bagian dari kode peserta ulang yang tidak dapat dieksekusi secara bersamaan oleh lebih dari satu utas. Objek muteks hanya memungkinkan satu utas ke dalam bagian yang dikontrol, memaksa utas lain yang berupaya mendapatkan akses ke bagian itu untuk menunggu sampai utas pertama telah keluar dari bagian itu. " Ref: Perpustakaan Pengembang Symbian

(Mutex benar-benar semaphore dengan nilai 1.)

Tiang sinyal:

Apakah jumlah kunci toilet identik gratis. Contoh, misalkan kita memiliki empat toilet dengan kunci dan kunci yang identik. Hitungan semaphore - hitungan kunci - diatur ke 4 di awal (keempat toilet gratis), maka nilai hitungan dikurangi ketika orang masuk. Jika semua toilet penuh, yaitu. tidak ada kunci gratis yang tersisa, jumlah semaphore adalah 0. Sekarang, ketika eq. satu orang meninggalkan toilet, semaphore dinaikkan menjadi 1 (satu kunci gratis), dan diberikan kepada orang berikutnya dalam antrian.

Secara resmi: "Semafor membatasi jumlah pengguna simultan sumber daya bersama hingga jumlah maksimum. Utas dapat meminta akses ke sumber daya (mengurangi semafor), dan dapat memberi sinyal bahwa mereka telah selesai menggunakan sumber daya (menambah semafor). " Ref: Perpustakaan Pengembang Symbian

Artikel bagus tentang topik ini:

• MUTEX VS. SEMAFOR - BAGIAN 1: SEMAFOR
• MUTEX VS. SEMAPHOR - BAGIAN 2: MUTEX
• MUTEX VS. SEMAPHOR - BAGIAN 3 (BAGIAN AKHIR): MASALAH PENGECUALIAN MUTUAL

Dari bagian 2:

Mutex ini mirip dengan prinsip-prinsip biner semaphore dengan satu perbedaan signifikan: prinsip kepemilikan. Kepemilikan adalah konsep sederhana bahwa ketika suatu tugas mengunci (memperoleh) sebuah mutex hanya ia dapat membuka (melepaskan) itu. Jika suatu tugas mencoba membuka kunci mutex yang belum dikunci (maka tidak dimiliki sendiri) maka terjadi kesalahan dan, yang paling penting, mutex tidak terbuka. Jika objek pengecualian bersama tidak memiliki kepemilikan, maka tidak relevan dengan apa yang disebutnya, itu bukan mutex.

Karena tidak ada jawaban di atas yang menghilangkan kebingungan, berikut adalah salah satu yang membersihkan kebingungan saya.

Sebenarnya, mutex adalah mekanisme penguncian yang digunakan untuk menyinkronkan akses ke sumber daya. Hanya satu tugas (dapat berupa utas atau proses berdasarkan abstraksi OS) yang dapat memperoleh mutex. Ini berarti akan ada kepemilikan yang terkait dengan mutex, dan hanya pemilik yang dapat melepaskan kunci (mutex).

Semaphore adalah mekanisme pensinyalan ("Saya sudah selesai, Anda bisa melanjutkan" semacam sinyal). Misalnya, jika Anda mendengarkan lagu (menganggapnya sebagai satu tugas) di ponsel Anda dan pada saat yang sama teman Anda memanggil Anda, interupsi akan dipicu ketika interrupt service routine (ISR) akan memberi sinyal tugas pemrosesan panggilan untuk bangun. .

Sumber: http://www.geeksforgeeks.org/mutex-vs-semaphore/

Semantik sinkronisasi mereka sangat berbeda:

• mutex memungkinkan serialisasi akses ke sumber daya yang diberikan yaitu beberapa utas menunggu kunci, satu per satu dan seperti yang dikatakan sebelumnya, utas memiliki kunci sampai selesai: hanya utas khusus ini yang dapat membuka kunci.
• semaphore biner adalah penghitung dengan nilai 0 dan 1: tugas yang memblokirnya sampai tugas apa pun melakukan sem_post. Semaphore mengiklankan bahwa sumber daya tersedia, dan menyediakan mekanisme untuk menunggu sampai diberi sinyal sebagai tersedia.

Dengan demikian orang dapat melihat mutex sebagai token yang diteruskan dari satu tugas ke tugas lain dan semafor sebagai lampu merah lalu lintas (ini memberi sinyal seseorang bahwa ia dapat melanjutkan).

Pada tingkat teoretis, mereka tidak berbeda secara semantik. Anda dapat menerapkan mutex menggunakan semaphores atau sebaliknya (lihat di sini untuk contoh). Dalam praktiknya, implementasinya berbeda dan mereka menawarkan layanan yang sedikit berbeda.

Perbedaan praktis (dalam hal layanan sistem di sekitarnya) adalah bahwa penerapan mutex ditujukan untuk menjadi mekanisme sinkronisasi yang lebih ringan. Dalam bahasa oracle, mutex dikenal sebagai kait dan semaphore dikenal sebagai menunggu .

Pada level terendah, mereka menggunakan semacam uji atom dan mekanisme pengaturan . Ini membaca nilai saat ini dari lokasi memori, menghitung semacam persyaratan dan menulis nilai di lokasi itu dalam satu instruksi yang tidak dapat diinterupsi . Ini berarti Anda dapat memperoleh mutex dan menguji untuk melihat apakah ada orang lain yang memilikinya sebelum Anda.

Implementasi mutex yang khas memiliki proses atau utas yang melaksanakan instruksi tes dan set dan mengevaluasi apakah ada hal lain yang telah mengatur mutex. Poin kunci di sini adalah bahwa tidak ada interaksi dengan penjadwal , jadi kami tidak tahu (dan tidak peduli) siapa yang telah mengatur kunci. Kemudian kita menyerah irisan waktu kita dan mencobanya lagi ketika tugas dijadwalkan ulang atau menjalankan spin-lock . Spin lock adalah algoritme seperti:

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.

Ketika kami telah selesai menjalankan kode kami yang dilindungi (dikenal sebagai bagian kritis ) kami hanya menetapkan nilai mutex ke nol atau apa pun artinya 'jelas.' Jika beberapa tugas berusaha untuk mendapatkan mutex, tugas berikutnya yang dijadwalkan setelah mutex dilepaskan akan mendapatkan akses ke sumber daya. Biasanya Anda akan menggunakan mutex untuk mengontrol sumber daya yang disinkronkan di mana akses eksklusif hanya diperlukan untuk waktu yang sangat singkat, biasanya untuk membuat pembaruan ke struktur data bersama.

Semaphore adalah struktur data yang disinkronkan (biasanya menggunakan mutex) yang memiliki hitungan dan beberapa pembungkus panggilan sistem yang berinteraksi dengan scheduler sedikit lebih dalam daripada perpustakaan mutex. Semafor bertambah dan dikurangi dan digunakan untuk memblokir tugas sampai hal lain siap. Lihat Masalah Produsen / Konsumen untuk contoh sederhana ini. Semaphore diinisialisasi ke beberapa nilai - semaphore biner hanyalah kasus khusus di mana semaphore diinisialisasi ke 1. Posting ke semaphore memiliki efek membangunkan proses menunggu.

Algoritma semaphore dasar terlihat seperti:

(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.

Dalam kasus semaphore biner, perbedaan praktis utama antara keduanya adalah sifat layanan sistem yang mengelilingi struktur data aktual.

EDIT: Seperti yang ditunjukkan oleh evan dengan benar, spinlocks akan memperlambat mesin prosesor tunggal. Anda hanya akan menggunakan spinlock pada kotak multi-prosesor karena pada satu prosesor proses memegang mutex tidak akan mengatur ulang saat tugas lain sedang berjalan. Spinlocks hanya berguna pada arsitektur multi-prosesor.

Meskipun mutex & semaphore digunakan sebagai primitif sinkronisasi, ada perbedaan besar di antara mereka. Dalam hal mutex, hanya utas yang mengunci atau mendapatkan mutex yang dapat membukanya. Dalam kasus semaphore, utas yang menunggu semafor dapat ditandai oleh utas yang berbeda. Beberapa sistem operasi mendukung penggunaan mutex & semaphores antar proses. Biasanya penggunaan dibuat di memori bersama.

Mutex: Misalkan kita memiliki utas bagian kritis T1 ingin mengaksesnya lalu mengikuti langkah-langkah di bawah ini. T1:

1. Mengunci
2. Gunakan Bagian Kritis
3. Membuka kunci

Binary semaphore: Ini bekerja berdasarkan signalling wait dan signal. tunggu, turunkan nilai "s" satu per satu biasanya nilai "s" diinisialisasi dengan nilai "1", sinyal meningkatkan nilai "s" satu per satu. jika nilai "s" adalah 1 berarti tidak ada yang menggunakan bagian kritis, ketika nilai 0 berarti bagian kritis digunakan. misalkan utas T2 menggunakan bagian kritis lalu mengikuti langkah-langkah di bawah ini. T2:

1. tunggu // nilai awalnya adalah satu setelah memanggil tunggu nilainya berkurang satu yaitu 0
2. Gunakan bagian kritis
3. signal // sekarang nilainya dinaikkan dan menjadi 1

Perbedaan utama antara Mutex dan Binary semaphore adalah Mutext jika thread mengunci bagian kritis maka harus membuka bagian kritis tidak ada thread lain yang bisa membukanya, tetapi dalam kasus Binary semaphore jika salah satu thread mengunci bagian kritis menggunakan fungsi menunggu maka nilai dari s menjadi "0" dan tidak ada yang dapat mengaksesnya sampai nilai "s" menjadi 1 tetapi anggaplah beberapa sinyal panggilan lain maka nilai "s" menjadi 1 dan memungkinkan fungsi lain untuk menggunakan bagian kritis. karenanya dalam semaphore Biner thread tidak memiliki kepemilikan.

Pada Windows, ada dua perbedaan antara mutex dan semaphore biner:

1. Mutex hanya dapat dirilis oleh utas yang memiliki kepemilikan, yaitu utas yang sebelumnya disebut fungsi Tunggu, (atau yang mengambil kepemilikan saat membuatnya). Semaphore dapat dirilis oleh utas apa pun.

2. Utas dapat memanggil fungsi tunggu berulang kali pada mutex tanpa memblokir. Namun, jika Anda memanggil fungsi tunggu dua kali pada semaphore biner tanpa melepaskan semaphore di antaranya, utas akan memblokir.

Anda jelas menggunakan mutex untuk mengunci data dalam satu utas yang diakses oleh utas lain pada saat yang sama. Asumsikan bahwa Anda baru saja menelepon lock()dan sedang dalam proses mengakses data. Ini berarti bahwa Anda tidak mengharapkan utas lainnya (atau contoh lain dari kode-utas yang sama) untuk mengakses data yang sama dikunci oleh mutex yang sama. Yaitu, jika itu adalah kode-thread yang sama dijalankan pada instance thread yang berbeda, tekan kunci, makalock()harus memblokir aliran kontrol di sana. Ini berlaku untuk utas yang menggunakan utas-kode berbeda, yang juga mengakses data yang sama dan yang juga dikunci oleh mutex yang sama. Dalam hal ini, Anda masih dalam proses mengakses data dan Anda dapat mengambil, katakanlah, 15 detik untuk mencapai pembukaan kunci mutex (sehingga utas lain yang diblokir di kunci mutex akan membuka blokir dan akan memungkinkan kontrol untuk akses data). Apakah Anda dengan biaya berapa pun membiarkan utas lain membuka kunci mutex yang sama, dan pada gilirannya, mengizinkan utas yang sudah menunggu (memblokir) dalam kunci mutex untuk membuka blokir dan mengakses data? Semoga Anda mengerti apa yang saya katakan di sini? Sesuai, disepakati definisi universal !,

• dengan "mutex" ini tidak bisa terjadi. Tidak ada utas lain yang dapat membuka kunci pada utas Anda
• dengan "binary-semaphore" ini bisa terjadi. Utas lainnya dapat membuka kunci di utas Anda

Jadi, jika Anda sangat khusus menggunakan binary-semaphore daripada mutex, maka Anda harus sangat berhati-hati dalam “pelingkupan” kunci dan pembatalannya. Maksud saya, setiap aliran kontrol yang mengenai setiap kunci harus mengenai panggilan pembuka, juga tidak boleh ada "pembukaan pertama", melainkan harus selalu "kunci pertama".

Mutex digunakan untuk "Mekanisme Penguncian". satu proses pada satu waktu dapat menggunakan sumber daya bersama

sedangkan

Semafor digunakan untuk "Mekanisme Pensinyalan" seperti "Saya selesai, sekarang dapat melanjutkan"

Mitos:

Beberapa artikel mengatakan bahwa "semaphore biner dan mutex sama" atau "Semaphore dengan nilai 1 adalah mutex" tetapi perbedaan dasarnya adalah Mutex hanya dapat dilepaskan oleh utas yang telah mengakuisisi, sementara Anda dapat memberi sinyal semafor dari utas lain

Poin-Poin Utama:

• Sebuah utas dapat memperoleh lebih dari satu kunci (Mutex).

• Sebuah mutex dapat dikunci lebih dari sekali hanya jika itu adalah mutex rekursif, di sini mengunci dan membuka kunci untuk mutex harus sama

• Jika utas yang sudah mengunci mutex, mencoba untuk mengunci mutex lagi, itu akan masuk ke dalam daftar tunggu mutex itu, yang mengakibatkan kebuntuan.

• Semaphore biner dan mutex serupa tetapi tidak sama.

• Mutex adalah operasi yang mahal karena protokol perlindungan yang terkait dengannya.

• Tujuan utama mutex adalah mencapai akses atom atau mengunci sumber daya

Sebuah mutex mengontrol akses ke sumber daya bersama tunggal. Ini memberikan operasi untuk memperoleh () akses ke sumber daya itu dan melepaskan () ketika selesai.

Sebuah Semaphore mengontrol akses ke kolam renang bersama sumber daya. Ini menyediakan operasi untuk Tunggu () sampai salah satu sumber daya di kumpulan tersedia, dan Sinyal () ketika diberikan kembali ke kumpulan.

Ketika jumlah sumber daya yang dilindungi Semaphore lebih besar dari 1, itu disebut Counting Semaphore . Ketika mengontrol satu sumber daya, itu disebut Boolean Semaphore . Semaphore boolean setara dengan mutex.

Jadi Semaphore adalah abstraksi level yang lebih tinggi daripada Mutex. Mutex dapat diimplementasikan menggunakan Semaphore tetapi tidak sebaliknya.

Pertanyaan yang dimodifikasi adalah - Apa perbedaan antara A mutex dan "binary" semaphore di "Linux"?

Jawab: Berikut adalah perbedaannya - i) Lingkup - Ruang lingkup mutex berada dalam ruang alamat proses yang telah membuatnya dan digunakan untuk sinkronisasi utas. Sedangkan semaphore dapat digunakan melintasi ruang proses dan karenanya dapat digunakan untuk sinkronisasi antarproses.

ii) Mutex lebih ringan dan lebih cepat dari semaphore. Futex bahkan lebih cepat.

iii) Mutex dapat diperoleh dengan utas yang sama berhasil beberapa kali dengan syarat harus melepaskannya beberapa kali. Utas lain yang mencoba mengakuisisi akan diblokir. Sedangkan dalam kasus semaphore jika proses yang sama mencoba untuk mendapatkannya kembali itu blok karena hanya dapat diperoleh satu kali.

Perbedaan antara Binary Semaphore dan Mutex: KEPEMILIKAN: Semaphores dapat diisyaratkan (diposting) bahkan dari pemilik yang tidak aktif. Ini berarti Anda cukup memposting dari utas lain, meskipun Anda bukan pemiliknya.

Semaphore adalah properti publik dalam proses, Ini dapat dengan mudah diposting oleh utas bukan pemilik. Harap Tandai perbedaan ini dalam huruf BOLD, ini sangat berarti.

Mutex bekerja pada pemblokiran wilayah kritis, Tapi Semaphore bekerja pada hitungan.

http://www.geeksforgeeks.org/archives/9102 membahas secara rinci.

Mutexadalah mekanisme penguncian yang digunakan untuk menyinkronkan akses ke sumber daya. Semaphoreadalah mekanisme pensinyalan.

Terserah programmer jika dia ingin menggunakan binary semaphore sebagai ganti mutex.

Terlepas dari kenyataan bahwa mutex memiliki pemilik, kedua objek dapat dioptimalkan untuk penggunaan yang berbeda. Mutex dirancang untuk diadakan hanya untuk waktu yang singkat; melanggar ini dapat menyebabkan kinerja yang buruk dan penjadwalan yang tidak adil. Misalnya, utas berjalan mungkin diizinkan untuk mendapatkan mutex, meskipun utas lain sudah diblokir di situ. Semafor dapat memberikan lebih banyak keadilan, atau keadilan dapat dipaksa menggunakan beberapa variabel kondisi.

Di windows perbedaannya adalah seperti di bawah ini. MUTEX: proses yang berhasil dijalankan menunggu harus mengeksekusi sinyal dan sebaliknya. SEMINFOR BINARY: Berbagai proses dapat menjalankan operasi menunggu atau memberi sinyal pada semaphore.

Sementara semaphore biner dapat digunakan sebagai mutex, mutex adalah use-case yang lebih spesifik, dalam hal itu hanya proses yang mengunci mutex yang seharusnya membuka kuncinya. Batasan kepemilikan ini memungkinkan untuk memberikan perlindungan terhadap:

• Pelepasan tak disengaja
• Kebuntuan Rekursif
• Deadlock Tugas Kematian

Kendala ini tidak selalu ada karena mereka menurunkan kecepatan. Selama pengembangan kode Anda, Anda dapat mengaktifkan pemeriksaan ini sementara.

mis. Anda dapat mengaktifkan atribut Pemeriksaan kesalahan di mutex Anda. Kesalahan memeriksa mutexes kembali EDEADLKjika Anda mencoba untuk mengunci yang sama dua kali danEPERM jika Anda membuka kunci mutex yang bukan milik Anda.

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);

Setelah diinisialisasi, kami dapat menempatkan cek ini dalam kode kami seperti ini:

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

Konsepnya jelas bagi saya setelah membahas posting di atas. Tapi ada beberapa pertanyaan yang tersisa. Jadi, saya menulis kode kecil ini.

Ketika kami mencoba memberikan semafor tanpa mengambilnya, ia berhasil melewatinya. Tetapi, ketika Anda mencoba memberikan mutex tanpa mengambilnya, itu gagal. Saya menguji ini pada platform Windows. Aktifkan USE_MUTEX untuk menjalankan kode yang sama menggunakan 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;
}

Fakta bahwa semaphore memungkinkan Anda memberi sinyal "itu dilakukan dengan menggunakan sumber daya", meskipun tidak pernah memiliki sumber daya, membuat saya berpikir ada hubungan yang sangat longgar antara memiliki dan memberi sinyal dalam kasus semafor.

Mutex digunakan untuk melindungi kode sensitif dan data, semaphore digunakan untuk sinkronisasi. Anda juga dapat memiliki penggunaan praktis dengan melindungi kode sensitif, tetapi mungkin ada risiko yang melepaskan perlindungan oleh utas lainnya dengan operasi V.Jadi, yang utama perbedaan antara bi-semaphore dan mutex adalah kepemilikan. Misalnya dengan toilet, Mutex seperti itu orang bisa masuk toilet dan mengunci pintu, tidak ada orang lain yang bisa masuk sampai pria itu keluar, bi-semaphore seperti itu yang bisa masuk toilet dan mengunci pintu, tetapi orang lain bisa masuk dengan meminta administrator untuk membuka pintu, itu konyol.

Mutex

Mutex biasanya digunakan untuk membuat serialisasi akses ke bagian kode re-entrant yang tidak dapat dieksekusi secara bersamaan oleh lebih dari satu utas. Objek mutex hanya memungkinkan satu utas masuk ke bagian yang dikontrol, memaksa utas lain yang berupaya mendapatkan akses ke bagian itu untuk menunggu sampai utas pertama keluar dari bagian itu. Penggunaan yang benar dari mutex adalah untuk melindungi sumber daya bersama yang dapat memiliki bahaya. efek samping yang tidak diinginkan. Dua tugas RTOS yang beroperasi pada prioritas yang berbeda dan berkoordinasi melalui mutex, menciptakan peluang untuk inversi prioritas . Mutex bekerja di ruang pengguna .

Tiang sinyal

Semaphore adalah mekanisme pensinyalan. Semaphore membatasi jumlah pengguna simultan dari sumber daya bersama hingga jumlah maksimum. Thread dapat meminta akses ke sumber daya (menurunkan semaphore) dan dapat memberi sinyal bahwa mereka telah selesai menggunakan sumber daya (incrementing the semaphore). Ini memungkinkan sejumlah utas untuk mengakses sumber daya bersama. Penggunaan semafor yang benar adalah untuk pensinyalan dari satu tugas ke tugas lainnya. Memori juga dapat digunakan untuk memberi sinyal dari interrupt service routine (ISR) ke suatu tugas. Signaling semaphore adalah perilaku RTOS yang tidak menghalangi dan dengan demikian ISR aman. Karena teknik ini menghilangkan kebutuhan yang rawan kesalahan untuk menonaktifkan interupsi pada tingkat tugas. Ini bekerja di ruang kernel .

Jawabannya mungkin tergantung pada OS target. Sebagai contoh, setidaknya satu implementasi RTOS yang saya kenal akan memungkinkan beberapa operasi "get" berurutan terhadap satu OS mutex, asalkan semuanya dari dalam konteks utas yang sama. Beberapa get harus diganti dengan jumlah put yang sama sebelum thread lain diizinkan untuk mendapatkan mutex. Ini berbeda dari semaphore biner, yang hanya dapat satu kali diizinkan pada satu waktu, terlepas dari konteks utas.

Gagasan di balik jenis mutex ini adalah bahwa Anda melindungi objek dengan hanya mengizinkan satu konteks untuk memodifikasi data pada suatu waktu. Bahkan jika utas mendapatkan mutex dan kemudian memanggil fungsi yang lebih lanjut memodifikasi objek (dan mendapat / menempatkan pelindung mutex di sekitar operasinya sendiri), operasi harus tetap aman karena semuanya terjadi di bawah utas tunggal.

{
    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.
}

Tentu saja, ketika menggunakan fitur ini, Anda harus yakin bahwa semua akses dalam satu utas benar-benar aman!

Saya tidak yakin seberapa umum pendekatan ini, atau apakah itu berlaku di luar sistem yang saya kenal. Untuk contoh mutex semacam ini, lihat ThreadX RTOS.

Mutex memiliki kepemilikan, tidak seperti semaphore. Meskipun setiap utas, dalam lingkup mutex, bisa mendapatkan mutex yang tidak dikunci dan mengunci akses ke bagian kode yang sama, hanya utas yang mengunci mutex yang akan membukanya .

Seperti yang telah disebutkan oleh banyak orang di sini, sebuah mutex digunakan untuk melindungi bagian penting dari kode (bagian kritis AKA.) Anda akan memperoleh mutex (kunci), memasuki bagian kritis, dan melepaskan mutex (membuka) semua di utas yang sama .

Saat menggunakan semaphore, Anda dapat membuat utas menunggu di semafor (katakan utas A), hingga utas lainnya (misalkan utas B) menyelesaikan tugas apa pun, lalu setel Semafor untuk utas A untuk menghentikan penantian, dan melanjutkan tugasnya.

Solusi terbaik

Satu-satunya perbedaan adalah

1.Mutex -> mengunci dan membuka kunci berada di bawah kepemilikan utas yang mengunci mutex.

2.Semaphore -> Tanpa kepemilikan yaitu; jika satu utas panggilan sedang menunggu utas lainnya dapat memanggil sempost untuk menghapus kunci.

MUTEX

Sampai saat ini, satu-satunya kunci tidur di kernel adalah semaphore. Sebagian besar pengguna semaphore membuat semaphore dengan hitungan satu dan memperlakukan mereka sebagai kunci pengecualian bersama - versi tidur dari kunci-kunci. Sayangnya, semaphore agak generik dan tidak memaksakan batasan penggunaan. Ini membuatnya berguna untuk mengelola akses eksklusif dalam situasi yang tidak jelas, seperti tarian rumit antara kernel dan ruang pengguna. Tetapi itu juga berarti bahwa penguncian yang lebih sederhana lebih sulit untuk dilakukan, dan kurangnya aturan yang ditegakkan membuat segala jenis debugging otomatis atau penegakan kendala menjadi tidak mungkin. Mencari kunci tidur yang lebih sederhana, pengembang kernel memperkenalkan mutex. Ya, seperti yang biasa Anda lakukan, itu adalah nama yang membingungkan. Mari kita perjelas. Istilah “mutex” adalah nama generik untuk merujuk pada kunci tidur apa pun yang memberlakukan saling pengecualian, seperti semaphore dengan hitungan penggunaan satu. Dalam kernel Linux baru-baru ini, kata benda yang tepat "mutex" sekarang juga merupakan jenis kunci penguncian khusus yang menerapkan saling pengecualian. Artinya, mutex adalah mutex.

Kesederhanaan dan efisiensi dari mutex berasal dari kendala tambahan yang dikenakan pada penggunanya melebihi dan melebihi apa yang semafor butuhkan. Tidak seperti semaphore, yang menerapkan perilaku paling dasar sesuai dengan desain asli Dijkstra, mutex memiliki kasus penggunaan yang lebih ketat, lebih sempit: n Hanya satu tugas yang dapat menahan mutex pada suatu waktu. Artinya, jumlah penggunaan pada mutex selalu satu.

1. Siapa pun yang mengunci mutex harus membukanya. Artinya, Anda tidak dapat mengunci mutex dalam satu konteks dan kemudian membukanya di lain. Ini berarti bahwa mutex tidak cocok untuk sinkronisasi yang lebih rumit antara kernel dan ruang pengguna. Namun, sebagian besar kasus penggunaan, mengunci dan membuka kunci dengan rapi dari konteks yang sama.
2. Kunci rekursi dan buka kunci tidak diizinkan. Artinya, Anda tidak bisa secara rekursif mendapatkan mutex yang sama, dan Anda tidak bisa membuka kunci mutex yang tidak terkunci.
3. Suatu proses tidak dapat keluar saat memegang mutex.
4. Mutex tidak dapat diperoleh oleh pengendali interupsi atau setengah bagian bawah, bahkan dengan mutex_trylock ().
5. Mutex hanya dapat dikelola melalui API resmi: Mutual harus diinisialisasi melalui metode yang dijelaskan dalam bagian ini dan tidak dapat disalin, diinisialisasi dengan tangan, atau diinisialisasi ulang.

[1] Pengembangan Kernel Linux, Edisi Ketiga Robert Love

Saya pikir sebagian besar jawaban di sini membingungkan terutama yang mengatakan bahwa mutex dapat dirilis hanya oleh proses yang menahannya tetapi semaphore dapat ditandai oleh proses. Baris di atas agak kabur dalam hal semafor. Untuk memahami kita harus tahu bahwa ada dua jenis semaphore satu disebut berhitung semaphore dan yang lainnya disebut binary semaphore. Dalam penghitungan semaphore menangani akses ke n jumlah sumber daya di mana n dapat didefinisikan sebelum penggunaan. Setiap semaphore memiliki variabel jumlah, yang menjaga jumlah jumlah sumber daya yang digunakan, awalnya, diatur ke n. Setiap proses yang ingin menggunakan sumber daya melakukan operasi menunggu () pada semaphore (dengan demikian mengurangi jumlah). Ketika suatu proses melepaskan sumber daya, ia melakukan operasi rilis () (menambah jumlah). Saat hitungan menjadi 0, semua sumber daya digunakan. Setelah itu, proses menunggu hingga hitungan menjadi lebih dari 0. Sekarang di sini adalah tangkapan hanya proses yang memegang sumber daya dapat meningkatkan jumlah tidak ada proses lain dapat meningkatkan jumlah hanya proses memegang sumber daya dapat meningkatkan jumlah dan proses menunggu semaphore lagi memeriksa dan ketika melihat sumber daya yang tersedia itu mengurangi jumlah lagi. Jadi dalam hal binary semaphore, hanya proses memegang semaphore yang dapat meningkatkan jumlah, dan penghitungan tetap nol sampai berhenti menggunakan semaphore dan meningkatkan jumlah dan proses lainnya mendapat kesempatan untuk mengakses semaphore. Sekarang di sini adalah tangkapan hanya proses yang memegang sumber daya dapat meningkatkan jumlah tidak ada proses lain dapat meningkatkan jumlah hanya proses memegang sumber daya dapat meningkatkan jumlah dan proses menunggu semaphore memeriksa lagi dan ketika melihat sumber daya tersedia itu mengurangi hitungan lagi. Jadi dalam hal binary semaphore, hanya proses memegang semaphore yang dapat meningkatkan jumlah, dan penghitungan tetap nol sampai berhenti menggunakan semaphore dan meningkatkan jumlah dan proses lainnya mendapat kesempatan untuk mengakses semaphore. Sekarang di sini adalah tangkapan hanya proses yang memegang sumber daya dapat meningkatkan jumlah tidak ada proses lain dapat meningkatkan jumlah hanya proses memegang sumber daya dapat meningkatkan jumlah dan proses menunggu semaphore memeriksa lagi dan ketika melihat sumber daya tersedia itu mengurangi hitungan lagi. Jadi dalam hal binary semaphore, hanya proses memegang semaphore yang dapat meningkatkan jumlah, dan penghitungan tetap nol sampai berhenti menggunakan semaphore dan meningkatkan jumlah dan proses lainnya mendapat kesempatan untuk mengakses semaphore.

Perbedaan utama antara semaphore biner dan mutex adalah bahwa semaphore adalah mekanisme pensinyalan dan mutex adalah mekanisme penguncian, tetapi semaphore biner tampaknya berfungsi seperti mutex yang menciptakan kebingungan, tetapi keduanya adalah konsep yang berbeda yang cocok untuk berbagai jenis pekerjaan.