How can I retrieve the number of running posix threads?

Hello

I'd like to limit the number of threads that my server can simultaneously run to some predetermined number, say 50, and refuse connections when the count exceeds this. The idea is that load-balancing will be a responsibility of client apps as they iterate over a server bank for the first server that accepts a connection.

I can't seem to find a straightforward way to do this simply (I mean retrieve this count in a single, simple system/function call to the pthread library). I can, of course, do this by maintaining a thread counter myself and updating it with a mutex lock, but I'd rather not do this if an existing function can do this for me. It seems so obvious that I just can't believe I haven't been able to find such a call. Or have I been looking in the wrong places?

Ideally, I'd like something like:

size_t nActiveThreads = pthread_getActiveCount(getpid());

Any help will be greatly appreciated.

Thanks.

pandamatak

It doesn't seems a standard posix call exists for that task.

Maintaining your own counter seems to me the best approach, but should you want to avoid it, I believe you can count the number of threads a process is using by parsing the /proc directory.
This is quite easy with Solaris "/proc/self/lwp/*", not sure about how to translate that on other O/Ses though.

Thank all for your help. From the responses I got, it seems the following is the best workaround, which I was hoping I'd not have to do. But so far it seems to work
fine in the server.

Regards -- &

//--------------------------------------------------------
#include <pthread.h>

/* The only thread-writable global.
*/
size_t NumActiveThreads = 1;
pthread_mutex_t NatMutex = PTHREAD_MUTEX_INITIALIZER;

/* Returns the number of active threads so we can
* control how many we choose to handle
*/
size_t numActiveThreads()
{
pthread_mutex_lock(&NatMutex);
size_t n = NumActiveThreads;
pthread_mutex_unlock(&NatMutex);
return n;
}

void incrNumActiveThreads() // Safe increment
{
pthread_mutex_lock(&NatMutex);
++NumActiveThreads;
pthread_mutex_unlock(&NatMutex);
}

void decrNumActiveThreads() // Safe decrement
{
pthread_mutex_lock(&NatMutex);
--NumActiveThreads;
pthread_mutex_unlock(&NatMutex);
}

//--------------------------------------------------------