जावा: एक्सेकॉर्स सर्विस जो एक निश्चित कतार आकार के बाद जमा करने पर रोकती है

Question 1

मैं एक समाधान को कोड करने की कोशिश कर रहा हूं जिसमें एक एकल धागा I / O- गहन कार्यों का उत्पादन करता है जो समानांतर में किया जा सकता है। प्रत्येक कार्य में महत्वपूर्ण मेमोरी डेटा होता है। इसलिए मैं उन कार्यों को सीमित करना चाहता हूं जो एक पल में लंबित हैं।

अगर मैं इस तरह ThreadPoolExecutor बनाऊं:

    ThreadPoolExecutor executor = new ThreadPoolExecutor(numWorkerThreads, numWorkerThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(maxQueue));

फिर executor.submit(callable) फेंकता है RejectedExecutionExceptionजब कतार भर जाती है और सभी धागे पहले से ही व्यस्त होते हैं।

बनाने के लिए मैं क्या कर सकता हूं executor.submit(callable)जब कतार भरी हो और सभी धागे व्यस्त हों ब्लॉक ?

संपादित करें : मैंने यह कोशिश की :

executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

और यह कुछ हद तक उस प्रभाव को प्राप्त करता है जो मैं प्राप्त करना चाहता हूं, लेकिन एक अयोग्य तरीके से (मूल रूप से खारिज किए गए धागे कॉलिंग थ्रेड में चलाए जाते हैं, इसलिए यह कॉलिंग थ्रेड को अधिक सबमिट करने से रोकता है)।

EDIT: (प्रश्न पूछने के 5 साल बाद)

इस प्रश्न और इसके उत्तर को पढ़ने वाले किसी व्यक्ति के लिए, कृपया एक सही समाधान के रूप में स्वीकृत उत्तर को न लें। कृपया सभी उत्तर और टिप्पणियों के माध्यम से पढ़ें।

Question 2

मैंने भी यही किया है। ट्रिक एक ब्लॉकिंग क्यू बनाने के लिए है जहां प्रस्ताव () विधि वास्तव में एक पुट () है। (आप जो चाहें आधार ब्लॉकिंग का उपयोग कर सकते हैं, जो आप चाहते हैं)।

public class LimitedQueue<E> extends LinkedBlockingQueue<E> 
{
    public LimitedQueue(int maxSize)
    {
        super(maxSize);
    }

    @Override
    public boolean offer(E e)
    {
        // turn offer() and add() into a blocking calls (unless interrupted)
        try {
            put(e);
            return true;
        } catch(InterruptedException ie) {
            Thread.currentThread().interrupt();
        }
        return false;
    }

}

ध्यान दें कि यह केवल थ्रेड पूल के लिए काम करता है जहां पर corePoolSize==maxPoolSizeवहां सावधान रहें (टिप्पणियां देखें)।

Question 3

यहाँ मैंने इसे अपने अंत में हल किया है:

(नोट: यह समाधान कॉल करने योग्य थ्रेड को ब्लॉक करता है, इसलिए यह RejectExecutionException को फेंकने से रोकता है)

public class BoundedExecutor extends ThreadPoolExecutor{

    private final Semaphore semaphore;

    public BoundedExecutor(int bound) {
        super(bound, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        semaphore = new Semaphore(bound);
    }

    /**Submits task to execution pool, but blocks while number of running threads 
     * has reached the bound limit
     */
    public <T> Future<T> submitButBlockIfFull(final Callable<T> task) throws InterruptedException{

        semaphore.acquire();            
        return submit(task);                    
    }


    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);

        semaphore.release();
    }
}

Question 4

वर्तमान में स्वीकार किए गए उत्तर में संभावित रूप से महत्वपूर्ण समस्या है - यह थ्रेडपूल एक्सक्यूटर के व्यवहार को बदल देता है। ऐसा करें कि यदि आपके पास ए corePoolSize < maxPoolSize, थ्रेडपूल एक्जिक्यूटर तर्क है तो कोर से परे अतिरिक्त श्रमिकों को कभी नहीं जोड़ा जाएगा।

से ThreadPoolExecutor .execute (Runnable):

    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    else if (!addWorker(command, false))
        reject(command);

विशेष रूप से, कि पिछले 'और' ब्लॉक विल कभी नहीं मारा जाएगा।

एक बेहतर विकल्प यह है कि ओपी पहले से जो कुछ कर रहा है, उसके समान ही करें - समान तर्क करने के लिए एक RejectExecutionHandler का उपयोग करें put:

public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
    try {
        if (!executor.isShutdown()) {
            executor.getQueue().put(r);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new RejectedExecutionException("Executor was interrupted while the task was waiting to put on work queue", e);
    }
}

इस दृष्टिकोण के साथ देखने के लिए कुछ चीजें हैं, जैसा कि टिप्पणियों में बताया गया है ( इस उत्तर का संदर्भ देते हुए ):

यदि corePoolSize==0, तो एक दौड़ की स्थिति है जहां पूल में सभी धागे कार्य दिखाई देने से पहले मर सकते हैं
एक कार्यान्वयन का उपयोग करना जो कतार के कार्यों को लपेटता है (लागू नहीं है ThreadPoolExecutor) उन मुद्दों पर परिणाम देगा जब तक कि हैंडलर भी उसी तरह से लपेटता नहीं है।

उन गोचरों को ध्यान में रखते हुए, यह समाधान सबसे विशिष्ट थ्रेडपूल एक्सक्यूटर्स के लिए काम करेगा, और जहां मामले को ठीक से संभाल लेगा corePoolSize < maxPoolSize।

Question 5

मुझे पता है कि यह एक पुराना सवाल है, लेकिन एक समान मुद्दा यह था कि नए कार्यों का निर्माण बहुत तेज था और अगर बहुत सारे आउटऑफमेरीऑरर होते हैं, क्योंकि मौजूदा कार्य तेजी से पूरा नहीं हुआ था।

मेरे मामले में Callables में प्रस्तुत किए जाते हैं और मुझे परिणाम की आवश्यकता होती है इसलिए मुझे सभी Futuresलौटे हुए स्टोर करने की आवश्यकता होती है executor.submit()। मेरा समाधान अधिकतम आकार के साथ Futuresमें डालना था BlockingQueue। एक बार जब कतार पूरी हो जाती है, तो कुछ पूर्ण होने तक अधिक कार्य नहीं किए जाते हैं (कतार से हटाए गए तत्व)। छद्म कोड में:

final ExecutorService executor = Executors.newFixedThreadPool(numWorkerThreads);
final LinkedBlockingQueue<Future> futures = new LinkedBlockingQueue<>(maxQueueSize);
try {   
    Thread taskGenerator = new Thread() {
        @Override
        public void run() {
            while (reader.hasNext) {
                Callable task = generateTask(reader.next());
                Future future = executor.submit(task);
                try {
                    // if queue is full blocks until a task
                    // is completed and hence no future tasks are submitted.
                    futures.put(compoundFuture);
                } catch (InterruptedException ex) {
                    Thread.currentThread().interrupt();         
                }
            }
        executor.shutdown();
        }
    }
    taskGenerator.start();

    // read from queue as long as task are being generated
    // or while Queue has elements in it
    while (taskGenerator.isAlive()
                    || !futures.isEmpty()) {
        Future compoundFuture = futures.take();
        // do something
    }
} catch (InterruptedException ex) {
    Thread.currentThread().interrupt();     
} catch (ExecutionException ex) {
    throw new MyException(ex);
} finally {
    executor.shutdownNow();
}

Question 6

मुझे भी इसी तरह की समस्या थी और मैंने इसे beforeExecute/afterExecuteहुक से इस्तेमाल करके लागू कियाThreadPoolExecutor :

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Blocks current task execution if there is not enough resources for it.
 * Maximum task count usage controlled by maxTaskCount property.
 */
public class BlockingThreadPoolExecutor extends ThreadPoolExecutor {

    private final ReentrantLock taskLock = new ReentrantLock();
    private final Condition unpaused = taskLock.newCondition();
    private final int maxTaskCount;

    private volatile int currentTaskCount;

    public BlockingThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
            long keepAliveTime, TimeUnit unit,
            BlockingQueue<Runnable> workQueue, int maxTaskCount) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        this.maxTaskCount = maxTaskCount;
    }

    /**
     * Executes task if there is enough system resources for it. Otherwise
     * waits.
     */
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        taskLock.lock();
        try {
            // Spin while we will not have enough capacity for this job
            while (maxTaskCount < currentTaskCount) {
                try {
                    unpaused.await();
                } catch (InterruptedException e) {
                    t.interrupt();
                }
            }
            currentTaskCount++;
        } finally {
            taskLock.unlock();
        }
    }

    /**
     * Signalling that one more task is welcome
     */
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        taskLock.lock();
        try {
            currentTaskCount--;
            unpaused.signalAll();
        } finally {
            taskLock.unlock();
        }
    }
}

यह आपके लिए काफी अच्छा होना चाहिए। Btw, मूल कार्यान्वयन कार्य आकार आधारित था क्योंकि एक कार्य दूसरे की तुलना में 100 गुना बड़ा हो सकता है और दो विशाल कार्यों को प्रस्तुत करना बॉक्स को मार सकता था, लेकिन एक बड़ा और बहुत छोटा चलना ठीक था। यदि आपके I / O- गहन कार्य लगभग एक ही आकार के हैं तो आप इस वर्ग का उपयोग कर सकते हैं, अन्यथा बस मुझे बताएं और मैं आकार आधारित कार्यान्वयन पोस्ट करूंगा।

PS आप ThreadPoolExecutorjavadoc की जांच करना चाहेंगे । यह डौग ली से वास्तव में अच्छा उपयोगकर्ता गाइड है कि इसे आसानी से कैसे अनुकूलित किया जा सकता है।

Question 7

मैंने डेकोरेटर पैटर्न के बाद एक समाधान लागू किया है और निष्पादित कार्यों की संख्या को नियंत्रित करने के लिए एक सेमाफोर का उपयोग किया है। आप इसे किसी भी Executorऔर के साथ उपयोग कर सकते हैं :

चल रहे कार्यों की अधिकतम निर्दिष्ट करें
कार्य निष्पादन परमिट के लिए प्रतीक्षा करने के लिए अधिकतम समय-निर्धारण निर्दिष्ट करें (यदि समय-सीमा गुजरती है और कोई परमिट प्राप्त नहीं होता है, तो एक RejectedExecutionExceptionफेंक दिया जाता है)

import static java.util.concurrent.TimeUnit.MILLISECONDS;

import java.time.Duration;
import java.util.Objects;
import java.util.concurrent.Executor;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.Semaphore;

import javax.annotation.Nonnull;

public class BlockingOnFullQueueExecutorDecorator implements Executor {

    private static final class PermitReleasingDecorator implements Runnable {

        @Nonnull
        private final Runnable delegate;

        @Nonnull
        private final Semaphore semaphore;

        private PermitReleasingDecorator(@Nonnull final Runnable task, @Nonnull final Semaphore semaphoreToRelease) {
            this.delegate = task;
            this.semaphore = semaphoreToRelease;
        }

        @Override
        public void run() {
            try {
                this.delegate.run();
            }
            finally {
                // however execution goes, release permit for next task
                this.semaphore.release();
            }
        }

        @Override
        public final String toString() {
            return String.format("%s[delegate='%s']", getClass().getSimpleName(), this.delegate);
        }
    }

    @Nonnull
    private final Semaphore taskLimit;

    @Nonnull
    private final Duration timeout;

    @Nonnull
    private final Executor delegate;

    public BlockingOnFullQueueExecutorDecorator(@Nonnull final Executor executor, final int maximumTaskNumber, @Nonnull final Duration maximumTimeout) {
        this.delegate = Objects.requireNonNull(executor, "'executor' must not be null");
        if (maximumTaskNumber < 1) {
            throw new IllegalArgumentException(String.format("At least one task must be permitted, not '%d'", maximumTaskNumber));
        }
        this.timeout = Objects.requireNonNull(maximumTimeout, "'maximumTimeout' must not be null");
        if (this.timeout.isNegative()) {
            throw new IllegalArgumentException("'maximumTimeout' must not be negative");
        }
        this.taskLimit = new Semaphore(maximumTaskNumber);
    }

    @Override
    public final void execute(final Runnable command) {
        Objects.requireNonNull(command, "'command' must not be null");
        try {
            // attempt to acquire permit for task execution
            if (!this.taskLimit.tryAcquire(this.timeout.toMillis(), MILLISECONDS)) {
                throw new RejectedExecutionException(String.format("Executor '%s' busy", this.delegate));
            }
        }
        catch (final InterruptedException e) {
            // restore interrupt status
            Thread.currentThread().interrupt();
            throw new IllegalStateException(e);
        }

        this.delegate.execute(new PermitReleasingDecorator(command, this.taskLimit));
    }

    @Override
    public final String toString() {
        return String.format("%s[availablePermits='%s',timeout='%s',delegate='%s']", getClass().getSimpleName(), this.taskLimit.availablePermits(),
                this.timeout, this.delegate);
    }
}

Question 8

मुझे लगता है कि यह ArrayBlockingQueueआ के बजाय का उपयोग करने के रूप में सरल हैLinkedBlockingQueue ।

मुझे अनदेखा करें ... यह पूरी तरह से गलत है। ThreadPoolExecutorकॉल Queue#offerनहींput जो आप की आवश्यकता होती है प्रभाव होगा।

आप के स्थान पर उस कॉल ThreadPoolExecutorका कार्यान्वयन और विस्तार कर सकते हैंexecute(Runnable)putoffer ।

मुझे लगता है कि मैं पूरी तरह से संतोषजनक जवाब की तरह नहीं हूँ।