Increasing number of Threads in the Thread Pool

Hi,
Using newFixedThreadPool ( int nbThreads )_, how do I increase the number of threads allowed dynamically in my application ?
Thank you

As the name of the method implies the Pool returned by that method supports only a fixed number of threads.
If you want to be able to modify the number of threads after instantiation, then you could use a ThreadPoolExecutor. This class supports changing the number of threads it uses.

Similar Messages

IS INCREASING number of JVM = good performance on forms

Hi,
Will increasing number of JVMs make the oracle forms work faster. :). [Release is R12].
Regards
Taher

Taher,
Not necessarily -- See these documents for details.
Note: 362851.1 - Guidelines to setup the JVM in Apps Ebusiness Suite 11i and R12 (Customer Recommended)
Note: 567551.1 - Configuring various JVM tuning parameters for Oracle E-Business suite 11i and R12
Note: 415455.1 - How To Use Jconsole to Monitor JVM with Oracle E-Business Suite 11i10 and R12
Note: 763658.1 - R12: What Is the OAFM JVM Process Used For?
Regards,
Hussein

Increasing the number of thread results in core dump

Hi all ,
I am having application in C++ on Solaris and WIn NT OS . In Win Nt if the Number of Threads Spawned is 50 it's working fine but if we try the same it results in Core , but if we reduce the number of Threads spawned to 40 the application works just fine . The System configuration for WIn NT is 512 RAM and for Solaris is 1GB . Any pointers to what can be the possible reason and solution to the cause .
Regards
Rahul

Hi,
The basis sets the maximum number of pages that can be printed by the user in authorization object S_SPO_PAGE.
Please discuss with your basis guy.
Tyken

Submit submit a large number of task to a thread pool (more than 10,000)

i want to submit a large number of task to a thread pool (more than 10,000).
Since a thread pool take runnable as input i have to create as many objects of Runnable as the number of task, but since the number of task is very large it causes the memory overflow and my application crashes.
Can you suggest me some way to overcome this problem?

Ravi_Gupta wrote:
I have to serve them infinitely depending upon the choice of the user.
Take a look at my code (code of MyCustomRunnable is already posted)
public void start(Vector<String> addresses)
searching = true;What is this for? Is it a kind of comment?
>
Vector<MyCustomRunnable> runnables = new Vector<MyCustomRunnable>(1,1);
for (String address : addresses)
try
runnables.addElement(new MyCustomRunnable(address));
catch (IOException ex)
ex.printStackTrace();
}Why does MyCustomRunnable throw an IOException? Why is using up resources when it hasn't started. Why build this vector at all?
>
//ThreadPoolExecutor pool = new ThreadPoolExecutor(100,100,50000L,TimeUnit.MILLISECONDS,new LinkedBlockingQueue());
ExecutorService pool = Executors.newFixedThreadPool(100);You have 100 CPUs wow! I can only assume your operations are blocking on a Socket connection most of the time.
>
boolean interrupted = false;
Vector<Future<String>> futures = new Vector<Future<String>>(1,1);You don't save much by reusing your vector here.
for(int i=1; !interrupted; i++)You are looping here until the thread is interrupted, why are you doing this? Are you trying to generate loading on a remote server?
System.out.println("Cycle: " + i);
for(MyCustomRunnable runnable : runnables)Change the name of you Runnable as it clearly does much more than that. Typically a Runnable is executed once and does not create resources in its constructor nor have a cleanup method.
futures.addElement((Future<String>) pool.submit(runnable));Again, it unclear why you would use a vector rather than a list here.
>
for(Future<String> future : futures)
try
future.get();
catch (InterruptedException ex)
interrupted = true;If you want this to break the loop put the try/catch outside the loop.
ex.printStackTrace();
catch (ExecutionException ex)
ex.printStackTrace();If you are generating a load test you may want to record this kind of failure. e.g. count them.
futures.clear();
try
Thread.sleep(60000);Why do you sleep even if you have been interrupted? For better timing, you should sleep, before check if you futures have finished.
catch(InterruptedException e)
searching = false;again does nothing.
System.out.println("Thread pool terminated..................");
//return;remove this comment. its dangerous.
break;why do you have two way of breaking the loop. why not interrupted = true here.
searching = false;
System.out.println("Shut downing pool");
pool.shutdownNow();
try
for(MyCustomRunnable runnable : runnables)
runnable.close(); //release resources associated with it.
catch(IOException e)put the try/catch inside the loop. You may want to ignore the exception but if one fails, the rest of the resources won't get cleaned up.
The above code serve the task infinitely untill it is terminated by user.
i had created a large number of runnables and future objects and they remain in memory until
user terminates the operation might be the cause of the memory overflow.It could be the size of the resources each runnable holds. Have you tried increasing your maximum memory? e.g. -Xmx512m

Thread pool throws reject exceptions even though the queue is not full

Hi. I am using org.springframework.scheduling.concurrent.ThreadPo olTaskExecutor which is based on java
java.util.concurrent.ThreadPoolExecutor
with a enviornment under load.
I see on some cases, that this thread pool throws tasks with reject exception
even though the queue size is 0.
According to the documentation, this thread pool should increase the pool size to core size and then wait untill all queue is full to create new threads.
this is not what happends. for some reason the queue is not filled but exceptions are thrown.
Any ideas why this can happen?

This is the stack trace:
taskExecutorStats-1 2010-04-27 11:01:43,324 ERROR [com.expand.expandview.infrastructure.task_executor] TaskExecutorController: RejectedExecutionException exception in thread: 18790970, failed on thread pool: [email protected]544f07, to run logic: com.expand.expandview.infrastructure.logics.DispatchLogicsProviderLogic
org.springframework.core.task.TaskRejectedException: Executor [java.util.concurrent.ThreadPoolExecutor@dd9007] did not accept task: com.expand.expandview.infrastructure.task_executor.TaskExecuterController$1@141f728; nested exception is java.util.concurrent.RejectedExecutionException
     at org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor.execute(ThreadPoolTaskExecutor.java:305)
     at com.expand.expandview.infrastructure.task_executor.TaskExecuterController.operate(TaskExecuterController.java:68)
     at com.expand.expandview.infrastructure.proxies.DataProxy.callLogic(DataProxy.java:131)
     at com.expand.expandview.infrastructure.proxies.DataProxy.operate(DataProxy.java:109)
     at com.expand.expandview.infrastructure.logics.AbstractLogic.operate(AbstractLogic.java:455)
     at com.expand.expandview.server.app.logics.stats.StatsPersisterSingleChunkLogic.persistSlots(StatsPersisterSingleChunkLogic.java:362)
     at com.expand.expandview.server.app.logics.stats.StatsPersisterSingleChunkLogic.doLogic(StatsPersisterSingleChunkLogic.java:132)
     at com.expand.expandview.infrastructure.logics.AbstractLogic.execute(AbstractLogic.java:98)
     at com.expand.expandview.server.app.logics.ApplicationLogic.execute(ApplicationLogic.java:79)
     at com.expand.expandview.infrastructure.task_executor.TaskExecuterControllerDirect.operate(TaskExecuterControllerDirect.java:33)
     at com.expand.expandview.infrastructure.proxies.LogicProxy.service(LogicProxy.java:62)
     at com.expand.expandview.infrastructure.logics.AbstractLogic.service(AbstractLogic.java:477)
     at com.expand.expandview.server.app.logics.stats.StatsPersisterLogic.persist(StatsPersisterLogic.java:48)
     at com.expand.expandview.server.app.logics.stats.StatsPersisterLogic.doLogic(StatsPersisterLogic.java:19)
     at com.expand.expandview.infrastructure.logics.AbstractLogic.execute(AbstractLogic.java:98)
     at com.expand.expandview.server.app.logics.ApplicationLogic.execute(ApplicationLogic.java:79)
     at com.expand.expandview.infrastructure.task_executor.TaskExecuterController$1.run(TaskExecuterController.java:80)
     at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
     at java.lang.Thread.run(Thread.java:619)
Caused by: java.util.concurrent.RejectedExecutionException
     at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:1760)
     at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:767)
     at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:658)
     at org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor.execute(ThreadPoolTaskExecutor.java:302)
     ... 19 more

The problem in the thread pool implemented by myself

Hello, I need to a thread pool in J2ME CDC 1.0 + FP 1.0, so I implemented a simple one by myself that also meets my own requirement.
Here is the main idea:
The thread pool creates a fixed number of threads in advance. When a task comes, it is put in the waiting list. All threads tries to get the tasks from the waiting list. If no task exists, the threads wait until someone wakes them up.
Here are the requirements from myself:
1. when a task has finished its work in one execution, it is put in the waiting list for the next run.
2. the task can control the delay between when the task owner tries to put it in the waiting list and when the task is actually put in the waiting list. I need this function because sometimes I don't want the tasks to run too often and want to save some CPU usage.
In my program, I creates two thread pools. In one pool, every task don't use the delay, and the thread pool works very well. The other pool has the tasks that use the delay, and sometimes, as I can see from the printed information, there are many tasks in the waiting list but 0 or 1 thread executes tasks. It seems that the waiting threads cannot wake up when new tasks comes.
I suspect the code in addTask(), but cannot find the reason why it fails. Could anyone please help me find out the bug in my code? I put the code of thread pool below
Thank you in advance
Zheng Da
ThreadPool.java
package j2me.concurrent;
import java.util.LinkedList;
import java.util.Timer;
import java.util.TimerTask;
import alvis.general.Util;
public class ThreadPool {
     private int maxQueueSize;
     private boolean running = true;
     private Thread[] threads;
     private LinkedList tasks = new LinkedList();
     private Timer timer = new Timer(true);
     private AtomicInteger usingThreads = new AtomicInteger(0);
     private synchronized boolean isRunning() {
          return running;
     private synchronized void stopRunning() {
          running = false;
     private synchronized PoolTask getTask() {
          while (tasks.isEmpty() && isRunning()) {
               try {
                    this.wait();
               } catch (InterruptedException e) {
                    e.printStackTrace();
          if (tasks.isEmpty())
               return null;
          // Util.log.info(Thread.currentThread().getName() +
          // " gets a task, left tasks: " + tasks.size());
          return (PoolTask) tasks.removeFirst();
     private synchronized void addTaskNoDelay(PoolTask task) {
          tasks.addLast(task);
          notifyAll();
     private synchronized void addTask(final PoolTask task) {
          long delay = task.delay();
          if (delay == 0) {
               addTaskNoDelay(task);
          } else {
               timer.schedule(new TimerTask() {
                    public void run() {
                         addTaskNoDelay(task);
               }, delay);
     private synchronized int numTasks() {
          return tasks.size();
     private class PoolThread extends Thread {
          public void run() {
               Util.poolThreads.inc();
               while (isRunning()) {
                    PoolTask task = getTask();
                    if (task == null) {
                         Util.poolThreads.dec();
                         return;
                    usingThreads.inc();
                    long currentTime = System.currentTimeMillis();
                    task.run();
                    long elapsedTime = System.currentTimeMillis() - currentTime;
                    if (elapsedTime > 100)
                         System.err.println(task.toString() + " takes " + ((double) elapsedTime)/1000 + "s");
                    usingThreads.dec();
                    if (!task.finish()) {
                         addTask(task);
               Util.poolThreads.dec();
     public ThreadPool(int size, int taskQueueSize) {
          maxQueueSize = taskQueueSize;
          threads = new Thread[size];
          for (int i = 0; i < threads.length; i++) {
               threads[i] = new PoolThread();
               threads.start();
     public synchronized boolean executor(PoolTask task) {
          if (!isRunning()) {
               return false;
          Util.log.info("Thread Pool gets " + task + ", there are "
                    + numTasks() + " waiting tasks");
          if (numTasks() >= maxQueueSize) {
               return false;
          addTask(task);
          return true;
     public synchronized void destroy() {
          stopRunning();
          timer.cancel();
          // TODO: I am not sure it can wake up all threads and destroy them.
          this.notifyAll();
     public synchronized void printSnapshot() {
          System.err.println("using threads: " + usingThreads + ", remaining tasks: " + tasks.size());
PoolTask.javapackage j2me.concurrent;
public interface PoolTask extends Runnable {
     * It shows if the task has already finished.
     * If it isn't, the task will be put in the thread pool for the next execution.
     * @return
     boolean finish();
     * It shows the delay in milliseconds that the task is put in the thread pool.
     * @return
     long delay();

are receiving/sends tasks packets time consuming operation in your case or not? if it is not you do not need to use thread pools at all. you can create a queue like in your code through the linked list and dispatch this queue periodically with minimum monitor usage. try this.
import java.util.LinkedList;
public class PacketDispatcher extends Thread {
    LinkedList list = new LinkedList();
    public PacketDispatcher (String name) {
        super(name);
    public void putTask(Task task) {
        synchronized (list) {
            list
                    .add(task);
            list.notify();
    public void run() {
        while (true/* your condition */) {
            Task task = null;
            synchronized (list) {
                while (list.isEmpty())
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                task = (Task)list
                        .poll();
            if (task == null) {
                try {
                    Thread
                            .sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                continue;
            task
                    .run();
            if (!task.isFinished()) {
                putTask(task);
            Thread
                    .yield();
    public static void main(String[] args) {
        // just for test
        try {
            Thread.sleep (10000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        PacketDispatcher dispatcher = new PacketDispatcher("Packet Dispatcher");
        Task task = new Task();
        dispatcher.putTask(task);
        dispatcher.start();
        try {
            Thread.sleep (10000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        Task task2 = new Task();
        dispatcher.putTask(task2);
class Task {
    long result = 0;
    public boolean isFinished () {
        if (getResult() >= 10000000) {
            return true;
        return false;
    public void run() {
        for (int i = 0; i < 1000; i++) {
            result += i;
    public long getResult () {
        return result;
}

Limiting the number of threads that are created

I am trying to write a web crawler as a way of learning about multi-threading and I have hit a stumbling block (probably my design). The way the application I have started works is that I provide a single URL, which is passed to a thread and that thread then parses the web page building a list of links (If the links are not already held in a 'visited' list then they are saved in a list in the Runnable object that is parsing the html page).
When the page has been parsed the list of links are then passed to a method in a Utilities class that creates a new group of threads, 1 for each link and each of these threads then does the same thing. The problem I have is that as more and more links are captured more and more threads are created eventually I either get a out of memory exception or I get an operating system 'cannot create native thread' message. I am not sure if the threads are staying in memory after they have done their tasks, I am not sure why I am running out of memory so quickly.
What I would like to try and do is to set a limit for the maximum number of threads created and then only create new threads if the limit is not breached. If someone could point me in the right direction that would be good, I have googled around but cant find an example of what I want to do.
Thanks

Thanks for that, that has given me a lot to read up on and I can already see where I went wrong.... I think implementing a thread pool and also a work queue is probably the way I will go from now on.

Combining the fixed and cached thread pools

Is there a way to 'combine' the behavior of cached and fixed thread pools ? I have a requirement where
- at startup, I need to execute a fixed number of short-lived tasks at the background
- after startup, on demand, I need to run one short-lived task at a time
If I use a fixed thread pool for my startup processing, it creates the fixed number of threads to process the tasks. But subsequently, those many threads are not required since my task submission is going to be one at a time. The remaining (n-1) threads therefore are really sitting idle & useless.
If I use a cached thread pool, then I cannot constrain the number of threads to run at startup (since it creates one for each task). Though it ends up taking those threads out after they are idle for a fixed period. But I'm worried that it might create many threads and possibly slowing down the startup ?
Is there a way to create a pool with a fixed number of threads but 'remove' a set of threads when they are idle ?
TIA

v_bala wrote:
Thanks. The SynchronousQueue worked as expected. But I tried a LinkedBlockingQueue with size 1 hoping that would cause the second task submission to cause a new thread creation. It didn't. Instead it queues up the request (maybe the doc in ThreadPoolExecutor says that when it mentions "If corePoolSize or more threads are running, the Executor always prefers queuing a request rather than adding a new thread"). I suppose if I were to try another it would create another thread ? (I was testing with only two tasks - the first one ended up creating a thread for the task and the next got queued since the queue capacity is 1)yes, the TPE will not start adding threads until the queue starts rejecting them. kind of odd in my opinion, but that's how it works.
Btw, that was an interesting idea to add a task that scale the core pool number down ! Currently it comes back down to just the one thread (my core pool size is one) after the idle timeout but your idea may give me a slightly better response since it will scale down the core pool size quicker....I suppose if there was a task submission before that idle time there maybe a performance hit (but I don't anticipate that in my case )?actually, that won't scale things down any faster. changing the core pool size will not ditch the other threads immediately, they will still stick around until they idle timeout. changing the core pool size allows you to not worry about the queue implementation (the first solution). you can set the initial core pool size to your "max" size on startup, then drop it down for the normal processing, all the while using a linkedblockingqueue of unlimited size.

Tuning the good number of thread with Work Manager?

Hi,
I search some best practice or experience return on the max thread number on a weblogic managed server
I try to explain: with WLS 8.1 and execute queue it was hard to tune the good number of thread but possible (with some processor and for an application we find that after 30 concurrent thread, there's lower performance because of switch on processeur, for others it was 45 for example)
Now i can see sometimes more than 500 thread on one JVM and it seem to be very much for me!!
we face some problem of response time in PRODUCTION, i can see sometimes more than 100 Stuck thread on a resource, so i think it's the reason of bad response time. But with Work Manager, it increase the number of thread to accept others request and the CPU stay at acceptable level (less than 50%) because the stuckthread are do nothing (waiting for resource)
So i don't understand the good tuning to apply since WorkManager...ok it isn't normal to have a lot of stuck thread but if there's no matter about the max number of thread, is it useful to stop and restart managed server?
do you think we can have have bad performance if there's a lot of thread?
thank you for your experience return. If you have no idea just tell me how much thread you can see on your managed server in Production.

up, up...
we have always the same probleme in production: 50 stuck thread on each JVM since 15 days....
the manages serveurs are in warning but don't seem to be disturb cause the work manager add more threads dynamicaly.
Anyone have idea if this situation is a probleme for response time on other request ?
reboot managed solve this situation but i would like to understand the consequence of this situation.
thanks a lot for your experience.

The problem of thread pool

I want to make a thread pool to handle UDP package request
so I set tow int variable :
norsize;
maxsize;
the norsize is normal amount threads when Server boot they will be creat;
the maxsize is when the quest is large and the norsize threads are not enough,The
Thead pool can increase to the amount
but how reduce the Thread pool amount when it reach the maxsize????

That was funy (the Duke Dollars part) :)
Ok. This time with some code.
We have a class that manages work. This work is made up of Runnable objects and the threads that run it. Let's go with sample code instead of english, just remenber that I wrote this code directly to the post text area and didn't event compile it, although it should work.
publi class WorkQueue {
    private LinkedList m_listRunnable;
    private int m_nMinThread;
    private int m_nMaxThread;
    private int m_nTimeOut;
    private int m_nNumThread;
    private int m_nNumThreadWaiting;
    public WorkQueue(int minThread, int maxThread, int timeOut) {
        m_listRunnable = new LinkedList();
        m_nMinThread = minThread;
        m_nMaxThread = maxThread;
        m_nTimeOut = timeOut;
        m_nNumThread = 0;
        m_nNumThreadWaiting = 0;
        init();
    private void init() {
        /* Start MinThread threads */
        for (i = 0; i < m_nMinThread; i++) {
             new WorkSlaveThread();
             m_nNumThread++;
    /* Inner class for the work thread */
    private class WorkSlaveThread extends Thread {
        public WorkSlaveThread() {
        public void run() {
            /* Work unless no work is returned, then it should stop */
            for (Runnable work = getNextWork(); work != null; work = getNextWork()) {
                try {
                    work.run();
                } catch (Throwable ex) {
                    /* Log the error */
                    ex.printStackTrace();
            threadStopping();
    private void threadStopping() {
        synchronized (this) {
            m_nNumThread--;
    private Runnable getNextWork() {
        Runnable work;
        long starttime = System.currentTimeMillis();
        long currenttime = starttime;
        long timeOut = m_nTimeOut * 1000; // Assume the time on in the constructor is in seconds
        synchronized (m_listRunnable) {
            /* Until there is work and the time out hasn't exceed */
            /* (time out ignored if the minimum umber of threads is reached) */
            while ((m_listRunnable.size() == 0) && ((timeOut > (currenttime - starttime)) || (m_nThreads == m_nMinThreads))) {
                try {
                    m_nNumThreadWaiting++;
                    m_listRunnable.wait(m_nTimeOut * 1000);
                } catch (Exception ex) {
                    /* Exception are launched if the VM is going down */
                    return null;
                } finally {
                    m_nNumThreadWaiting--;
                currenttime = System.currentTimeMillis();
            if (m_listRunnable.size () == 0) {
                /* Stop threads procedure */
                return null; // Null will stop the thread
            } else {
                work = (Runnable)m_listRunnable.remove(0);
                return work;
    public void addWork(Runnable work) {
        synchronized (m_listRunnable) {
            m_listRunnable.add(work);
            /* Start threads if necessary */
            if ((m_nNumThreadWaiting == 0) && (m_nNumThread < m_nMaxthread)) {
                new WorkSlaveThread();
                synchronized (this) {
                    m_nNumThread++;
            /* Signal a waiting thread */
            m_listRunnable.notify();
}Well, this about does it! I didn't compile this, nor this is the code I use internally (internally I have shutdown procedures to ensure all work is down and other things), but it should do all the things a mention previously (I don't think I forgot any thing).
Hope this helps,
Nuno

Will more number of waiting threads in thread pool degrade performance?

Hi,
I use thread pool and set the maximum number of threads to execute. My problem is, the thread pool initiates the number of threads and these threads wait until they get a work. Will this degrade the performance (The threads do I/O operations) ??

Threads waiting for work will not degrade performance. If your work involves those threads waiting for I/O then that in itself will not degrade performance either (as long as they block and don't poll of course).
All live threads consume resources however so if you are short on threads or memory then don't create too many of them.
Pre-starting a large number of threads in a pool can cause a startup delay of course. Generally you should let the pool create threads as needed until it gets to the core pool size.

Is there any way to limit the number of Threads running in Application(JVM)

Hello all,
is there any way to limit the number of Threads running in Application(JVM)?
how to ensure that only 100 Threads are running in an Application?
Thanks
Mohamed Javeed

You should definitely use a thread pool for this. You can specify maximum number of threads that can be run. Be note that the thread pool will only limit the number of threads that are submitted to it. So donot call "Thread"s start() method to start thread on your own. Submit it to the pool. To know more, study about executor service and thread pool creation. Actually it will not be more than 20 line code for a class and you might need maximum of 2 such classes, one for threadPool and other one for rejection handler (if you want).
Just choose the queue used carefully, you just have to pass it as a parameter to the pool.
You should use "Bounded" queue for limiting threads, but also be careful in using queues like SynchronizedQueue as the queue will execute immediately the threads submitted to it if maximum number of threads have not been running. Otherwise it will reject it and you should use rejection handler. So if your pool has a synchronized queue of size 100, if you submit 101th thread, it will be rejected and is not executed.
If you want some kind of waiting mechanism, use something like LinkedBlockingQueue. What this will do is even if you want 100 threads, you can specify the queue's size to be 1000, so that you can submit 1000 threads, only 100 will run at a time and the remaining will wait in the queue. They will be executed when each thread already executing will complete. Rejection occurs only when the queue oveflows.

How to decide the number of threads?

Dear all,
Suppose we have a multi-thread application, and we know that each thread is doing the same kind of work. What is the reasonable number of threads that we should set at begining.
It seems that a thread is expensive, so we should use only 1 thread. (wrong)
It seems that we should use 100000000000 threads. (wrong)
I would like to know your opnion about the above questions.
Regards.
Pengyou

pengyou wrote:
Thanks for the two answers.
In fact, I have made a crawler to crawl internet sites. I would like to know in practice should I:
1. Run the application to crawl the Internet site one by one;
2. Use multi-threads to crawl n sites in prarallel; (If one thread failed down, what to do?);
3. Run the application n times to crawl n sites.You will likely be spending a bunch of time in blocking I/O, so should gain a bunch by adding multiple threads. However, please be nice to the web hosts:
- Put all requests to the same domain into a single thread. This prevents your crawler from stealing too much bandwidth from the web host, making it harder for other real live people from using the site. Some sites will actually detect such hits and treat them as attacks and block them. One way to make sure you don't make too many simultaneous requests to the same domain would be to run all of a domain's requests into a single thread.
- To get the right amount of Threads, you will need to profile. Run the crawler with different amount of threads and see what settings make the best use of CPU time (fill CPU time to nearly 100%) without excessive thread switching.
How to handle failed threads? I would suggest using a Thread Pool (ThreadPoolExecutorService) and let the thread pool handle thread generation / death. You would have to make sure your code handles exceptions intelligently, and synchronizes properly still.

How to find out the number of threads created under java vm at runtime

our application seems to have hit the max number of threads that can be created under vm and the vm will just hang after that. that behavior seems to be consistent from an article that I read earlier.
I wonder any way that java app can find out the number of threads currently created under vm?
thanks in advance!

If you are not starting an extra thread group you can use the Thread.activeCount method. But this willnot return all the threads, as there are some jvm threads, i.e. garbage collector. Also if you are running on a Unix type operating system then you can send a signal to the jvm to give you a thread dump, i think the signal is sighup.
If the application is hanging i would of thought that you have a deadlock situation rather then the JVM not being able to create new threads, roughly how many threads should be running ??

How do I use a thread from the execute pool

Is there any way to use the execute pools directly from my application code? We
cannot find any reference in the documentation. This will probably happen in a
startup class, but not limited to.
Thanks,
Elli

"Elli Albek" <[email protected]> wrote in message news:406a2fd5$[email protected]..
Is there any way to use the execute pools directly from my application code? We
cannot find any reference in the documentation. This will probably happen in a
startup class, but not limited to.Weblogic's pools of execute threads are purely internal resources
and are not intended for public use.
Regards,
Slava Imeshev

Increasing number of Threads in the Thread Pool

Similar Messages

Maybe you are looking for