threadpool

Is there a Java class such that: Executable tasks can be added via an id, where all tasks with the same id are guaranteed to never run concurrently The number of threads can be limited to a fixed amount A naive solution of a Map would easily solve (1), but it would be difficult to manage (2). Similarly, all thread pooling classes that I know of will pull from a single queue, meaning (1) is not guaranteed. Solutions involving external libraries are welcome. If you don't find something that does this out of the box, it shouldn't be hard to roll your own. One thing you could do is to wrap each

MSDN, as well as many other sources, claim that worker threads in the thread pool are always background. "Thread pool threads are background threads." (MSDN) "Pooled threads are always background threads." (Threading in C#, Joseph Albahari) I can easily make the worker thread non-background by setting Thread.CurrentThread.IsBackground = false; And the application will be waiting until the thread finishes. What's wrong with that? When does the thread finish? When your method ends? I highly doubt that's the case. The whole point of the thread pool is that once your thread is finished, it gets

I have a asp.net webform which writes about 25-30 items(has info required when user makes follow up request from the form) into a custom cache. Currently all this happens synchronously on the main thread. But at higher loads addcache is becoming a bottleneck. How can i run this task in the background without consuming threads from the asp.net worker process thread pool. Jupaol Alternatives: Completely async: Call the server code using AJAX from the client, and add code to monitor the process of the call I just added an answer related to this process: https://stackoverflow.com/a/11524718

Currently I have a ScheduledThreadPoolExecutor which can execute a callable at a fixed rate. scheduledThreadPoolExecutor.scheduleAtFixedRate(callable, delay, waitNano, TimeUnit.NANOSECONDS); My team wants to add some randomess into the waitNano. Currently it is 1000. But we want the wait second to be 900, 1100, 800, 1200, for example. The average wait time is still 1000 but the wait second is randomly distributed, (for example like a Bell curve). I am wondering is this functionality already in java? If I have to write my own "scheduler" which has this random-waiting behavior, what do you guys

I want to launch a lot of tasks to run on a database of +-42Mio records. I want to run this in batches of 5000 records/time (results in 850 tasks). I also want to limit the number of threads (to 16) java starts to do this for me and I am using the current code to accomplish this task: ExecutorService executorService = Executors.newFixedThreadPool(16); for (int j = 1; j < 900 + 1; j++) { int start = (j - 1) * 5000; int stop = (j) * 5000- 1; FetcherRunner runner = new FetcherRunner(routes, start, stop); executorService.submit(runner); Thread t = new Thread(runner); threadsList.add(t); t.start();