it-swarm-id.com

Perbedaan antara semaphore biner dan mutex

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

747
Nitin

Mereka BUKAN hal yang sama. Mereka digunakan untuk tujuan yang berbeda!
Meskipun kedua jenis semafor memiliki status penuh/kosong dan menggunakan API yang sama, penggunaannya sangat berbeda.

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

Semafor Mutex "dimiliki" oleh tugas yang membawanya. 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 Kritis 
 - SemGive

Ini adalah contoh sederhana:

 Thread A Thread B 
 Ambil Mutex 
 Data akses 
 ... Ambil Mutex <== Akan memblokir 
 ... .... ] 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.

641
Benoit

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 semafor dengan nilai 1.)

Tiang sinyal:

Apakah jumlah kunci toilet identik gratis. Contoh, misalkan kita punya empat toilet dengan kunci dan kunci 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

420
dlinsin

Mutex hanya dapat dirilis oleh utas yang telah mengakuisisi, sementara Anda dapat memberi sinyal semafor dari utas lain (atau proses), sehingga semafor lebih cocok untuk beberapa masalah sinkronisasi seperti produsen-konsumen.

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

413
Mladen Janković

Artikel bagus tentang topik ini:

Dari bagian 2:

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

140
teki

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 dapat 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 layanan interupsi rutin (ISR) akan memberi sinyal tugas pemrosesan panggilan untuk bangun .

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

93
Hemant

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 itu dilakukan: hanya utas khusus ini dapat membukanya.
  • biner semaphore adalah penghitung dengan nilai 0 dan 1: tugas memblokirnya sampai ada tugas 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 tugas ke tugas dan semafor sebagai lampu merah lalu lintas (itu sinyal seseorang yang dapat diproses).

37
ppi
  • A Mutex, menurut definisi, digunakan untuk membuat serialisasi akses ke bagian kode re-entrant yang tidak dapat dieksekusi secara bersamaan oleh lebih dari satu utas.

  • A Semaphore, menurut definisi, membatasi jumlah pengguna simultan sumber daya bersama hingga jumlah maksimum

  • Semaphore bisa menjadi Mutex tetapi Mutex tidak pernah bisa menjadi semaphore. Ini hanya berarti bahwa semaphore biner dapat digunakan sebagai Mutex, tetapi Mutex tidak pernah dapat menunjukkan fungsionalitas semaphore.

  • Semaphores dan Mutex (setidaknya pada kernel terbaru) bersifat non-rekursif.
  • Tidak ada yang memiliki semaphores, sedangkan Mutex dimiliki dan pemilik bertanggung jawab atas mereka. Ini adalah perbedaan penting dari perspektif debugging.
  • Dalam hal Mutex, utas yang memiliki Mutex bertanggung jawab untuk membebaskannya. Namun, dalam kasus semaphores, kondisi ini tidak diperlukan. Utas lainnya dapat memberi sinyal untuk membebaskan semafor dengan menggunakan s mp s (function.e_ot)

  • Perbedaan lain yang penting bagi pengembang adalah bahwa semafor adalah sistem yang luas dan tetap dalam bentuk file pada sistem file, kecuali jika tidak dibersihkan. Mutex adalah seluruh proses dan dibersihkan secara otomatis ketika proses keluar.

  • Sifat semaphore memungkinkan untuk menggunakannya dalam menyinkronkan proses terkait dan tidak terkait, serta di antara utas. Mutex hanya dapat digunakan dalam sinkronisasi antara utas dan paling banyak di antara proses terkait (implementasi pthread dari kernel terbaru dilengkapi dengan fitur yang memungkinkan Mutex untuk digunakan antara proses terkait).
  • Menurut dokumentasi kernel, Mutex lebih ringan jika dibandingkan dengan semaphores. Ini berarti bahwa suatu program dengan penggunaan semaphore memiliki jejak memori yang lebih tinggi jika dibandingkan dengan program yang memiliki Mutex.
  • Dari perspektif penggunaan, Mutex memiliki semantik yang lebih sederhana jika dibandingkan dengan semaphores.
36
Varun Chhangani

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 Oracle-speak, mutex dikenal sebagai kait dan semaphores dikenal sebagai menungg .

Pada level terendah, mereka menggunakan semacam atom test and set mekanisme. 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 bahwa Anda dapat memperoleh mutex dan menguji untuk melihat apakah ada orang lain yang memilikinya sebelum Anda.

Implementasi mutex tipikal memiliki proses atau utas yang melaksanakan instruksi tes dan set dan mengevaluasi apakah ada hal lain yang telah mengatur mutex. Titik kunci di sini adalah bahwa tidak ada interaksi dengan scheduler , jadi kami tidak tahu (dan tidak peduli) 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 blok tugas sampai yang 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 dari 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 pernah menyetel 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.

18
Praveen_Shukla

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 maka ia mengikuti langkah-langkah di bawah ini. T2:

  1. wait (s) // awalnya nilai s adalah satu setelah memanggil tunggu nilainya berkurang satu i.e 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 kunci bagian kritis, tidak ada thread lain yang bisa membuka kunci itu, tetapi dalam kasus Binary semaphore jika 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.

12
Sumit Naik

Anda jelas menggunakan mutex untuk mengunci data di satu utas yang diakses oleh utas lain pada saat yang sama. Asumsikan bahwa Anda baru saja menelepon lock() dan dalam proses mengakses data. Ini berarti Anda tidak mengharapkan utas lainnya (atau contoh lain dari kode utas yang sama) untuk mengakses data yang sama dikunci oleh mutex yang sama. Artinya, jika kode-thread yang sama dijalankan pada instance thread yang berbeda, tekan kunci, maka lock() harus memblokir aliran kontrol di sana. Ini berlaku untuk utas yang menggunakan utas-kode yang 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 mengakses 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".

10
paxi

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"

10
Jamshad Ahmad

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

  1. Mutex hanya dapat dirilis oleh utas yang memiliki kepemilikan, mis. 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.

10
Rich

Mitos:

Beberapa artikel mengatakan bahwa "semaphore biner dan mutex sama" atau "Semaphore dengan nilai 1 adalah mutex" tetapi perbedaan dasarnya adalah Mutex dapat dilepaskan hanya oleh utas yang telah mendapatkannya, 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 satu kali hanya jika itu sebuah mutex rekursif, di sini kunci dan buka 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

9
Saurabh Sinha

A Mutex mengontrol akses ke satu sumber daya bersama. Ini menyediakan operasi untuk memperoleh () akses ke sumber daya itu dan rilis () ketika selesai.

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

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.

8
Charan

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

Jawab: Berikut ini perbedaannya - i) Ruang 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.

6
Mickey

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

6
Askkan

Perbedaan antara Binary Semaphore dan Mutex: KEPEMILIKAN: Semaphores dapat diisyaratkan (diposting) bahkan dari pemilik yang tidak lancar. Ini berarti Anda dapat 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.

5
buddingspacer

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

Mutex adalah mekanisme penguncian yang digunakan untuk menyinkronkan akses ke sumber daya. Semaphore adalah mekanisme pensinyalan.

Terserah programmer jika dia ingin menggunakan semaphore biner di tempat mutex.

5
user1852497

Di windows perbedaannya adalah seperti di bawah ini. MUTEX: proses yang berhasil dijalankan tungg harus mengeksekusi sinyal dan sebaliknya. BINARY SEMAPHORES: Proses yang berbeda dapat menjalankan tungg atau sinyal operasi pada semaphore.

4
ajay bidari

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.

4
jilles

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;
}
4
Raghav Navada

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 menurunkan kecepatan. Selama pengembangan kode Anda, Anda dapat mengaktifkan pemeriksaan ini sementara.

misalnya Anda dapat mengaktifkan atribut Pemeriksaan kesalahan di mutex Anda. Kesalahan memeriksa mutex mengembalikan EDEADLK jika Anda mencoba untuk mengunci yang sama dua kali dan EPERM 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");
3
Adi06411

Mutex digunakan untuk melindungi kode dan data sensitif, 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.

2
mannnnerd

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 harus = buka kunci itu .

1
laksbv

Mutex dan binary semaphore keduanya memiliki penggunaan yang sama, tetapi dalam kenyataannya, mereka berbeda.

Dalam hal mutex, hanya utas yang telah menguncinya yang dapat membukanya. Jika ada utas lain untuk menguncinya, ia akan menunggu.

Dalam hal semaphone, bukan itu masalahnya. Semaphore tidak terikat dengan ID utas tertentu.

1
Neeraj Sh

Jawabannya mungkin tergantung pada OS target. Sebagai contoh, setidaknya satu RTOS implementasi 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 utasnya.

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

1
Casey Barker

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), memasukkan 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, dan kemudian menetapkan Semafor untuk utas A untuk menghentikan penantian, dan melanjutkan tugasnya.

1
Dom045

"binary semaphore" adalah bahasa pemrograman yang digunakan untuk menggunakan "semaphore" seperti "mutex". Ternyata ada dua perbedaan yang sangat besar:

  1. Cara Anda memanggil mereka masing-masing.

  2. Panjang maksimum "pengidentifikasi".

0
ilias iliadis