Java 8 Concurrency Tutorial జావా 8 కరెన్సీ ట్యుటోరియల్ పూర్తి వివరాలు

 ఏకకాలంలో బహుళ పనులు లేదా ప్రక్రియలను అమలు చేయగల కంప్యూటర్ సిస్టమ్ యొక్క సామర్ధ్యాన్ని కరెన్సీ అంటారు. జావా 8లో, థ్రెడ్‌లను ఉపయోగించడం ద్వారా సమ్మేళనం సాధించబడుతుంది, ఇవి ఒకే ప్రక్రియలో ఏకకాలంలో అమలు చేసే తేలికైన ఎగ్జిక్యూషన్ యూనిట్లు.

జావా 8 కరెన్సీపై ఇక్కడ ట్యుటోరియల్ ఉంది:

1. థ్రెడ్‌లను సృష్టించడం: రన్ చేయదగిన ఇంటర్‌ఫేస్‌ను అమలు చేయడం ద్వారా లేదా థ్రెడ్ క్లాస్‌ని పొడిగించడం ద్వారా జావాలో థ్రెడ్‌లను సృష్టించవచ్చు. రన్ చేయదగిన ఇంటర్‌ఫేస్‌ను అమలు చేయడానికి ఇక్కడ ఒక ఉదాహరణ:

టైపుస్క్రిప్ట్
public class MyRunnable implements Runnable {
   public void run() {
      // Code to be executed in this thread
   }
}

ఈ Runnableని అమలు చేసే థ్రెడ్‌ని సృష్టించడానికి మరియు ప్రారంభించడానికి, మీరు ఈ క్రింది వాటిని చేయవచ్చు:

జావా
Thread t = new Thread(new MyRunnable());
t.start();

2. సమకాలీకరణ: భాగస్వామ్య వనరు లేదా కోడ్ బ్లాక్‌ను ఒకేసారి ఒక థ్రెడ్ మాత్రమే యాక్సెస్ చేయగలదని నిర్ధారించడానికి జావాలో సింక్రొనైజేషన్ ఉపయోగించబడుతుంది. సమకాలీకరించబడిన బ్లాక్‌లు లేదా పద్ధతులను ఉపయోగించడం ద్వారా ఇది సాధించబడుతుంది. సమకాలీకరించబడిన బ్లాక్‌లను ఉపయోగించే ఉదాహరణ ఇక్కడ ఉంది:

టైపుస్క్రిప్ట్
public class MyObject {
   private int counter = 0;
   public void incrementCounter() {
      synchronized(this) {
         counter++;
      }
   }
}

ఈ ఉదాహరణలో, సమకాలీకరించబడిన బ్లాక్ ఒకేసారి ఒక థ్రెడ్ మాత్రమే ఇంక్రిమెంట్ కౌంటర్ () పద్ధతిని యాక్సెస్ చేయగలదని నిర్ధారిస్తుంది.

3. తాళాలు: జావాలో సమకాలీకరణను సాధించడానికి తాళాలు మరొక మార్గం. అవి సమకాలీకరించబడిన బ్లాక్‌లు లేదా పద్ధతుల కంటే సమకాలీకరణపై మరింత చక్కటి నియంత్రణను అనుమతిస్తాయి. తాళాలను ఉపయోగించడం యొక్క ఉదాహరణ ఇక్కడ ఉంది:

జావా
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyObject {
   private int counter = 0;
   private Lock lock = new ReentrantLock();
   
   public void incrementCounter() {
      lock.lock();
      try {
         counter++;
      } finally {
         lock.unlock();
      }
   }
}

ఈ ఉదాహరణలో, ReentrantLock క్లాస్ లాక్‌ని సృష్టించడానికి ఉపయోగించబడుతుంది, ఇది ఒక థ్రెడ్ మాత్రమే ఒకేసారి ఇంక్రిమెంట్‌కౌంటర్() పద్ధతిని యాక్సెస్ చేయగలదని నిర్ధారించడానికి ఉపయోగించబడుతుంది.

4. CompletableFuture: CompletableFuture అనేది జావా 8లో ప్రవేశపెట్టబడిన కొత్త ఫీచర్, ఇది అసమకాలిక గణనలను నిర్వహించడానికి మరియు వాటి ఫలితాలను నిర్వహించడానికి ఒక మార్గాన్ని అందిస్తుంది. CompletableFutureని ఉపయోగించే ఉదాహరణ ఇక్కడ ఉంది:

తుప్పు పట్టడం
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
   // Code to be executed asynchronously
   return "result";
});
future.thenAccept(result -> {
   // Code to be executed when the async task completes
   System.out.println(result);
});

ఈ ఉదాహరణలో, సప్లైఅసిన్క్() పద్ధతి కోడ్‌ను అసమకాలికంగా అమలు చేయడానికి ఉపయోగించబడుతుంది మరియు ఎసిన్క్ టాస్క్ పూర్తయినప్పుడు ఫలితాన్ని నిర్వహించడానికి thenAccept() పద్ధతి ఉపయోగించబడుతుంది.

5. స్ట్రీమ్ API: జావా 8లో ప్రవేశపెట్టిన స్ట్రీమ్ API డేటా సేకరణలను డిక్లరేటివ్ పద్ధతిలో ప్రాసెస్ చేయడానికి ఒక మార్గాన్ని అందిస్తుంది. మల్టీ-కోర్ ప్రాసెసర్ల ప్రయోజనాన్ని పొందడానికి సమాంతర ప్రాసెసింగ్ కోసం కూడా దీనిని ఉపయోగించవచ్చు. సమాంతర ప్రాసెసింగ్ కోసం స్ట్రీమ్ APIని ఉపయోగించే ఉదాహరణ ఇక్కడ ఉంది:

scss
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream()
                .mapToInt(Integer::intValue)
                .sum();

ఈ ఉదాహరణలో, parallelStream() పద్ధతి డేటా యొక్క సమాంతర ప్రసారాన్ని సృష్టించడానికి ఉపయోగించబడుతుంది, ఇది mapToInt() మరియు sum() పద్ధతులను ఉపయోగించి సమాంతరంగా ప్రాసెస్ చేయబడుతుంది.

జావా 8లో కాన్కరెన్సీ కోసం అందుబాటులో ఉన్న అనేక ఫీచర్లు మరియు సాధనాలకు ఇవి కొన్ని ఉదాహరణలు మాత్రమే. ఈ లక్షణాలను అర్థం చేసుకోవడం మరియు మాస్టరింగ్ చేయడం ద్వారా, మీరు ఆధునిక మల్టీ-కోర్ ప్రాసెసర్‌ల ప్రయోజనాన్ని పొందే మరింత సమర్థవంతమైన మరియు స్కేలబుల్ ప్రోగ్రామ్‌లను వ్రాయవచ్చు.