అణు కార్యకలాపాల ఆవిర్భావానికి ముందస్తు అవసరాలు
అణు కార్యకలాపాలు ఎలా పనిచేస్తాయో అర్థం చేసుకోవడంలో మీకు సహాయపడటానికి ఈ ఉదాహరణను పరిశీలిద్దాం:
public class Counter {
int count;
public void increment() {
count++;
}
}మనకు ఒక థ్రెడ్ ఉన్నప్పుడు, ప్రతిదీ అద్భుతంగా పని చేస్తుంది, కానీ మనం మల్టీథ్రెడింగ్‌ని జోడిస్తే, మనకు తప్పుడు ఫలితాలు వస్తాయి మరియు అన్నీ ఇంక్రిమెంట్ ఆపరేషన్ ఒక ఆపరేషన్ కాదు, కానీ మూడు: ప్రస్తుత విలువను పొందడానికి అభ్యర్థనలెక్కించండి, ఆపై దానిని 1 ద్వారా పెంచి, మళ్లీ వ్రాయండిలెక్కించండి.
మరియు రెండు థ్రెడ్‌లు వేరియబుల్‌ని పెంచాలనుకున్నప్పుడు, మీరు డేటాను ఎక్కువగా కోల్పోతారు. అంటే, రెండు థ్రెడ్‌లు 100ని అందుకుంటాయి, ఫలితంగా, రెండూ ఊహించిన విలువ 102కి బదులుగా 101ని వ్రాస్తాయి.
మరియు దానిని ఎలా పరిష్కరించాలి? మీరు తాళాలు ఉపయోగించాలి. సమకాలీకరించబడిన కీవర్డ్ ఈ సమస్యను పరిష్కరించడంలో సహాయపడుతుంది, దీన్ని ఉపయోగించడం ద్వారా ఒక థ్రెడ్ ఒకేసారి పద్ధతిని యాక్సెస్ చేస్తుందనే హామీని ఇస్తుంది.
public class SynchronizedCounterWithLock {
private volatile int count;
public synchronized void increment() {
count++;
}
}
అదనంగా, మీరు అస్థిర కీవర్డ్‌ని జోడించాలి , ఇది థ్రెడ్‌ల మధ్య సూచనల యొక్క సరైన దృశ్యమానతను నిర్ధారిస్తుంది. మేము పైన అతని పనిని సమీక్షించాము.
కానీ ఇప్పటికీ ప్రతికూలతలు ఉన్నాయి. అతి పెద్దది పనితీరు, ఆ సమయంలో అనేక థ్రెడ్‌లు లాక్‌ని పొందేందుకు ప్రయత్నిస్తున్నప్పుడు మరియు ఒకరికి వ్రాసే అవకాశం లభించినప్పుడు, థ్రెడ్ విడుదలయ్యే వరకు మిగిలిన థ్రెడ్‌లు బ్లాక్ చేయబడతాయి లేదా తాత్కాలికంగా నిలిపివేయబడతాయి.
సిస్టమ్ పనితీరు కోసం ఈ ప్రక్రియలన్నీ, నిరోధించడం, మరొక స్థితికి మారడం చాలా ఖరీదైనవి.
అణు కార్యకలాపాలు
అల్గోరిథం కంపేర్-అండ్-స్వాప్ (CAS, కంపేర్-అండ్-స్వాప్, ఇది డేటా సమగ్రతను నిర్ధారిస్తుంది మరియు వాటిపై ఇప్పటికే పెద్ద మొత్తంలో పరిశోధన ఉంది) వంటి తక్కువ-స్థాయి యంత్ర సూచనలను ఉపయోగిస్తుంది.
ఒక సాధారణ CAS ఆపరేషన్ మూడు ఆపరేండ్లపై పనిచేస్తుంది:
- పని కోసం మెమరీ స్పేస్ (M)
- వేరియబుల్ యొక్క ప్రస్తుత అంచనా విలువ (A).
- కొత్త విలువ (B) సెట్ చేయాలి
CAS పరమాణుపరంగా M నుండి Bకి అప్‌డేట్ చేస్తుంది, అయితే M యొక్క విలువ A వలె ఉంటే మాత్రమే, లేకపోతే ఎటువంటి చర్య తీసుకోబడదు.
మొదటి మరియు రెండవ సందర్భాలలో, M యొక్క విలువ తిరిగి ఇవ్వబడుతుంది. ఇది మూడు దశలను కలపడానికి మిమ్మల్ని అనుమతిస్తుంది, అవి విలువను పొందడం, విలువను సరిపోల్చడం మరియు దానిని నవీకరించడం. మరియు ఇది అన్ని యంత్ర స్థాయిలో ఒక ఆపరేషన్గా మారుతుంది.
మల్టీ-థ్రెడ్ అప్లికేషన్ వేరియబుల్‌ను యాక్సెస్ చేసి, దానిని అప్‌డేట్ చేయడానికి ప్రయత్నించినప్పుడు మరియు CAS వర్తింపజేయబడినప్పుడు, థ్రెడ్‌లలో ఒకటి దాన్ని పొందుతుంది మరియు దానిని అప్‌డేట్ చేయగలదు. కానీ లాక్‌ల మాదిరిగా కాకుండా, ఇతర థ్రెడ్‌లు విలువను అప్‌డేట్ చేయలేకపోవడం గురించి లోపాలను పొందుతాయి. అప్పుడు వారు తదుపరి పనికి వెళతారు మరియు ఈ రకమైన పనిలో స్విచ్చింగ్ పూర్తిగా మినహాయించబడుతుంది.
ఈ సందర్భంలో, CAS ఆపరేషన్ విజయవంతంగా పని చేయనప్పుడు మేము పరిస్థితిని నిర్వహించవలసి ఉంటుంది అనే వాస్తవం కారణంగా లాజిక్ మరింత కష్టమవుతుంది. మేము కోడ్‌ను మోడల్ చేస్తాము, తద్వారా ఆపరేషన్ విజయవంతం అయ్యే వరకు అది ముందుకు సాగదు.
అటామిక్ రకాల పరిచయం
మీరు టైప్ int యొక్క సరళమైన వేరియబుల్ కోసం సమకాలీకరణను సెటప్ చేయాల్సిన పరిస్థితిని మీరు ఎదుర్కొన్నారా ?
మేము ఇప్పటికే కవర్ చేసిన మొదటి మార్గం అస్థిర + సమకాలీకరించబడింది . కానీ ప్రత్యేక అటామిక్* తరగతులు కూడా ఉన్నాయి.
మేము CASని ఉపయోగిస్తే, మొదటి పద్ధతితో పోలిస్తే కార్యకలాపాలు వేగంగా పని చేస్తాయి. మరియు అదనంగా, మేము విలువ మరియు పెంపు మరియు తగ్గింపు కార్యకలాపాలను జోడించడానికి ప్రత్యేకమైన మరియు చాలా అనుకూలమైన పద్ధతులను కలిగి ఉన్నాము.
AtomicBoolean , AtomicInteger , AtomicLong , AtomicIntegerArray , AtomicLongArray కార్యకలాపాలు పరమాణువుగా ఉండే తరగతులు. క్రింద మేము వారితో పనిని విశ్లేషిస్తాము.
పరమాణు పూర్ణాంకం
AtomicInteger తరగతి విస్తరించిన పరమాణు కార్యకలాపాలను అందించడంతో పాటు, పరమాణుపరంగా చదవగలిగే మరియు వ్రాయగల పూర్ణాంక విలువపై కార్యకలాపాలను అందిస్తుంది .
ఇది వేరియబుల్స్ చదవడం మరియు వ్రాయడం వంటి పని చేసే పద్ధతులను పొంది మరియు సెట్ చేస్తుంది .
అంటే, మనం ఇంతకు ముందు మాట్లాడిన అదే వేరియబుల్ యొక్క ఏదైనా తదుపరి రసీదుతో "జరగడం-ముందు". అటామిక్ కంపేర్‌అండ్‌సెట్ పద్ధతి కూడా ఈ మెమరీ స్థిరత్వ లక్షణాలను కలిగి ఉంది.
కొత్త విలువను అందించే అన్ని కార్యకలాపాలు పరమాణుపరంగా నిర్వహించబడతాయి:
| int addAndGet (int డెల్టా) | ప్రస్తుత విలువకు నిర్దిష్ట విలువను జోడిస్తుంది. |
| boolean compareAndSet (అంచనా పూర్ణాంకము, నవీకరణ పూర్ణాంకము) | ప్రస్తుత విలువ ఆశించిన విలువతో సరిపోలితే, అందించిన నవీకరించబడిన విలువకు విలువను సెట్ చేస్తుంది. |
| int decrementAndGet() | ప్రస్తుత విలువను ఒకటి తగ్గిస్తుంది. |
| int getAndAdd(int delta) | ప్రస్తుత విలువకు ఇచ్చిన విలువను జోడిస్తుంది. |
| int getAndDecrement() | ప్రస్తుత విలువను ఒకటి తగ్గిస్తుంది. |
| int getAndIncrement() | ప్రస్తుత విలువను ఒకటి పెంచుతుంది. |
| int getAndSet(int newValue) | ఇచ్చిన విలువను సెట్ చేస్తుంది మరియు పాత విలువను అందిస్తుంది. |
| int incrementAndGet() | ప్రస్తుత విలువను ఒకటి పెంచుతుంది. |
| lazySet (పూర్ణాంక కొత్త విలువ) | చివరగా ఇచ్చిన విలువకు సెట్ చేయండి. |
| బూలియన్ బలహీన CompareAndSet (అంచనా, నవీకరణ పూర్ణాంకానికి) | ప్రస్తుత విలువ ఆశించిన విలువతో సరిపోలితే, అందించిన నవీకరించబడిన విలువకు విలువను సెట్ చేస్తుంది. |
ఉదాహరణ:
ExecutorService executor = Executors.newFixedThreadPool(5);
IntStream.range(0, 50).forEach(i -> executor.submit(atomicInteger::incrementAndGet));
executor.shutdown();
executor.awaitTermination(Long.MAX_VALUE, TimeUnit.HOURS);
System.out.println(atomicInteger.get()); // prints 50