threadpool

I have some old java code for a REST service that uses a separate thread for every incoming request. I.e. the main loop would loop on socket.accept() and hand off the socket to a Runnable which then would start up its own background thread and invoke run on itself. This worked admiringly well for a while until recently i noticed that the lag of accept to processing the request would get unacceptable under high load. When i say admiringly well, i mean that it was handling 100-200 requests a second without significant CPU usage. The performance only degraded when other daemons were adding load

My use of ThreadLocal In my Java classes, I sometimes make use of a ThreadLocal mainly as a means of avoiding unnecessary object creation: @net.jcip.annotations.ThreadSafe public class DateSensitiveThing { private final Date then; public DateSensitiveThing(Date then) { this.then = then; } private static final ThreadLocal<Calendar> threadCal = new ThreadLocal<Calendar>() { @Override protected Calendar initialValue() { return new GregorianCalendar(); } }; public Date doCalc(int n) { Calendar c = threadCal.get(); c.setTime(this.then): // use n to mutate c return c.getTime(); } } I do this for the

I'm really confused about async-await s, pool s and thread s. The main problem starts with this question: "What can I do when I have to handle 10k socket I/O?" (aka The C10k Problem ). First, I tried to make a custom pooling architecture with threads that uses one main Queue and multiple Thread s to process all incoming datas. It was a great experience about understanding thread-safety and multi-threading but thread is an overkill with async-await nowadays. Later, I implemented a simple architecture with async-await but I can't understand why "The async and await keywords don't cause

What are the types of thread pools in java. I need to implement a robust multi-threaded application which uses heavy computation, which thread pool should I use? There are various thread pools in java: Single Thread Executor : A thread pool with only one thread. So all the submitted tasks will be executed sequentially. Method : Executors.newSingleThreadExecutor() Cached Thread Pool : A thread pool that creates as many threads it needs to execute the task in parrallel. The old available threads will be reused for the new tasks. If a thread is not used during 60 seconds, it will be terminated

I am learning to use ExectorService to pool threads and send out tasks. I have a simple program below import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; class Processor implements Runnable { private int id; public Processor(int id) { this.id = id; } public void run() { System.out.println("Starting: " + id); try { Thread.sleep(5000); } catch (InterruptedException e) { System.out.println("sorry, being interupted, good bye!"); System.out.println("Interrupted "+Thread.currentThread().getName()); e.printStackTrace(); } System

When I run my code : nb workers = 12 I'm i : 0 HELLO I'm func1 BYE I'm func2 terminate called after throwing an instance of 'std::system_error' what(): Invalid argument Aborted (core dumped) terminate called after throwing an instance of 'std::system_error'l what(): Invalid argument #ifndef CPP_PLAZZA_EXAMPLE_H #define CPP_PLAZZA_EXAMPLE_H #include <thread> #include <vector> #include <list> #include <memory> #include <functional> #include <mutex> #include <condition_variable> #include <atomic> #include <iterator> #include <tuple> class ThreadPool { public: ThreadPool(size_t numThreads);