თქვენ მუშაობდით სემაფორებთან თქვენს პრაქტიკაში?

ඔව්, මම සෙමාෆෝර් භාවිතා කර ඇත, විශේෂයෙන් Android යෙදුම්වල බහු තන්තු සමඟ වැඩ කිරීමේ සන්දර්භයේ.

Java-යේ (java.util.concurrent.Semaphore) සෙමාෆෝර් යනු සීමිත සම්පතකට එකවර ප්‍රවේශ විය හැකි තන්තු සංඛ්‍යාව සීමා කිරීමට භාවිතා වේ. මෙය ප්‍රයෝජනවත් වේ එවිට සම්පත සීමිත "කැපැසිටි" ඇතැයි සැලකිය යුතු අවස්ථා, උදාහරණයක් ලෙස සම්බන්ධතා පූල් හෝ ලබා ගත හැකි ස්ලොට් සංඛ්‍යාව.

මම වැඩ කළ මූලික ක්‍රම:

• acquire(): වර්තමාන තන්තු බ්ලොක් කරයි, අවසර ලබා ගත නොහැකි වන තෙක්.
• acquire(int permits): වර්තමාන තන්තු බ්ලොක් කරයි, නියමිත අවසර සංඛ්‍යාව ලබා ගත නොහැකි වන තෙක්.
• release(): සෙමාෆෝර්ට අවසර ආපසු දෙයි, ලබා ගත හැකි අවසර සංඛ්‍යාව වැඩි කරයි.
• release(int permits): නියමිත අවසර සංඛ්‍යාව ආපසු දෙයි.
• tryAcquire(): අවසර ලබා ගැනීමට උත්සාහ කරයි, බ්ලොක් නොකර.
• availablePermits(): වර්තමාන ලබා ගත හැකි අවසර සංඛ්‍යාව ආපසු දෙයි.

උදාහරණයක්:

import java.util.concurrent.Semaphore;

public class ResourcePool {

    private static final int MAX_AVAILABLE = 5;
    private final Semaphore permits = new Semaphore(MAX_AVAILABLE, true); // සාධාරණ සෙමාෆෝර්

    public void useResource() throws InterruptedException {
        permits.acquire(); // අවසර ඉල්ලීම
        try {
            // සම්පත භාවිතා කිරීමේ තර්කය (උදාහරණයක් ලෙස, සම්බන්ධතා පූල් සමඟ වැඩ කිරීම)
            System.out.println(Thread.currentThread().getName() + " සම්පත භාවිතා කරමින්.");
            Thread.sleep(1000); // සම්පත සමඟ වැඩ කිරීමේ අනුකරණය
        } finally {
            permits.release(); // අවසර නිදහස් කිරීම
            System.out.println(Thread.currentThread().getName() + " සම්පත භාවිතා කිරීම නිමවීය.");
        }
    }

    public static void main(String[] args) {
        ResourcePool pool = new ResourcePool();
        // බොහෝ තන්තු නිර්මාණය කිරීම, ඒවා සම්පත භාවිතා කිරීමට උත්සාහ කරමින්
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    pool.useResource();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

මෙම උදාහරණයේ, permits සෙමාෆෝර් 5 අවසර සමඟ ආරම්භ වේ, එයින් අදහස් වන්නේ එකවර try බ්ලොක් තුළ සම්පත භාවිතා කරන තන්තු 5 පමණක් විය හැකිය. acquire() ක්‍රමය සියලු අවසරයන් ගන්නා විට, අනෙක් තන්තු release() නොකළ හැකිය.

සෙමාෆෝර් යනු සීමිත සම්පත් පූල් කළමනාකරණයට උපකාරී වේ, නමුත්, deadlock වැනි සම්භාව්‍ය ගැටලු වලට සැලකිල්ලෙන් බලන්න, අවසර ලබා ගැනීම හා නිදහස් කිරීම නිවැරදිව කළ යුතුය. try සහ finally සමඟ release() කැඳවීම හොඳ පුරුද්දක් වන අතර, එය අවාසියකට පත්වූ විටද, සම්පත් නිදහස් කිරීමේ වගකීම සම්පූර්ණ කරයි.