Synchronizers: ஜாவாவில் உள்ள வளங்களுக்கான அணுகலை ஒத்திசைத்தல்

செமாஃபோர்

கோப்பு முறைமையுடன் பணிபுரியும் போது நூல்களின் எண்ணிக்கையை குறைக்க வேண்டியிருக்கும் போது செமாஃபோர்கள் பொதுவாகப் பயன்படுத்தப்படுகின்றன. கோப்பு அல்லது பிற பகிரப்பட்ட ஆதாரங்களுக்கான அணுகல் கவுண்டர் மூலம் கட்டுப்படுத்தப்படுகிறது. அதன் மதிப்பு பூஜ்ஜியத்தை விட அதிகமாக இருந்தால், அணுகல் அனுமதிக்கப்படுகிறது, ஆனால் அதே நேரத்தில் கவுண்டர் குறையும்.

கவுண்டர் பூஜ்ஜியத்தை வழங்கும் தருணத்தில், ஆதாரம் மற்றொரு நூலால் வெளியிடப்படும் வரை தற்போதைய தொடரிழை தடுக்கப்படும். அனுமதிகள் அளவுருவின் எண்ணிக்கையை கன்ஸ்ட்ரக்டர் மூலம் அமைக்க வேண்டும்.

உங்கள் கணினி அல்லது மடிக்கணினியின் சக்தியைப் பொறுத்து, இந்த அளவுருவை நீங்கள் தனித்தனியாக தேர்ந்தெடுக்க வேண்டும்.

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 - மற்ற த்ரெட்களில் செய்யப்படும் குறிப்பிட்ட எண்ணிக்கையிலான செயல்பாடுகள் முடிவடையும் வரை பல நூல்கள் காத்திருக்க அனுமதிக்கிறது. ஒரு பயன்பாட்டின் நிறுவல் ஒரு எடுத்துக்காட்டு: நீங்கள் பயன்பாட்டு விதிமுறைகளை ஏற்கும் வரை, புதிய நிரலை நிறுவ வேண்டிய கோப்புறையைத் தேர்ந்தெடுக்கும் வரை, அது தொடங்காது. இதற்கென ஒரு பிரத்யேக கவுண்ட்டவுன்() முறை உள்ளது- இந்த முறை கவுண்ட் டவுன் கவுண்டரை ஒவ்வொன்றாக குறைக்கிறது.

எண்ணிக்கை பூஜ்ஜியத்திற்குச் சென்றவுடன், காத்திருப்பில் உள்ள அனைத்து காத்திருப்பு இழைகளும் தங்கள் வேலையைத் தொடரும், மேலும் காத்திருக்கும் அனைத்து அடுத்தடுத்த அழைப்புகளும் காத்திருக்காமல் கடந்து செல்லும். கவுண்ட் டவுன் கவுண்டர் ஒரு முறை கவுண்டர் என்பதால் மீட்டமைக்க முடியாது.

CyclicBarrier - ஒரு புள்ளியில் கொடுக்கப்பட்ட நூல்களின் எண்ணிக்கையை ஒத்திசைக்கப் பயன்படுகிறது. N இழைகள் காத்திருக்கும்(...) முறை மற்றும் தடுப்பை அழைக்கும் போது தடையை அடைகிறது. அதன் பிறகு, கவுண்டர் அதன் அசல் மதிப்பிற்கு மீட்டமைக்கப்படுகிறது, மேலும் காத்திருக்கும் நூல்கள் வெளியிடப்படும். கூடுதலாக, தேவைப்பட்டால், த்ரெட்களை அவிழ்த்துவிட்டு கவுண்டரை மீட்டமைக்கும் முன் தனிப்பயன் குறியீட்டை இயக்க முடியும். இதைச் செய்ய, இயக்கக்கூடிய இடைமுகத்தை செயல்படுத்தும் ஒரு பொருள்.

எக்ஸ்சேஞ்சர்<V> — எக்ஸ்சேஞ்சர் கிளாஸ் த்ரெட்களுக்கு இடையில் தரவு பரிமாற்றத்திற்காக வடிவமைக்கப்பட்டுள்ளது. இது தட்டச்சு செய்யப்பட்டு, திரிகள் பரிமாறிக்கொள்ள வேண்டிய தரவின் வகையை டைப் செய்கிறது.

இந்த வகுப்பின் ஒரே பரிமாற்றம்() முறையைப் பயன்படுத்தி தரவு பரிமாற்றம் செய்யப்படுகிறது :

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

x அளவுரு பரிமாற்றம் செய்ய வேண்டிய தரவு இடையகத்தைக் குறிக்கிறது. முறையின் இரண்டாவது வடிவம், காலக்கெடு அளவுரு , காலக்கெடு மற்றும் அலகு , காலக்கெடு அளவுருவிற்குப் பயன்படுத்த வேண்டிய நேர அலகு வகை ஆகியவற்றை வரையறுக்கிறது .

ஒட்டுமொத்த செயலின் செயல்பாட்டின் ஒரு கட்டம் அல்லது கட்டத்தைக் குறிக்கும் இழைகளை ஒத்திசைக்க Phaser வகுப்பு உங்களை அனுமதிக்கிறது. ஒரு குறிப்பிட்ட கட்டம் முடியும் வரை காத்திருக்கும் ஒத்திசைவு பொருளை Phaser வரையறுக்கிறது. பேஸர் அடுத்த கட்டம் அல்லது கட்டத்திற்குச் சென்று, அது மீண்டும் முடிவடையும் வரை காத்திருக்கிறது .

பேசர் வகுப்பில் பணிபுரியும் போது , ​​முதலில் அதன் பொருளை உருவாக்குவது பொதுவானது. அடுத்து, அனைத்து பங்கேற்பாளர்களையும் பதிவு செய்ய வேண்டும். ஒவ்வொரு பங்கேற்பாளரையும் பதிவு செய்ய, பதிவு() முறை அழைக்கப்படுகிறது, அல்லது இந்த முறை இல்லாமல், தேவையான எண்ணிக்கையிலான பங்கேற்பாளர்களை Phaser கன்ஸ்ட்ரக்டருக்கு அனுப்புவதன் மூலம் நீங்கள் செய்யலாம் .

ஒவ்வொரு பங்கேற்பாளரும் கட்டத்தை உருவாக்கும் ஒரு குறிப்பிட்ட செயல்களைச் செய்கிறார்கள். மேலும் பங்கேற்பாளர்கள் அனைவரும் கட்டத்தை நிறைவேற்றும் வரை Phaser synchronizer காத்திருக்கிறது. கட்டம் முடிவடைந்ததை ஒத்திசைப்பாளருக்குத் தெரிவிக்க, பங்கேற்பாளர் வருகை() அல்லது வந்தடைதல்AndAwaitAdvance() முறையை அழைக்க வேண்டும் . சின்க்ரோனைசர் அடுத்த கட்டத்திற்கு செல்கிறது.