Question

Is there a way to tell the thread pool mananger to only have x number of threads invoking a specific method or group of methods?

I have an application where I use thread pool worker threads all over the place, and it works swimmingly; one of the tasks I consign to the worker threads is a web service call, however, and it will reject more than 5 concurrent requests. I don’t want to limit the thread pool to 5 threads, because many other things use the threads and can handle a great many more.

Is there a way to “compartmentalize” a thread pool to say “you will have a maximum of x threads active doing this particular thing at any point in time, but the rest of you threads can go do other stuff”?

Answer 1

Create another threadpool and SetMaxThreads(5) – it’s the easiest way.

OK, you can’t do it with Threadpool class.

Just so I’m not downvoted:

public abstract class Task {
    public EventHandler FonComplete;
    public ThreadPool myPool;
    protected int param;
    public Exception error;
    public Task(int inParam, EventHandler OnDone) { param = inParam; FonComplete = OnDone; }
    public abstract void run();
};


public class PoolThread{
private
    BlockingCollection<Task> FinQueue;
public
    PoolThread(BlockingCollection<Task> inQueue)
    {
       FinQueue=inQueue; 
    }
    Task inMess;
    public void run(){
        while(true){
            inMess=FinQueue.Take();
            if(inMess==null) return;
            try
            {
                inMess.run();
                inMess.error = null;
            }
            catch (Exception e)
            {
                inMess.error = e;
            }
            inMess.FonComplete(inMess, null);
        }
    }
};

public class ThreadPool {
    int FthreadCount;
    BlockingCollection<Task> queue;
    void startThread(){
            PoolThread thisPoolThread=new PoolThread(queue);
            Thread thisThread=new Thread(new ThreadStart(thisPoolThread.run));
            thisThread.Priority = ThreadPriority.BelowNormal;
            thisThread.IsBackground = true;
            thisThread.Start();
    }
    void SetThreadCount(int newCount){
        while(FthreadCount<newCount){startThread();};
        while(FthreadCount>newCount){
            queue.Add(default(Task));
            FthreadCount--;
        };
    }
    public ThreadPool(int initThreads){
        queue=new BlockingCollection<Task>();
        for(FthreadCount=0;FthreadCount<initThreads;FthreadCount++) startThread();
    }
    public int threadCount{
        get{return FthreadCount;}
        set
        {
            while (FthreadCount < value) {
                startThread();
                FthreadCount++;
            };
            while (FthreadCount > value)
            {
                queue.Add(default(Task));
                FthreadCount--;
            }
        }
    }

    public void submit(Task task){
        task.myPool=this;
        queue.Add(task);
    }
};

}

It’s not like the ‘real’ System.Threading.Threadpool, but it is a threadpool with a fixed number of threads