मैं एक उपयोगिता पुस्तकालय बनाने की कोशिश कर रहा हूं जो ThreadPoolExecutor कतार में कार्य जोड़ता है। मैं वस्तुओं की एक सूची/सरणी, एक कॉल करने योग्य फ़ंक्शन, और कॉल करने योग्य फ़ंक्शन में पारित किए जाने वाले फ़ंक्शन तर्कों की एक सूची को स्वीकार करना चाहता हूं। अब मैं इन सूची या तर्कों को फ़ंक्शन कॉल में पास करना चाहता हूं जो मैं कॉल करने योग्य इंटरफ़ेस से बना रहा हूं, लेकिन कॉल करने योग्य इंटरफ़ेस में केवल एक फ़ंक्शन है जो कोई तर्क नहीं लेता है।

क्या कोई मुझे संरचना को नया स्वरूप देने में मदद कर सकता है? मैं चाहता हूं कि इस पुस्तकालय के ग्राहक उपर्युक्त तर्कों के साथ एक एकल फ़ंक्शन को कॉल करें और पुस्तकालय को सब कुछ संभालना चाहिए।

मेरी वर्तमान कक्षा इस तरह दिखती है:

public class ThreadPoolExecutorUtils {

    private ExecutorService executorService;

    /**
     * Initialize Executor service with given number of threads
     * @param threadCount : number of threads on the thread pool
     */
    public ThreadPoolExecutorUtils(int threadCount) {
        executorService = Executors.newFixedThreadPool(threadCount);
    }

    /**
     * Add the task to the queue of current threadpool executor
     * @param callableFunc: Function to be called from every thread
     */
    public <T> void scheduleTask(Callable<T> callableFunc) {
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    callableFunc.call();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }


    /**
     * Blocks until all tasks have completed execution after a shutdown
     * request, or the timeout occurs, or the current thread is
     * interrupted, whichever happens first.
     * @param timeOutSeconds : The maximum time in seconds to wait
     */
    public void awaitCompletion(int timeOutSeconds) {
        executorService.shutdown();
        try {
            executorService.awaitTermination(timeOutSeconds, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdownNow();
        }
    }

}

इसमें, क्लाइंट को ThreadPoolExecutorUtils का ऑब्जेक्ट बनाना होता है और अपने कार्य की सूची पर पुनरावृति करना होता है और अलग-अलग कॉल करने योग्य फ़ंक्शन को पास करना होता है। मैं इसे क्लाइंट के लिए सार करना चाहता हूं।

0
karan 12 फरवरी 2019, 15:10

1 उत्तर

सबसे बढ़िया उत्तर

क्या आपने java.util.function पैकेज में से कुछ पर विचार किया है। मुझे लगता है कि यह Callable, BiConsumer या BiFunction की तुलना में आपके उपयोग के मामले के लिए अधिक उपयुक्त है। चूंकि Callable आउटपुट का उपयोग आपके उदाहरण कोड में नहीं किया गया है, इसलिए मुझे इसका उपयोग करने की आवश्यकता नहीं दिख रही है।

0
Mladen Savić 12 फरवरी 2019, 12:19