რა არის ბლოკირების მდგომარეობა?

სტატუსი ბლოკირება (lock contention) წარმოიქმნება, როდესაც რამდენიმე ნაკადი ან პროცესი ერთდროულად ცდილობს მიიღოს ექსკლუზიური წვდომა საერთო რესურსზე (მაგალითად, ცვლადზე, ფაილზე ან ბლოკირებაზე), რომელიც დაცულია ბლოკირების მექანიზმით. ეს იწვევს მათ შორის ზოგიერთი შეჩერებას და ელოდება რესურსის გათავისუფლებას.

ძირითადი მიზეზები:

• მრავალ ნაკადიანი/მრავალპროცესიანი მუშაობა.
• საერთო ცვლადი რესურსები.
• ბლოკირებების არასრულყოფილი გამოყენება (მოდულური ან ძალიან გრძელი ბლოკირებები).

შედეგები:

• მუშაობის ეფექტურობის შემცირება ელოდების გამო.
• ბლოკირებების მართვის დამატებითი ხარჯები.
• ურთიერთბლოკირებები (deadlocks) არასათანადო გამოყენებისას.

მინიმიზაციის მეთოდები:

• რესურსის დაკავების დროის შემცირება.
• ნაკლებ გრაფულ ბლოკირებების გამოყენება (მხოლოდ საჭირო ნაწილის ბლოკირება).
• ატომური ოპერაციების გამოყენება, თუ შესაძლებელია.
• ბლოკირებადი სტრუქტურების გარეშე მონაცემთა სტრუქტურების გამოყენება.
• ჰორიზონტალური მასშტაბირება, თუ არქიტექტურა ამის საშუალებას იძლევა.

Python-ის კოდის მაგალითი, რომელიც აჩვენებს კონკურენციას ბლოკირებაზე:

import threading
import time

lock = threading.Lock()
counter = 0

def increment():
    global counter
    # ბლოკირების მიღება
    lock.acquire()
    try:
        # მუშაობის იმიტაცია
        time.sleep(0.01)
        counter += 1
    finally:
        # ბლოკირების გათავისუფლება
        lock.release()

threads = []
for _ in range(10):
    t = threading.Thread(target=increment)  # ნაკადების შექმნა
    threads.append(t)
    t.start()  # ნაკადების დაწყება

for t in threads:
    t.join() # ყველა ნაკადის დასრულების მოლოდინი

print(f"საკონტროლო მნიშვნელობა: {counter}")

აქ lock.acquire() და lock.release() იცავს counter-ის წვდომას. ბლოკირების გარეშე (ან კონკურენციის დროს) საბოლოო მნიშვნელობა შეიძლება იყოს 10-ზე ნაკლები, რადგან მონაცემთა შეჯახება ხდება.