As you see from the JavaDoc execute(Runnable) does not return anything. However, submit(Callable<T>) returns a Future object which allows a way for you to programatically cancel the running thread later as well as get the T that is returned when the Callable completes. See JavaDoc of Future for more details Future<?> future = executor.submit(longRunningJob); … … Read more
A CachedThreadPool seems appropriate for your situation as there are no negative consequence to using one for long running threads directly. The comment in the java doc about CachedThreadPools being suitable for short tasks merely suggest that they are particularly appropriate for such cases, not that they cannot be used for long running tasks. The … Read more
Other answers here seem to be leaving out the most important point: Unless you are trying to parallelize a CPU-intensive operation in order to get it done faster on a low-load site, there is no point in using a worker thread at all. That goes for both free threads, created by new Thread(…), and worker … Read more
I would suggest you use a thread pool in C# for the same reasons as any other language. When you want to limit the number of threads running or don’t want the overhead of creating and destroying them, use a thread pool. By small tasks, the book you read means tasks with a short lifetime. … Read more
Question 1: I changed this from the original because the original was wrong. I was under the impression that Linux thread creation was very cheap and after testing I determined that the overhead of function call in a new thread vs. a normal one is enormous. The overhead for creating a thread to handle a … Read more
Using Thread.currentThread(): private class MyTask implements Runnable { public void run() { long threadId = Thread.currentThread().getId(); logger.debug(“Thread # ” + threadId + ” is doing this task”); } }
Thread pool will provide benefits for frequent and relatively short operations by Reusing threads that have already been created instead of creating new ones (an expensive process) Throttling the rate of thread creation when there is a burst of requests for new work items (I believe this is only in .NET 3.5) If you queue … Read more
This is adapted from my answer to another very similar post. Let’s build a ThreadPool class: class ThreadPool { public: void Start(); void QueueJob(const std::function<void()>& job); void Stop(); void busy(); private: void ThreadLoop(); bool should_terminate = false; // Tells threads to stop looking for jobs std::mutex queue_mutex; // Prevents data races to the job queue … Read more
The simplest approach is to use ExecutorService.invokeAll() which does what you want in a one-liner. In your parlance, you’ll need to modify or wrap ComputeDTask to implement Callable<>, which can give you quite a bit more flexibility. Probably in your app there is a meaningful implementation of Callable.call(), but here’s a way to wrap it … Read more
Guava almost always has what you need. ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat(“my-sad-thread-%d”).build() and pass it off to your ExecutorService.