Mga Synchronizer: Pag-synchronize ng Access sa Mga Mapagkukunan sa Java

Semaphore

Karaniwang ginagamit ang mga semaphore kapag kinakailangan upang limitahan ang bilang ng mga thread kapag nagtatrabaho sa file system. Ang pag-access sa isang file o iba pang nakabahaging mapagkukunan ay kinokontrol sa pamamagitan ng isang counter. Kung ang halaga nito ay mas malaki kaysa sa zero, pinapayagan ang pag-access, ngunit sa parehong oras ay bababa ang counter.

Sa sandaling ang counter ay nagbabalik ng zero, ang kasalukuyang thread ay iba-block hanggang sa ang mapagkukunan ay inilabas ng isa pang thread. Ang bilang ng mga parameter ng pahintulot ay dapat itakda sa pamamagitan ng constructor.

Kailangan mong piliin ang parameter na ito nang paisa-isa, depende sa kapangyarihan ng iyong computer o laptop.

public class Main {

   public static void main(String[] args) {
       Semaphore sem = new Semaphore(1);
       CommonResource res = new CommonResource();
       new Thread(new MyThread(res, sem, "MyThread_1")).start();
       new Thread(new MyThread(res, sem, "MyThread_2")).start();
       new Thread(new MyThread(res, sem, "MyThread_3")).start();
   }
}

class CommonResource {
   int value = 0;
}

class MyThread implements Runnable {
   CommonResource commonResource;
   Semaphore semaphore;
   String name;
   MyThread(CommonResource commonResource, Semaphore sem, String name) {
       this.commonResource = commonResource;
       this.semaphore = sem;
       this.name = name;
   }

   public void run() {

       try {
           System.out.println(name + "waiting permission");
           semaphore.acquire();
           commonResource.value = 1;
           for (int i = 1; i < 7; i++) {
               System.out.println(this.name + ": " + commonResource.value);
               commonResource.value++;
               Thread.sleep(150);
           }
       } catch (InterruptedException e) {
           System.out.println(e.getMessage() + " " + name);
           Thread.currentThread().interrupt();
       }
       System.out.println(name + "releases permission");
       semaphore.release();
   }
}

CountDownLatch at iba pa

CountDownLatch - Nagbibigay-daan sa maramihang mga thread na maghintay hanggang sa makumpleto ang isang tiyak na bilang ng mga operasyong isinagawa sa ibang mga thread. Ang isang halimbawa ay ang pag-install ng isang application: hindi ito magsisimula hanggang sa tanggapin mo ang mga tuntunin ng paggamit, hanggang sa pumili ka ng folder kung saan mag-i-install ng bagong program, at iba pa. Mayroong isang espesyal na paraan ng countDown() para dito - binabawasan ng pamamaraang ito ang count down counter ng isa.

Sa sandaling mapunta sa zero ang bilang, ang lahat ng naghihintay na thread sa paghihintay ay magpapatuloy sa kanilang trabaho, at lahat ng kasunod na tawag ng paghihintay ay lilipas nang hindi naghihintay. Ang count down counter ay isang beses na counter at hindi maaaring i-reset.

CyclicBarrier - ginagamit upang i-synchronize ang isang naibigay na bilang ng mga thread sa isang punto. Naabot ang hadlang kapag tinawag ng N thread ang await(...) method at block. Pagkatapos nito, ire-reset ang counter sa orihinal nitong halaga, at ilalabas ang naghihintay na mga thread. Bukod pa rito, kung kinakailangan, posibleng magpatakbo ng custom na code bago i-unblock ang mga thread at i-reset ang counter. Upang gawin ito, ang isang bagay na may pagpapatupad ng Runnable interface ay ipinapasa sa constructor .

Exchanger<V> — ang klase ng Exchanger ay inilaan para sa pagpapalitan ng data sa pagitan ng mga thread. Ito ay tina-type at itina-type ang uri ng data na kailangang palitan ng mga thread.

Ang data ay ipinagpapalit gamit ang tanging exchange() na paraan ng klase na ito :

V exchange(V x) throws InterruptedException
V exchange(V x, long timeout, TimeUnit unit) throws InterruptedException, TimeoutException

Ang x parameter ay kumakatawan sa data buffer na ipapalit. Tinutukoy din ng pangalawang anyo ng pamamaraan ang parameter ng timeout , ang timeout, at unit , ang uri ng unit ng oras na gagamitin para sa parameter ng timeout .

Binibigyang-daan ka ng klase ng Phaser na i-synchronize ang mga thread na kumakatawan sa isang yugto o yugto sa pagsasagawa ng isang pangkalahatang aksyon. Tinutukoy ng Phaser ang isang bagay sa pag-synchronize na naghihintay hanggang sa makumpleto ang isang tiyak na yugto. Ang Phaser pagkatapos ay lilipat sa susunod na yugto o yugto at hihintayin itong makumpleto muli.

Kapag nagtatrabaho sa klase ng Phaser , karaniwan na unang likhain ang object nito. Susunod, kailangan nating irehistro ang lahat ng mga kalahok. Upang magparehistro para sa bawat kalahok, ang register() na pamamaraan ay tinatawag na , o magagawa mo nang wala ang pamamaraang ito sa pamamagitan ng pagpasa ng kinakailangang bilang ng mga kalahok sa Phaser constructor .

Pagkatapos ang bawat kalahok ay nagsasagawa ng isang tiyak na hanay ng mga aksyon na bumubuo sa yugto. At ang Phaser synchronizer ay naghihintay hanggang ang lahat ng mga kalahok ay makumpleto ang pagpapatupad ng yugto. Upang ipaalam sa synchronizer na natapos na ang yugto, dapat tawagan ng kalahok ang arrive() o arriveAndAwaitAdvance() na paraan . Ang synchronizer pagkatapos ay lumipat sa susunod na yugto.