రేస్ కండిషన్ దుర్బలత్వం అంటే ఏమిటి?

రేస్ కండిషన్ దుర్బలత్వం అంటే ఏమిటి?
మీలాంటి పాఠకులు MUOకి మద్దతు ఇవ్వడానికి సహాయం చేస్తారు. మీరు మా సైట్‌లోని లింక్‌లను ఉపయోగించి కొనుగోలు చేసినప్పుడు, మేము అనుబంధ కమీషన్‌ను సంపాదించవచ్చు.

ఒక నిర్దిష్ట క్రమంలో రెండు కార్యకలాపాలు తప్పనిసరిగా జరిగినప్పుడు రేసు పరిస్థితి ఏర్పడుతుంది, కానీ అవి వ్యతిరేక క్రమంలో అమలు కావచ్చు.





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



రోజు యొక్క వీడియోను తయారు చేయండి

ఈ నమూనాను బాగా అర్థం చేసుకోవడానికి, ప్రాసెసర్ యొక్క ప్రక్రియ మార్పిడి ప్రక్రియను నిశితంగా పరిశీలించడం మంచిది.





ప్రాసెసర్ ప్రక్రియలను ఎలా మారుస్తుంది

ఆధునిక ఆపరేటింగ్ సిస్టమ్స్ మల్టీటాస్కింగ్ అని పిలువబడే ఒకటి కంటే ఎక్కువ ప్రక్రియలను ఏకకాలంలో అమలు చేయగలదు. మీరు ఈ ప్రక్రియను పరంగా చూసినప్పుడు CPU యొక్క అమలు చక్రం , మల్టీ టాస్కింగ్ నిజంగా ఉనికిలో లేదని మీరు కనుగొనవచ్చు.

బదులుగా, ప్రాసెసర్‌లు వాటిని ఏకకాలంలో అమలు చేయడానికి లేదా కనీసం అవి చేస్తున్నట్లుగా పని చేయడానికి ప్రక్రియల మధ్య నిరంతరం మారుతూ ఉంటాయి. CPU ప్రక్రియ పూర్తికాకముందే అంతరాయం కలిగించవచ్చు మరియు వేరొక ప్రక్రియను పునఃప్రారంభించవచ్చు. ఆపరేటింగ్ సిస్టమ్ ఈ ప్రక్రియల నిర్వహణను నియంత్రిస్తుంది.



హెడ్‌ఫోన్‌లలో ప్రతిధ్వనిని ఎలా పరిష్కరించాలి

ఉదాహరణకు, రౌండ్ రాబిన్ అల్గోరిథం, సరళమైన స్విచ్చింగ్ అల్గారిథమ్‌లలో ఒకటి, ఈ క్రింది విధంగా పనిచేస్తుంది:

CPU ప్రస్తుతం అమలవుతున్న 1 సక్రియ ప్రక్రియను 3 క్యూలో, స్లీపింగ్ ప్రాసెస్ చేసే రేఖాచిత్రం

సాధారణంగా, ఈ అల్గోరిథం ఆపరేటింగ్ సిస్టమ్ నిర్ణయించినట్లుగా, ప్రతి ప్రక్రియను చాలా చిన్న భాగాలకు అమలు చేయడానికి అనుమతిస్తుంది. ఉదాహరణకు, ఇది రెండు మైక్రోసెకన్ల వ్యవధి కావచ్చు.



CPU ప్రతి ప్రక్రియను క్రమంగా తీసుకుంటుంది మరియు రెండు మైక్రోసెకన్ల పాటు అమలు చేసే ఆదేశాలను అమలు చేస్తుంది. ఇది ప్రస్తుత ప్రక్రియ పూర్తయిందా లేదా అనే దానితో సంబంధం లేకుండా తదుపరి ప్రక్రియకు కొనసాగుతుంది. అందువల్ల, తుది వినియోగదారు దృష్టికోణం నుండి, ఒకటి కంటే ఎక్కువ ప్రక్రియలు ఏకకాలంలో నడుస్తున్నట్లు అనిపిస్తుంది. అయితే, మీరు తెరవెనుక చూసినప్పుడు, CPU ఇప్పటికీ క్రమంలో పనులు చేస్తోంది.

మార్గం ద్వారా, పైన ఉన్న రేఖాచిత్రం చూపినట్లుగా, రౌండ్ రాబిన్ అల్గారిథమ్‌లో ఎలాంటి ఆప్టిమైజేషన్ లేదా ప్రాసెసింగ్ ప్రాధాన్యత భావనలు లేవు. తత్ఫలితంగా, ఇది నిజమైన వ్యవస్థలలో చాలా అరుదుగా ఉపయోగించబడే మూలాధార పద్ధతి.



ఇప్పుడు, ఇవన్నీ బాగా అర్థం చేసుకోవడానికి, రెండు థ్రెడ్లు నడుస్తున్నట్లు ఊహించుకోండి. థ్రెడ్‌లు సాధారణ వేరియబుల్‌ని యాక్సెస్ చేస్తే, రేస్ పరిస్థితి తలెత్తవచ్చు.

ఒక ఉదాహరణ వెబ్ అప్లికేషన్ మరియు రేస్ కండిషన్

మీరు ఇప్పటివరకు చదివిన ప్రతిదాని యొక్క నిర్దిష్ట ఉదాహరణను ప్రతిబింబించడానికి దిగువన ఉన్న సాధారణ ఫ్లాస్క్ యాప్‌ను చూడండి. ఈ అప్లికేషన్ యొక్క ఉద్దేశ్యం వెబ్‌లో జరిగే డబ్బు లావాదేవీలను నిర్వహించడం. అనే ఫైల్‌లో కింది వాటిని సేవ్ చేయండి money.py :

from flask import Flask 
from flask.ext.sqlalchemy import SQLAlchemy 
  
app = Flask(__name__) 
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test.db' 
db = SQLAlchemy(app) 
  
class Account(db.Model): 
    id = db.Column(db.Integer, primary_key = True) 
    amount = db.Column(db.String(80), unique = True) 
  
    def __init__(self, count): 
        self.amount = amount 
  
    def __repr__(self): 
        return '' % self.amount 
  
@app.route("/") 
def hi(): 
    account = Account.query.get(1) # There is only one wallet. 
    return "Total Money = {}".format(account.amount) 
  
@app.route("/send/") 
def send(amount): 
    account = Account.query.get(1) 
  
    if int(account.amount) < amount: 
        return "Insufficient balance. Reset money with /reset!)" 
  
    account.amount = int(account.amount) - amount 
    db.session.commit() 
    return "Amount sent = {}".format(amount) 
  
@app.route("/reset") 
def reset(): 
    account = Account.query.get(1) 
    account.amount = 5000 
    db.session.commit() 
    return "Money reset." 
  
if __name__ == "__main__": 
    app.secret_key = 'heLLoTHisIsSeCReTKey!' 
    app.run()

ఈ కోడ్‌ని అమలు చేయడానికి, మీరు ఖాతా పట్టికలో రికార్డ్‌ను సృష్టించాలి మరియు ఈ రికార్డ్‌లో లావాదేవీలను కొనసాగించాలి. మీరు కోడ్‌లో చూడగలిగినట్లుగా, ఇది పరీక్షా వాతావరణం, కాబట్టి ఇది పట్టికలోని మొదటి రికార్డుకు వ్యతిరేకంగా లావాదేవీలను చేస్తుంది.

from money import db 
db.create_all() 
from money import Account 
account = Account(5000) 
db.session.add(account) 
db.session.commit()

మీరు ఇప్పుడు ,000 బ్యాలెన్స్‌తో ఖాతాను సృష్టించారు. చివరగా, మీరు Flask మరియు Flask-SQLAlchemy ప్యాకేజీలను ఇన్‌స్టాల్ చేసి ఉంటే, కింది ఆదేశాన్ని ఉపయోగించి పై సోర్స్ కోడ్‌ను అమలు చేయండి:

python money.py

కాబట్టి మీరు ఒక సాధారణ వెలికితీత ప్రక్రియను చేసే Flask వెబ్ అప్లికేషన్‌ని కలిగి ఉన్నారు. ఈ అప్లికేషన్ GET అభ్యర్థన లింక్‌లతో కింది కార్యకలాపాలను చేయగలదు. Flask డిఫాల్ట్‌గా 5000 పోర్ట్‌లో నడుస్తుంది కాబట్టి, మీరు దాన్ని యాక్సెస్ చేసే చిరునామా 127.0.0.1:5000/ . అనువర్తనం క్రింది ముగింపు పాయింట్లను అందిస్తుంది:

  • 127.0.0.1:5000/ ప్రస్తుత బ్యాలెన్స్‌ని ప్రదర్శిస్తుంది.
  • 127.0.0.1:5000/పంపు/{మొత్తం} ఖాతా నుండి మొత్తాన్ని తీసివేస్తుంది.
  • 127.0.0.1:5000/రీసెట్ ఖాతాను ,000కి రీసెట్ చేస్తుంది.

ఇప్పుడు, ఈ దశలో, మీరు జాతి పరిస్థితి దుర్బలత్వం ఎలా సంభవిస్తుందో పరిశీలించవచ్చు.

రేస్ కండిషన్ దుర్బలత్వం యొక్క సంభావ్యత

పై వెబ్ అప్లికేషన్ రేస్ కండిషన్ దుర్బలత్వాన్ని కలిగి ఉంది.

ని పంపే రెండు వేర్వేరు HTTP అభ్యర్థనలను ప్రారంభించడానికి మరియు సృష్టించడానికి మీకు ,000 ఉందని ఊహించుకోండి. దీని కోసం, మీరు లింక్‌కి రెండు వేర్వేరు HTTP అభ్యర్థనలను పంపవచ్చు 127.0.0.1:5000/పంపు/1 . అనుకుందాం, వెంటనే వెబ్ సర్వర్ మొదటి అభ్యర్థనను ప్రాసెస్ చేస్తుంది, CPU ఈ ప్రక్రియను నిలిపివేస్తుంది మరియు రెండవ అభ్యర్థనను ప్రాసెస్ చేస్తుంది. ఉదాహరణకు, కింది కోడ్ లైన్‌ను అమలు చేసిన తర్వాత మొదటి ప్రక్రియ ఆగిపోవచ్చు:

psd ఫైల్‌ను ఎలా తెరవాలి 
account.amount = int(account.amount) - amount

ఈ కోడ్ కొత్త మొత్తాన్ని లెక్కించింది కానీ డేటాబేస్‌లో రికార్డ్‌ను ఇంకా సేవ్ చేయలేదు. రెండవ అభ్యర్థన ప్రారంభమైనప్పుడు, అది అదే గణనను నిర్వహిస్తుంది, డేటాబేస్లోని విలువ నుండి ని తీసివేస్తుంది-,000-మరియు ఫలితాన్ని నిల్వ చేస్తుంది. మొదటి ప్రక్రియ పునఃప్రారంభమైనప్పుడు, ఇది దాని స్వంత విలువ-,999-ని నిల్వ చేస్తుంది-ఇది ఇటీవలి ఖాతా బ్యాలెన్స్‌ను ప్రతిబింబించదు.

కాబట్టి, రెండు అభ్యర్థనలు పూర్తయ్యాయి మరియు ప్రతి ఒక్కటి ఖాతా బ్యాలెన్స్ నుండి ని తీసివేయాలి, ఫలితంగా కొత్త బ్యాలెన్స్ ,998. కానీ, వెబ్ సర్వర్ వాటిని ప్రాసెస్ చేసే క్రమాన్ని బట్టి, చివరి ఖాతా బ్యాలెన్స్ ,999 కావచ్చు.

ఐదు సెకన్ల వ్యవధిలో లక్ష్య సిస్టమ్‌కు బదిలీ చేయడానికి మీరు 128 అభ్యర్థనలను పంపినట్లు ఊహించుకోండి. ఈ లావాదేవీ ఫలితంగా, ఖాతా యొక్క అంచనా ప్రకటన ,000 - 8 = ,875 అవుతుంది. అయితే, రేసు పరిస్థితి కారణంగా, చివరి బ్యాలెన్స్ ,875 మరియు ,999 మధ్య ఏదైనా మారవచ్చు.

ప్రోగ్రామర్లు భద్రత యొక్క అత్యంత ముఖ్యమైన భాగాలలో ఒకటి

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

అటువంటి దుర్బలత్వాల గురించి మీకు తెలిసి ఉండాలి, తద్వారా వాటిని రక్షించడానికి మీరు వ్రాసిన ప్రోగ్రామ్ హాని నుండి విముక్తి పొందుతుంది. దీనికి బలమైన బాధ్యత అవసరం.

జాతి పరిస్థితి దుర్బలత్వం వాటిలో ఒకటి మాత్రమే. మీరు ఏ టెక్నాలజీని ఉపయోగించినా, మీరు వ్రాసే కోడ్‌లోని దుర్బలత్వాలను మీరు గమనించాలి. ప్రోగ్రామర్‌గా మీరు పొందగలిగే ముఖ్యమైన నైపుణ్యాలలో ఒకటి సాఫ్ట్‌వేర్ భద్రతతో పరిచయం.