Ano ang Semaphore sa Java at ang paggamit nito?



Ginagamit ang isang semaphore para sa pagsabay ng mga proseso. Dadalhin ka ng blog na ito sa iba't ibang uri at pagpapatupad ng mga semaphore sa java.

Isang Semaphore sa kinokontrol ang pag-access sa isang ibinahaging mapagkukunan sa pamamagitan ng isang counter. Ito ay isang pagsabay sa thread ginamit ang konstruksyon upang magpadala ng mga signal sa pagitan ng mga thread upang maiwasan ang mga hindi nasagot na signal o bantayan ang isang kritikal na seksyon. Sa blog na ito sa Semaphores sa Java, mauunawaan natin nang detalyado ang konsepto.
Ang mga sumusunod na paksa ay saklaw sa blog na ito:

Ano ang Semaphore sa Java?

Ang isang semaphore ay isang variable na ginamit para sa pagsabay ng mga proseso na ginagamit para sa pamamahala ng mga kasabay na proseso. Ginagamit din ito upang makontrol ang pag-access sa isang pangkaraniwang mapagkukunan ng maraming mga kasabay na proseso at maiwasan ang isang kalagayan sa lahi.





Mga uri ng semaphore -

  • Binary semaphore: Ang isang binary semaphore ay tumatagal lamang ng 0 at 1 bilang mga halaga at ginagamit upang ipatupad ang kapwa pagbubukod pati na rin ang pagsabayin ang mga kasabay na proseso.

  • Nagbibilang ng semaphore: Ang halaga ng isang pagbibilang semaphore sa anumang punto ay nagpapahiwatig ng maximum na bilang ng mga proseso na maaaring ipasok ang kritikal na seksyon sa eksaktong parehong oras.



Paggawa ng Semaphore

  • Kung bilang ng semaphore> 0, nakakakuha ang thread ng isang permiso, binabawasan ang bilang ng semaphore.

  • Iba pa, ang ay hinarangan hanggang sa ang isang permiso ay maaaring makuha.

    kabuuan ng mga digit ng isang numero sa java gamit ang para sa loop
  • Kapag hindi na nangangailangan ng access ang thread sa isang nakabahaging mapagkukunan, naglalabas ito ng permiso, na nagdaragdag ng bilang ng semaphore.



  • Kung ang ibang thread ay naghihintay para sa isang permiso, pagkatapos ang thread na iyon ay makakakuha ng isang permit sa oras na iyon.

Pagpapatupad ng Semaphore

i-import ang java.util.concurrent. * // Dadalhin ang Resource bilang shared class class Resource {static int count = 0} class MyDemo extends Demo {Semaphore sem String threadName public MyDemo (Semaphore sem, String threadName) {super (threadName) na ito. sem = sem this.threadName = threadName} @Override public void run () {// Run By X if (this.getName (). equals ('X')) {System.out.println ('Simula' + threadName) subukan ang {// Makakakuha ng permiso upang ma-access ang nakabahaging mapagkukunan System.out.println (threadName + 'naghihintay para sa isang permit.') // pagkuha ng lock sem.acquire () System.out.println (threadName + 'ay nakakakuha ng isang permit . ') // Ngayon, ang pag-access sa nakabahaging mapagkukunan at pahinga ay maghihintay para sa (int i = 0 i<7 i++) { Resource.count++ System.out.println(threadName + ': ' + Resouce.count) // Now thread Y will try to execute Thread.sleep(20) } } catch (InterruptedException exc) { System.out.println(exc) } // Release the permit. System.out.println(threadName + ' releases the permit.') sem.release() } // run by thread Y else { System.out.println('Starting ' + threadName) try { // First, Y will try to get permit System.out.println(threadName + ' waiting for a permit.') // acquiring the lock sem.acquire() System.out.println(threadName + ' gets a permit.') // Now, accessing the shared resource and others will wait for(int i=0 i < 7 i++) { Resource.count-- System.out.println(threadName + ': ' + Resource.count) // Now, allowing a context switch -- if possible. // for thread X to execute Thread.sleep(20) } } catch (InterruptedException exc) { System.out.println(exc) } // Release the permit. System.out.println(threadName + ' releases the permit.') sem.release() } } } public class SemTest { public static void main(String args[]) throws InterruptedException { // creating a Semaphore object // with number of permits 1 Semaphore sem = new Semaphore(1) // creating two threads with name X and Y // Here thread X will increment and Y will decrement the counter MyDemo md1 = new MyDemo(sem, 'X') MyDemo md2 = new MyDemo(sem, 'Y') // stating threads X and Y md1.start() md2.start() // waiting for threads X and Y md1.join() mtd.join() System.out.println('count: ' + Resource.count) } } 

Output-
Simula X
Simula Y
X naghihintay ng permiso
Naghihintay ako ng permit
X: 1
X: 2
X: 3
X: 4
X: 5
X: 6
X: 7
Naglabas ng permit si X
Kinukuha ni Y ang permit
Y: 6
Y: 5
Y: 4
Y: 3
Y: 2
Y: 1
Y: 0
At naglalabas ng permit
bilangin: 0

Sa pamamagitan nito, natapos namin ang blog na ito sa 'Semaphores in Java'. Kung nais mong malaman ang tungkol sa Java, tingnan ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online na may isang network na higit sa 250,000 nasiyahan na mga nag-aaral na kumalat sa buong mundo. Ang kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo para sa mga mag-aaral at propesyonal na nais na maging isang Java Developer. Ang kurso ay dinisenyo upang bigyan ka ng isang panimula sa pag-program ng Java at sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring.

May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng blog na 'Ano ang Semaphore sa Java' at babalikan ka namin sa lalong madaling panahon.