थ्रेड पूल के उपयोग को कॉन्फ़िगर करने के लिए एक संगत तरीका है या नहीं, इसके बाद मैं क्या हूं। आदर्श रूप से बाकी कोड बिल्कुल भी प्रभावित नहीं होना चाहिए। मैं 1 थ्रेड के साथ एक थ्रेड पूल का उपयोग कर सकता हूं लेकिन यह वह नहीं है जो मैं चाहता हूं। कोई विचार?
ExecutorService es = threads == 0 ? new CurrentThreadExecutor() : Executors.newThreadPoolExecutor(threads);
// es.execute / es.submit / new ExecutorCompletionService(es) etc
जवाबों:
यहां वास्तव में सरल है Executor(आप नहीं ExecutorService, मन) कार्यान्वयन जो केवल वर्तमान धागे का उपयोग करता है। इसे "जावा कॉन्सैरेसी इन प्रैक्टिस" (आवश्यक पढ़ना) से चोरी करना।
public class CurrentThreadExecutor implements Executor {
public void execute(Runnable r) {
r.run();
}
}
ExecutorService एक अधिक विस्तृत इंटरफ़ेस है, लेकिन उसी दृष्टिकोण के साथ संभाला जा सकता है।
AbstractExecutorServiceजाने का रास्ता दिखता है।
Runnable::run
आप अमरूद का उपयोग कर सकते हैं MoreExecutors.newDirectExecutorService(), या MoreExecutors.directExecutor()यदि आपको इसकी आवश्यकता नहीं है ExecutorService।
यदि अमरूद बहुत भारी-भरकम है, तो आप कुछ अच्छा कर सकते हैं:
public final class SameThreadExecutorService extends ThreadPoolExecutor {
private final CountDownLatch signal = new CountDownLatch(1);
private SameThreadExecutorService() {
super(1, 1, 0, TimeUnit.DAYS, new SynchronousQueue<Runnable>(),
new ThreadPoolExecutor.CallerRunsPolicy());
}
@Override public void shutdown() {
super.shutdown();
signal.countDown();
}
public static ExecutorService getInstance() {
return SingletonHolder.instance;
}
private static class SingletonHolder {
static ExecutorService instance = createInstance();
}
private static ExecutorService createInstance() {
final SameThreadExecutorService instance
= new SameThreadExecutorService();
// The executor has one worker thread. Give it a Runnable that waits
// until the executor service is shut down.
// All other submitted tasks will use the RejectedExecutionHandler
// which runs tasks using the caller's thread.
instance.submit(new Runnable() {
@Override public void run() {
boolean interrupted = false;
try {
while (true) {
try {
instance.signal.await();
break;
} catch (InterruptedException e) {
interrupted = true;
}
}
} finally {
if (interrupted) {
Thread.currentThread().interrupt();
}
}
}});
return Executors.unconfigurableScheduledExecutorService(instance);
}
}मैं एक के ExecutorServiceआधार पर लिखा था AbstractExecutorService।
/**
* Executes all submitted tasks directly in the same thread as the caller.
*/
public class SameThreadExecutorService extends AbstractExecutorService {
//volatile because can be viewed by other threads
private volatile boolean terminated;
@Override
public void shutdown() {
terminated = true;
}
@Override
public boolean isShutdown() {
return terminated;
}
@Override
public boolean isTerminated() {
return terminated;
}
@Override
public boolean awaitTermination(long theTimeout, TimeUnit theUnit) throws InterruptedException {
shutdown(); // TODO ok to call shutdown? what if the client never called shutdown???
return terminated;
}
@Override
public List<Runnable> shutdownNow() {
return Collections.emptyList();
}
@Override
public void execute(Runnable theCommand) {
theCommand.run();
}
}terminatedफ़ील्ड कोड के आधार पर सिंक्रनाइज़ एक्सेस से लाभान्वित नहीं होगा जो वास्तव में यहाँ है। 32-बिट क्षेत्रों पर संचालन जावा में परमाणु हैं।
आप कार्य को मौजूदा थ्रेड में चलाने के लिए RejectExecutionHandler का उपयोग कर सकते हैं।
public static final ThreadPoolExecutor CURRENT_THREAD_EXECUTOR = new ThreadPoolExecutor(0, 0, 0, TimeUnit.DAYS, new SynchronousQueue<Runnable>(), new RejectedExecutionHandler() {
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
r.run();
}
});आपको केवल इनमें से किसी एक की आवश्यकता है।
java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy।
मुझे परीक्षण प्रयोजनों के लिए उसी "CurrentThreadExecutorService" का उपयोग करना था और, हालांकि सभी सुझाए गए समाधान अच्छे थे (विशेष रूप से एक अमरूद रास्ते का उल्लेख करते हुए ), मैं पीटर लॉरी द्वारा यहां सुझाए गए समान के साथ आया था ।
जैसा कि यहां एक्सल ज़िग्लर ने उल्लेख किया है , दुर्भाग्य से पीटर का समाधान वास्तव ThreadPoolExecutorमें maximumPoolSizeनिर्माण पैरामीटर (यानी maximumPoolSizeनहीं हो सकता <=0) पर पेश किए गए चेक के कारण काम नहीं करेगा ।
इसे दरकिनार करने के लिए, मैंने निम्नलिखित कार्य किया:
private static ExecutorService currentThreadExecutorService() {
CallerRunsPolicy callerRunsPolicy = new ThreadPoolExecutor.CallerRunsPolicy();
return new ThreadPoolExecutor(0, 1, 0L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), callerRunsPolicy) {
@Override
public void execute(Runnable command) {
callerRunsPolicy.rejectedExecution(command, this);
}
};
}