இணைப் பணிச் செயல்பாட்டில் தேர்ச்சி பெறுதல்: ஃபோர்க்-ஜாயின் கட்டமைப்பின் ஒரு ஆழமான பார்வை

இன்றைய தரவு சார்ந்த மற்றும் உலகளவில் இணைக்கப்பட்ட உலகில், திறமையான மற்றும் பதிலளிக்கக்கூடிய பயன்பாடுகளுக்கான தேவை மிக முக்கியமானது. நவீன மென்பொருட்கள் பெரும்பாலும் பரந்த அளவிலான தரவைச் செயல்படுத்தவும், சிக்கலான கணக்கீடுகளைச் செய்யவும் மற்றும் பல ஒரேநேர செயல்பாடுகளைக் கையாளவும் தேவைப்படுகிறது. இந்த சவால்களைச் சமாளிக்க, உருவாக்குநர்கள் இணைச் செயலாக்கத்தை அதிகளவில் நாடியுள்ளனர் – இது ஒரு பெரிய சிக்கலை சிறிய, நிர்வகிக்கக்கூடிய துணைச் சிக்கல்களாகப் பிரித்து, அவற்றை ஒரே நேரத்தில் தீர்க்கும் கலையாகும். ஜாவாவின் ஒருங்கமைவு பயன்பாடுகளில் முன்னணியில், ஃபோர்க்-ஜாயின் கட்டமைப்பு (Fork-Join Framework) ஒரு சக்திவாய்ந்த கருவியாகத் திகழ்கிறது. இது இணைப் பணிகளின் செயல்பாட்டை எளிதாக்கவும், மேம்படுத்தவும் வடிவமைக்கப்பட்டுள்ளது, குறிப்பாக கணக்கீட்டு-செறிவுள்ள (compute-intensive) மற்றும் இயல்பாகவே பிரித்து-வெல்லும் உத்திக்கு ஏற்ற பணிகளுக்கு இது மிகவும் பயனுள்ளது.

இணைச் செயலாக்கத்தின் தேவையைப் புரிந்துகொள்ளுதல்

ஃபோர்க்-ஜாயின் கட்டமைப்பின் பிரத்யேக அம்சங்களுக்குள் செல்வதற்கு முன், இணைச் செயலாக்கம் ஏன் மிகவும் அவசியம் என்பதைப் புரிந்துகொள்வது முக்கியம். பாரம்பரியமாக, பயன்பாடுகள் பணிகளை ஒன்றன்பின் ஒன்றாக வரிசையாகச் செயல்படுத்தின. இந்த அணுகுமுறை எளிமையானதாக இருந்தாலும், நவீன கணக்கீட்டுத் தேவைகளைக் கையாளும் போது இது ஒரு தடையாக மாறுகிறது. ஒரு உலகளாவிய மின்-வணிகத் தளத்தைக் கருத்தில் கொள்ளுங்கள், அது மில்லியன் கணக்கான பரிவர்த்தனைகளைச் செயல்படுத்தவும், பல்வேறு பிராந்தியங்களிலிருந்து பயனர் நடத்தைத் தரவை பகுப்பாய்வு செய்யவும், அல்லது சிக்கலான காட்சி இடைமுகங்களை நிகழ்நேரத்தில் வழங்கவும் தேவைப்படுகிறது. ஒரு ஒற்றைத் திரெட் (single-threaded) செயல்பாடு மிக மெதுவாக இருக்கும், இது மோசமான பயனர் அனுபவத்திற்கும், வணிக வாய்ப்புகளைத் தவறவிடுவதற்கும் வழிவகுக்கும்.

பல்-மைய செயலிகள் (multi-core processors) இப்போது மொபைல் ஃபோன்கள் முதல் பெரிய சர்வர் தொகுப்புகள் வரை பெரும்பாலான கணினி சாதனங்களில் தரநிலையாக உள்ளன. இணைச் செயலாக்கம் இந்த பல்-மைய செயலிகளின் சக்தியைப் பயன்படுத்திக்கொள்ள அனுமதிக்கிறது, இதன்மூலம் பயன்பாடுகள் ஒரே நேரத்தில் அதிக வேலையைச் செய்ய முடிகிறது. இது பின்வரும் நன்மைகளுக்கு வழிவகுக்கிறது:

• மேம்படுத்தப்பட்ட செயல்திறன்: பணிகள் கணிசமாக வேகமாக முடிவடைகின்றன, இது ஒரு பதிலளிக்கக்கூடிய பயன்பாட்டிற்கு வழிவகுக்கிறது.
• அதிகரித்த செயல்பாடு (Throughput): ஒரு குறிப்பிட்ட காலக்கெடுவுக்குள் அதிக செயல்பாடுகளைச் செயல்படுத்த முடியும்.
• சிறந்த வளப் பயன்பாடு: கிடைக்கக்கூடிய அனைத்து செயலாக்க மையங்களையும் பயன்படுத்துவது செயலற்ற வளங்களைத் தடுக்கிறது.
• அளவிடுதல் (Scalability): அதிக செயலாக்க சக்தியைப் பயன்படுத்துவதன் மூலம், பயன்பாடுகள் அதிகரிக்கும் பணிச்சுமைகளைக் கையாள திறம்பட அளவிட முடியும்.

பிரித்து-வெல்லும் உத்தி (Divide-and-Conquer Paradigm)

ஃபோர்க்-ஜாயின் கட்டமைப்பு நன்கு நிறுவப்பட்ட பிரித்து-வெல்லும் நெறிமுறை உத்தியின் மீது கட்டமைக்கப்பட்டுள்ளது. இந்த அணுகுமுறையில் அடங்குபவை:

1. பிரித்தல் (Divide): ஒரு சிக்கலான சிக்கலை சிறிய, சுதந்திரமான துணைச் சிக்கல்களாகப் பிரித்தல்.
2. வெல்லுதல் (Conquer): இந்த துணைச் சிக்கல்களை சுழல்நிலை முறையில் (recursively) தீர்த்தல். ஒரு துணைச் சிக்கல் போதுமான அளவு சிறியதாக இருந்தால், அது நேரடியாகத் தீர்க்கப்படும். இல்லையெனில், அது மேலும் பிரிக்கப்படும்.
3. இணைத்தல் (Combine): துணைச் சிக்கல்களின் தீர்வுகளை ஒன்றிணைத்து, அசல் சிக்கலுக்கான தீர்வை உருவாக்குதல்.

இந்த சுழல்நிலைத் தன்மை ஃபோர்க்-ஜாயின் கட்டமைப்பை பின்வரும் பணிகளுக்கு மிகவும் பொருத்தமானதாக ஆக்குகிறது:

• அணிவரிசை செயலாக்கம் (எ.கா., வரிசைப்படுத்துதல், தேடுதல், மாற்றங்கள்)
• அணிச் செயல்பாடுகள் (Matrix operations)
• பட செயலாக்கம் மற்றும் கையாளுதல்
• தரவு திரட்டல் மற்றும் பகுப்பாய்வு
• ஃபைபோனச்சி தொடர் கணக்கீடு அல்லது மரக் கடத்தல் (tree traversals) போன்ற சுழல்நிலை நெறிமுறைகள்

ஜாவாவில் ஃபோர்க்-ஜாயின் கட்டமைப்பை அறிமுகப்படுத்துதல்

ஜாவாவின் ஃபோர்க்-ஜாயின் கட்டமைப்பு, ஜாவா 7 இல் அறிமுகப்படுத்தப்பட்டது, இது பிரித்து-வெல்லும் உத்தியின் அடிப்படையில் இணை நெறிமுறைகளைச் செயல்படுத்த ஒரு கட்டமைக்கப்பட்ட வழியை வழங்குகிறது. இது இரண்டு முக்கிய சுருக்க வகுப்புகளைக் (abstract classes) கொண்டுள்ளது:

• RecursiveTask<V>: ஒரு முடிவைத் தரும் பணிகளுக்கு.
• RecursiveAction: ஒரு முடிவைத் தராத பணிகளுக்கு.

இந்த வகுப்புகள் ForkJoinPool எனப்படும் ஒரு சிறப்பு வகை ExecutorService உடன் பயன்படுத்த வடிவமைக்கப்பட்டுள்ளன. ForkJoinPool ஃபோர்க்-ஜாயின் பணிகளுக்காக உகந்ததாக்கப்பட்டுள்ளது மற்றும் வேலை-திருடல் (work-stealing) எனப்படும் ஒரு நுட்பத்தைப் பயன்படுத்துகிறது, இது அதன் திறனுக்கு முக்கியமாகும்.

கட்டமைப்பின் முக்கிய கூறுகள்

ஃபோர்க்-ஜாயின் கட்டமைப்பில் பணிபுரியும்போது நீங்கள் சந்திக்கும் முக்கிய கூறுகளைப் பார்ப்போம்:

1. ForkJoinPool

ForkJoinPool தான் கட்டமைப்பின் இதயம். இது பணிகளைச் செயல்படுத்தும் வொர்க்கர் திரெட்களின் (worker threads) ஒரு தொகுப்பை நிர்வகிக்கிறது. பாரம்பரிய திரெட் பூல்களைப் போலல்லாமல், ForkJoinPool குறிப்பாக ஃபோர்க்-ஜாயின் மாதிரிக்கு வடிவமைக்கப்பட்டுள்ளது. அதன் முக்கிய அம்சங்கள் பின்வருமாறு:

• வேலை-திருடல் (Work-Stealing): இது ஒரு முக்கியமான மேம்படுத்தல் ஆகும். ஒரு வொர்க்கர் திரெட் தனக்கு ஒதுக்கப்பட்ட பணிகளை முடித்ததும், அது செயலற்ற நிலையில் இருக்காது. அதற்கு பதிலாக, அது மற்ற பிஸியான வொர்க்கர் திரெட்களின் வரிசைகளிலிருந்து பணிகளை "திருடும்". இது கிடைக்கக்கூடிய அனைத்து செயலாக்க சக்தியும் திறம்படப் பயன்படுத்தப்படுவதை உறுதிசெய்கிறது, செயலற்ற நேரத்தைக் குறைத்து, செயல்பாட்டை அதிகரிக்கிறது. ஒரு பெரிய திட்டத்தில் பணிபுரியும் ஒரு குழுவை கற்பனை செய்து பாருங்கள்; ஒருவர் தனது பங்கை சீக்கிரம் முடித்துவிட்டால், அதிக சுமையுள்ள ஒருவரிடமிருந்து வேலையை எடுத்துக் கொள்ளலாம்.
• நிர்வகிக்கப்பட்ட செயல்பாடு: இந்த பூல் திரெட்கள் மற்றும் பணிகளின் வாழ்க்கைச் சுழற்சியை நிர்வகிக்கிறது, இது ஒருங்கமைவு நிரலாக்கத்தை எளிதாக்குகிறது.
• செருகக்கூடிய நேர்மை (Pluggable Fairness): பணி அட்டவணையிடலில் வெவ்வேறு அளவிலான நேர்மைக்காக இதை உள்ளமைக்க முடியும்.

நீங்கள் ஒரு ForkJoinPool ஐ இப்படி உருவாக்கலாம்:

// பொதுவான பூலைப் பயன்படுத்துதல் (பெரும்பாலான நிகழ்வுகளுக்குப் பரிந்துரைக்கப்படுகிறது)
ForkJoinPool pool = ForkJoinPool.commonPool();

// அல்லது ஒரு தனிப்பயன் பூலை உருவாக்குதல்
// ForkJoinPool customPool = new ForkJoinPool(Runtime.getRuntime().availableProcessors());

commonPool() என்பது ஒரு நிலையான, பகிரப்பட்ட பூல் ஆகும், இதை நீங்கள் வெளிப்படையாக உருவாக்கி நிர்வகிக்காமல் பயன்படுத்தலாம். இது பெரும்பாலும் ஒரு நியாயமான எண்ணிக்கையிலான திரெட்களுடன் (பொதுவாகக் கிடைக்கக்கூடிய செயலிகளின் எண்ணிக்கையின் அடிப்படையில்) முன்பே உள்ளமைக்கப்பட்டிருக்கும்.

2. RecursiveTask<V>

RecursiveTask<V> என்பது V வகை முடிவைக் கணக்கிடும் ஒரு பணியைக் குறிக்கும் ஒரு சுருக்க வகுப்பு ஆகும். இதைப் பயன்படுத்த, நீங்கள் செய்ய வேண்டியது:

• RecursiveTask<V> வகுப்பை நீட்டிக்க வேண்டும் (extend).
• protected V compute() முறையைச் செயல்படுத்த வேண்டும்.

compute() முறைக்குள், நீங்கள் பொதுவாகச் செய்வது:

• அடிப்படை நிலையைச் சரிபார்க்கவும்: பணி நேரடியாகக் கணக்கிடப்படும் அளவுக்கு சிறியதாக இருந்தால், அதைச் செய்து முடிவைத் திருப்பவும்.
• ஃபோர்க் (Fork): பணி மிகப் பெரியதாக இருந்தால், அதைச் சிறிய துணைப் பணிகளாக உடைக்கவும். இந்த துணைப் பணிகளுக்காக உங்கள் RecursiveTask இன் புதிய நிகழ்வுகளை உருவாக்கவும். ஒரு துணைப் பணியை ஒத்திசைவற்ற முறையில் செயல்படுத்தத் திட்டமிட fork() முறையைப் பயன்படுத்தவும்.
• ஜாயின் (Join): துணைப் பணிகளை ஃபோர்க் செய்த பிறகு, அவற்றின் முடிவுகளுக்காக நீங்கள் காத்திருக்க வேண்டும். ஒரு ஃபோர்க் செய்யப்பட்ட பணியின் முடிவைப் பெற join() முறையைப் பயன்படுத்தவும். இந்தப் பணி முடியும் வரை இந்த முறை தடுக்கும் (blocks).
• இணைத்தல் (Combine): துணைப் பணிகளிலிருந்து முடிவுகளைப் பெற்றவுடன், தற்போதைய பணிக்கான இறுதி முடிவை உருவாக்க அவற்றை இணைக்கவும்.

எடுத்துக்காட்டு: ஒரு அணிவரிசையில் உள்ள எண்களின் கூட்டலைக் கணக்கிடுதல்

ஒரு பெரிய அணிவரிசையில் உள்ள உறுப்புகளைக் கூட்டும் ஒரு பாரம்பரிய எடுத்துக்காட்டுடன் விளக்குவோம்.

import java.util.concurrent.RecursiveTask;

public class SumArrayTask extends RecursiveTask<Long> {

    private static final int THRESHOLD = 1000; // பிரிப்பதற்கான வரம்பு
    private final int[] array;
    private final int start;
    private final int end;

    public SumArrayTask(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        int length = end - start;

        // அடிப்படை நிலை: துணை-அணிவரிசை போதுமான அளவு சிறியதாக இருந்தால், நேரடியாகக் கூட்டவும்
        if (length <= THRESHOLD) {
            return sequentialSum(array, start, end);
        }

        // சுழல்நிலை நிலை: பணியை இரண்டு துணை-பணிகளாகப் பிரிக்கவும்
        int mid = start + length / 2;

        SumArrayTask leftTask = new SumArrayTask(array, start, mid);
        SumArrayTask rightTask = new SumArrayTask(array, mid, end);

        // இடது பணியை ஃபோர்க் செய்யவும் (செயல்படுத்தத் திட்டமிடவும்)
        leftTask.fork();

        // வலது பணியை நேரடியாகக் கணக்கிடவும் (அல்லது அதையும் ஃபோர்க் செய்யவும்)
        // இங்கே, ஒரு திரெட்டை பிஸியாக வைத்திருக்க வலது பணியை நேரடியாகக் கணக்கிடுகிறோம்
        Long rightResult = rightTask.compute();

        // இடது பணியில் சேரவும் (அதன் முடிவுக்காகக் காத்திருக்கவும்)
        Long leftResult = leftTask.join();

        // முடிவுகளை இணைக்கவும்
        return leftResult + rightResult;
    }

    private Long sequentialSum(int[] array, int start, int end) {
        Long sum = 0L;
        for (int i = start; i < end; i++) {
            sum += array[i];
        }
        return sum;
    }

    public static void main(String[] args) {
        int[] data = new int[1000000]; // எடுத்துக்காட்டு பெரிய அணிவரிசை
        for (int i = 0; i < data.length; i++) {
            data[i] = i % 100;
        }

        ForkJoinPool pool = ForkJoinPool.commonPool();
        SumArrayTask task = new SumArrayTask(data, 0, data.length);

        System.out.println("Calculating sum...");
        long startTime = System.nanoTime();
        Long result = pool.invoke(task);
        long endTime = System.nanoTime();

        System.out.println("Sum: " + result);
        System.out.println("Time taken: " + (endTime - startTime) / 1_000_000 + " ms");

        // ஒப்பீட்டிற்காக, ஒரு வரிசையான கூட்டல்
        // long sequentialResult = 0;
        // for (int val : data) {
        //     sequentialResult += val;
        // }
        // System.out.println("Sequential Sum: " + sequentialResult);
    }
}

இந்த எடுத்துக்காட்டில்:

• THRESHOLD ஒரு பணி வரிசையாகச் செயல்படுத்தப்படுவதற்குப் போதுமான அளவு சிறியதா என்பதைத் தீர்மானிக்கிறது. செயல்திறனுக்குப் பொருத்தமான வரம்பைத் தேர்ந்தெடுப்பது முக்கியம்.
• compute() அணிவரிசைப் பகுதி பெரியதாக இருந்தால் வேலையைப் பிரிக்கிறது, ஒரு துணைப் பணியை ஃபோர்க் செய்கிறது, மற்றொன்றை நேரடியாகக் கணக்கிடுகிறது, பின்னர் ஃபோர்க் செய்யப்பட்ட பணியில் சேர்கிறது.
• invoke(task) என்பது ForkJoinPool இல் உள்ள ஒரு வசதியான முறையாகும், இது ஒரு பணியைச் சமர்ப்பித்து, அது முடியும் வரை காத்திருந்து, அதன் முடிவைத் தருகிறது.

3. RecursiveAction

RecursiveAction என்பது RecursiveTask ஐப் போன்றது, ஆனால் இது ஒரு ரிட்டர்ன் மதிப்பை உருவாக்காத பணிகளுக்குப் பயன்படுத்தப்படுகிறது. முக்கிய தர்க்கம் அப்படியே உள்ளது: பணி பெரியதாக இருந்தால் அதைப் பிரிக்கவும், துணைப் பணிகளை ஃபோர்க் செய்யவும், பின்னர் தொடர்வதற்கு அவற்றின் நிறைவு அவசியமானால் அவற்றில் சேரவும்.

ஒரு RecursiveAction ஐச் செயல்படுத்த, நீங்கள் செய்ய வேண்டியது:

• RecursiveAction ஐ நீட்டிக்க வேண்டும்.
• protected void compute() முறையைச் செயல்படுத்த வேண்டும்.

compute() க்குள், துணைப் பணிகளைத் திட்டமிட fork() ஐப் பயன்படுத்துவீர்கள், அவற்றின் நிறைவுக்காகக் காத்திருக்க join() ஐப் பயன்படுத்துவீர்கள். ரிட்டர்ன் மதிப்பு இல்லாததால், நீங்கள் முடிவுகளை "இணைக்க" வேண்டிய அவசியமில்லை, ஆனால் செயல்பாடு முடிவடைவதற்கு முன் அனைத்து சார்பு துணைப் பணிகளும் முடிவடைந்துவிட்டன என்பதை உறுதிப்படுத்த வேண்டியிருக்கலாம்.

எடுத்துக்காட்டு: இணை அணிவரிசை உறுப்பு மாற்றம்

ஒரு அணிவரிசையின் ஒவ்வொரு உறுப்பையும் இணையாக மாற்றுவதை கற்பனை செய்து கொள்வோம், உதாரணமாக, ஒவ்வொரு எண்ணையும் வர்க்கப்படுத்துதல்.

import java.util.concurrent.RecursiveAction;
import java.util.concurrent.ForkJoinPool;

public class SquareArrayAction extends RecursiveAction {

    private static final int THRESHOLD = 1000;
    private final int[] array;
    private final int start;
    private final int end;

    public SquareArrayAction(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected void compute() {
        int length = end - start;

        // அடிப்படை நிலை: துணை-அணிவரிசை போதுமான அளவு சிறியதாக இருந்தால், அதை வரிசையாக மாற்றவும்
        if (length <= THRESHOLD) {
            sequentialSquare(array, start, end);
            return; // திரும்பத் தர எந்த முடிவும் இல்லை
        }

        // சுழல்நிலை நிலை: பணியைப் பிரிக்கவும்
        int mid = start + length / 2;

        SquareArrayAction leftAction = new SquareArrayAction(array, start, mid);
        SquareArrayAction rightAction = new SquareArrayAction(array, mid, end);

        // இரு துணை-செயல்பாடுகளையும் ஃபோர்க் செய்யவும்
        // பல ஃபோர்க் செய்யப்பட்ட பணிகளுக்கு invokeAll பயன்படுத்துவது பெரும்பாலும் திறமையானது
        invokeAll(leftAction, rightAction);

        // invokeAll க்குப் பிறகு, இடைப்பட்ட முடிவுகளைச் சார்ந்திராவிட்டால் வெளிப்படையான ஜாயின் தேவையில்லை
        // நீங்கள் தனித்தனியாக ஃபோர்க் செய்து பின்னர் ஜாயின் செய்தால்:
        // leftAction.fork();
        // rightAction.fork();
        // leftAction.join();
        // rightAction.join();
    }

    private void sequentialSquare(int[] array, int start, int end) {
        for (int i = start; i < end; i++) {
            array[i] = array[i] * array[i];
        }
    }

    public static void main(String[] args) {
        int[] data = new int[1000000];
        for (int i = 0; i < data.length; i++) {
            data[i] = (i % 50) + 1; // 1 முதல் 50 வரையிலான மதிப்புகள்
        }

        ForkJoinPool pool = ForkJoinPool.commonPool();
        SquareArrayAction action = new SquareArrayAction(data, 0, data.length);

        System.out.println("Squaring array elements...");
        long startTime = System.nanoTime();
        pool.invoke(action); // invoke() செயல்பாடுகளுக்கும் நிறைவுக்காக காத்திருக்கிறது
        long endTime = System.nanoTime();

        System.out.println("Array transformation complete.");
        System.out.println("Time taken: " + (endTime - startTime) / 1_000_000 + " ms");

        // சரிபார்க்க முதல் சில உறுப்புகளை விருப்பமாக அச்சிடவும்
        // System.out.println("First 10 elements after squaring:");
        // for (int i = 0; i < 10; i++) {
        //     System.out.print(data[i] + " ");
        // }
        // System.out.println();
    }
}

இங்குள்ள முக்கிய குறிப்புகள்:

• compute() முறை நேரடியாக அணிவரிசை உறுப்புகளை மாற்றுகிறது.
• invokeAll(leftAction, rightAction) என்பது ஒரு பயனுள்ள முறையாகும், இது இரு பணிகளையும் ஃபோர்க் செய்து பின்னர் அவற்றை ஜாயின் செய்கிறது. இது தனித்தனியாக ஃபோர்க் செய்து பின்னர் ஜாயின் செய்வதை விட பெரும்பாலும் திறமையானது.

மேம்பட்ட ஃபோர்க்-ஜாயின் கருத்துகள் மற்றும் சிறந்த நடைமுறைகள்

ஃபோர்க்-ஜாயின் கட்டமைப்பு சக்திவாய்ந்ததாக இருந்தாலும், அதில் தேர்ச்சி பெறுவதற்கு இன்னும் சில நுணுக்கங்களைப் புரிந்துகொள்வது அவசியம்:

1. சரியான வரம்பைத் தேர்ந்தெடுத்தல்

THRESHOLD மிக முக்கியமானது. அது மிகவும் குறைவாக இருந்தால், பல சிறிய பணிகளை உருவாக்குவதிலும் நிர்வகிப்பதிலும் அதிக மேல்சுமையை (overhead) நீங்கள் சந்திப்பீர்கள். அது மிகவும் அதிகமாக இருந்தால், நீங்கள் பல மையங்களை திறம்பட பயன்படுத்த மாட்டீர்கள், மேலும் இணைச் செயலாக்கத்தின் நன்மைகள் குறைக்கப்படும். உலகளாவிய மந்திர எண் எதுவும் இல்லை; உகந்த வரம்பு பெரும்பாலும் குறிப்பிட்ட பணி, தரவின் அளவு மற்றும் அடிப்படை வன்பொருளைப் பொறுத்தது. பரிசோதனை செய்வது முக்கியம். ஒரு நல்ல தொடக்கப் புள்ளி பெரும்பாலும் வரிசைமுறையான செயல்பாட்டிற்கு சில மில்லி விநாடிகள் எடுக்கும் ஒரு மதிப்பாகும்.

2. அதிகப்படியான ஃபோர்க்கிங் மற்றும் ஜாயினிங்கைத் தவிர்த்தல்

அடிக்கடி மற்றும் தேவையற்ற ஃபோர்க்கிங் மற்றும் ஜாயினிங் செயல்திறன் குறைவுக்கு வழிவகுக்கும். ஒவ்வொரு fork() அழைப்பும் பூலில் ஒரு பணியைச் சேர்க்கிறது, மேலும் ஒவ்வொரு join() அழைப்பும் ஒரு திரெட்டைத் தடுக்கக்கூடும். எப்போது ஃபோர்க் செய்வது, எப்போது நேரடியாகக் கணக்கிடுவது என்பதை உத்தி ரீதியாக முடிவு செய்யுங்கள். SumArrayTask எடுத்துக்காட்டில் காணப்படுவது போல, ஒரு கிளையை நேரடியாகக் கணக்கிடும்போது மற்றொன்றை ஃபோர்க் செய்வது திரெட்களை பிஸியாக வைத்திருக்க உதவும்.

3. invokeAll ஐப் பயன்படுத்துதல்

உங்களிடம் பல துணைப் பணிகள் இருக்கும்போது, அவை சுதந்திரமானவை மற்றும் நீங்கள் தொடர்வதற்கு முன் முடிக்கப்பட வேண்டும் என்றால், ஒவ்வொரு பணியையும் கைமுறையாக ஃபோர்க் செய்து ஜாயின் செய்வதை விட invokeAll பொதுவாக விரும்பப்படுகிறது. இது பெரும்பாலும் சிறந்த திரெட் பயன்பாடு மற்றும் சுமை சமநிலைக்கு வழிவகுக்கிறது.

4. விதிவிலக்குகளைக் கையாளுதல்

ஒரு compute() முறைக்குள் எறியப்படும் விதிவிலக்குகள், நீங்கள் பணியை join() அல்லது invoke() செய்யும்போது ஒரு RuntimeException (பெரும்பாலும் ஒரு CompletionException) இல் மூடப்பட்டிருக்கும். நீங்கள் இந்த விதிவிலக்குகளை பிரித்து எடுத்து சரியான முறையில் கையாள வேண்டும்.

try {
    Long result = pool.invoke(task);
} catch (CompletionException e) {
    // பணியால் எறியப்பட்ட விதிவிலக்கைக் கையாளவும்
    Throwable cause = e.getCause();
    if (cause instanceof IllegalArgumentException) {
        // குறிப்பிட்ட விதிவிலக்குகளைக் கையாளவும்
    } else {
        // மற்ற விதிவிலக்குகளைக் கையாளவும்
    }
}

5. பொதுவான பூலைப் புரிந்துகொள்ளுதல்

பெரும்பாலான பயன்பாடுகளுக்கு, ForkJoinPool.commonPool() ஐப் பயன்படுத்துவது பரிந்துரைக்கப்படும் அணுகுமுறையாகும். இது பல பூல்களை நிர்வகிப்பதன் மேல்சுமையைத் தவிர்க்கிறது மற்றும் உங்கள் பயன்பாட்டின் வெவ்வேறு பகுதிகளிலிருந்து வரும் பணிகள் ஒரே திரெட் பூலைப் பகிர்ந்து கொள்ள அனுமதிக்கிறது. இருப்பினும், உங்கள் பயன்பாட்டின் மற்ற பகுதிகளும் பொதுவான பூலைப் பயன்படுத்தக்கூடும் என்பதை நினைவில் கொள்ளுங்கள், இது கவனமாக நிர்வகிக்கப்படாவிட்டால் போட்டிக்கு வழிவகுக்கும்.

6. ஃபோர்க்-ஜாயினை எப்போது பயன்படுத்தக்கூடாது

ஃபோர்க்-ஜாயின் கட்டமைப்பு கணக்கீடு சார்ந்த (compute-bound) பணிகளுக்காக உகந்ததாக்கப்பட்டுள்ளது, அவற்றை திறம்பட சிறிய, சுழல்நிலை துண்டுகளாக உடைக்க முடியும். இது பொதுவாகப் பின்வருவனவற்றிற்குப் பொருந்தாது:

• I/O-சார்ந்த பணிகள்: வெளி வளங்களுக்காக (நெட்வொர்க் அழைப்புகள் அல்லது வட்டு வாசிப்பு/எழுதுதல் போன்றவை) தங்கள் நேரத்தின் பெரும்பகுதியை செலவிடும் பணிகள், ஒத்திசைவற்ற நிரலாக்க மாதிரிகள் அல்லது கணக்கீட்டிற்குத் தேவையான வொர்க்கர் திரெட்களைக் கட்டிப்போடாமல் தடுக்கும் செயல்பாடுகளை நிர்வகிக்கும் பாரம்பரிய திரெட் பூல்கள் மூலம் சிறப்பாகக் கையாளப்படுகின்றன.
• சிக்கலான சார்புகளுடன் கூடிய பணிகள்: துணைப் பணிகளுக்கு சிக்கலான, சுழல்நிலை அல்லாத சார்புகள் இருந்தால், மற்ற ஒருங்கமைவு முறைகள் மிகவும் பொருத்தமானதாக இருக்கலாம்.
• மிகக் குறுகிய பணிகள்: பணிகளை உருவாக்குவதற்கும் நிர்வகிப்பதற்கும் ஆகும் மேல்சுமை, மிகக் குறுகிய செயல்பாடுகளுக்கான நன்மைகளை விட அதிகமாக இருக்கலாம்.

உலகளாவிய பரிசீலனைகள் மற்றும் பயன்பாட்டு நிகழ்வுகள்

ஃபோர்க்-ஜாயின் கட்டமைப்பின் பல்-மைய செயலிகளை திறம்படப் பயன்படுத்தும் திறன், உலகளாவிய பயன்பாடுகளுக்கு அதை விலைமதிப்பற்றதாக ஆக்குகிறது, அவை பெரும்பாலும் பின்வருவனவற்றைக் கையாளுகின்றன:

• பெரிய அளவிலான தரவு செயலாக்கம்: கண்டங்கள் முழுவதும் விநியோக வழிகளை மேம்படுத்த வேண்டிய ஒரு உலகளாவிய தளவாட நிறுவனத்தை கற்பனை செய்து பாருங்கள். ஃபோர்க்-ஜாயின் கட்டமைப்பு, பாதை மேம்படுத்தல் நெறிமுறைகளில் உள்ள சிக்கலான கணக்கீடுகளை இணைப்படுத்தப் பயன்படுத்தப்படலாம்.
• நிகழ்நேர பகுப்பாய்வு: ஒரு நிதி நிறுவனம் பல்வேறு உலகளாவிய பரிவர்த்தனைகளிலிருந்து சந்தைத் தரவை ஒரே நேரத்தில் செயலாக்கவும் பகுப்பாய்வு செய்யவும் இதைப் பயன்படுத்தலாம், இது நிகழ்நேர நுண்ணறிவுகளை வழங்குகிறது.
• படம் மற்றும் ஊடக செயலாக்கம்: உலகெங்கிலும் உள்ள பயனர்களுக்கு பட மறுஅளவிடுதல், வடிகட்டுதல் அல்லது வீடியோ டிரான்ஸ்கோடிங் வழங்கும் சேவைகள், இந்த செயல்பாடுகளை விரைவுபடுத்த கட்டமைப்பைப் பயன்படுத்திக் கொள்ளலாம். உதாரணமாக, ஒரு உள்ளடக்க விநியோக நெட்வொர்க் (CDN) பயனர் இருப்பிடம் மற்றும் சாதனத்தின் அடிப்படையில் வெவ்வேறு பட வடிவங்கள் அல்லது தெளிவுத்திறன்களை திறமையாகத் தயாரிக்க இதைப் பயன்படுத்தலாம்.
• அறிவியல் உருவகப்படுத்துதல்கள்: சிக்கலான உருவகப்படுத்துதல்களில் (எ.கா., வானிலை முன்னறிவிப்பு, மூலக்கூறு இயக்கவியல்) பணிபுரியும் உலகின் வெவ்வேறு பகுதிகளில் உள்ள ஆராய்ச்சியாளர்கள், கனமான கணக்கீட்டுச் சுமையை இணைப்படுத்தும் கட்டமைப்பின் திறனிலிருந்து பயனடையலாம்.

ஒரு உலகளாவிய பார்வையாளர்களுக்காக உருவாக்கும்போது, செயல்திறன் மற்றும் பதிலளிப்புத் தன்மை ஆகியவை முக்கியமானவை. ஃபோர்க்-ஜாயின் கட்டமைப்பு, உங்கள் ஜாவா பயன்பாடுகள் திறம்பட அளவிடப்படுவதையும், உங்கள் பயனர்களின் புவியியல் பரவல் அல்லது உங்கள் கணினிகளில் வைக்கப்பட்டுள்ள கணக்கீட்டுத் தேவைகளைப் பொருட்படுத்தாமல் ஒரு தடையற்ற அனுபவத்தை வழங்குவதையும் உறுதிசெய்ய ஒரு வலுவான வழிமுறையை வழங்குகிறது.

முடிவுரை

ஃபோர்க்-ஜாயின் கட்டமைப்பு என்பது நவீன ஜாவா உருவாக்குநரின் ஆயுதக் களஞ்சியத்தில், கணக்கீட்டு ரீதியாகச் செறிவான பணிகளை இணையாகச் சமாளிப்பதற்கான ஒரு இன்றியமையாத கருவியாகும். பிரித்து-வெல்லும் உத்தியை ஏற்றுக்கொள்வதன் மூலமும், ForkJoinPool க்குள் வேலை-திருடலின் சக்தியைப் பயன்படுத்துவதன் மூலமும், உங்கள் பயன்பாடுகளின் செயல்திறனையும் அளவிடுதலையும் கணிசமாக மேம்படுத்தலாம். RecursiveTask மற்றும் RecursiveAction ஐ எவ்வாறு சரியாக வரையறுப்பது, பொருத்தமான வரம்புகளைத் தேர்ந்தெடுப்பது மற்றும் பணிச் சார்புகளை நிர்வகிப்பது என்பதைப் புரிந்துகொள்வது, பல்-மைய செயலிகளின் முழு ஆற்றலையும் திறக்க உங்களை அனுமதிக்கும். உலகளாவிய பயன்பாடுகள் சிக்கலானதாகவும் தரவு அளவிலும் தொடர்ந்து வளர்ந்து வருவதால், ஃபோர்க்-ஜாயின் கட்டமைப்பில் தேர்ச்சி பெறுவது, உலகளாவிய பயனர் தளத்திற்கு ஏற்ற திறமையான, பதிலளிக்கக்கூடிய மற்றும் உயர் செயல்திறன் கொண்ட மென்பொருள் தீர்வுகளை உருவாக்குவதற்கு அவசியமாகும்.

உங்கள் பயன்பாட்டிற்குள் சுழல்நிலை முறையில் பிரிக்கக்கூடிய கணக்கீடு சார்ந்த பணிகளைக் கண்டறிவதன் மூலம் தொடங்குங்கள். கட்டமைப்பைப் பரிசோதிக்கவும், செயல்திறன் ஆதாயங்களை அளவிடவும், உகந்த முடிவுகளை அடைய உங்கள் செயலாக்கங்களைச் செம்மைப்படுத்தவும். திறமையான இணைச் செயல்பாட்டிற்கான பயணம் தொடர்கிறது, மேலும் ஃபோர்க்-ஜாயின் கட்டமைப்பு அந்தப் பாதையில் ஒரு நம்பகமான துணை.