Need ur opinion ! very urgent

Question

Hi all jGurus !
actually i'm developing a distributed and multithreaded clien/server application and i'm half way completed but still have few things in my mind regarding the overall performance of java language.... the general scnario is...
i've developed a instant messenger application in java using Swing 1.3 which is ofcourse based on a client/server architecture. The general application flow is something like the Messenger Server starts up and starts listening to the server socket for clients and as soon as the client socket connects to it it spawns a separate thread [ lets call it a Servicer ] for that client, the story does not endz here as the Servicer checks that users login information in the database and its already online users list ( an ArrayList Object ) for the verification process and going all through that process it performs function like creating certain objects which should have life till that user logs of from the server i.e. the servicer exits from run() as i'm doing all these processes in the run.
Now after the whole verification process the Servicer which have now DataOutput and DataInputStreams starts reading through those streams for strings through its readUTF() method and ofcourse writes to those also.
as this application is serving the clients as hot instant messaging system it should be very robust and reliable..
and must provide all the functions such as changing status , nick logOff, adding other friends and removing them, i'm keeping all the data in a database and to some extent in separate files on the server machine.....
So guyz that was all the story, but now the question arises wut are limiting factors keeping in mind this scenario, if u have suggestions yourself please let me know. but first explain whut i ask u for.
1.. whut are the total no of sockets that the server can open at one time(simultaneously). and as there is ofcourse platform dependency. so wut u guys think how much sockets windows NTServer or windows 2000 provides. suggest me if u think windows is not ur choice for such a scenario
2.. whut if the no. of sockets reaches its max limit, ofcourse the server would reject the client request for the connection but whut happens when after reaching a socket limit, do the server again i mean after having free sockets available(as the clients will keep logging in and logging off) do the server efficently returns to its normal state, or just stuck up its resources
3.. can i control the max limit of the sockets
4.. how many separate threads i can spawn without hanging the server resources.
5.. and in last u suggest me the best way to develop this kind of an application....... do u think the model that i'm following is the right choice.....
guys please provide me your precious comments as soon as possible as i have to finish the project
hoping to get a good response
thanx in adv

Answer 1

One way might be to construct an array of available threads. And then with each new connection assign your Servicer class to one of the available threads which will execute the run() method from the Servicer class.
You can add some code to keep track of how many open sockets you have and to check if all threads finish their job. the number of threads in the pool depends on how much time will spend each thread in finishing the assigned job. If it takes a long time increase the number of available threads. You can fine tune this by checking how many free threads you have at a given time.
For instance in your Server constructor you can construct the thread array:
private static final int THREAD_POOL = 10;
ServerThread[]  workers = null;
//in constructor
workers = new ServerThread[THREAD_POOL];
for(int i=0; i<workers.length; i++){
       workers[i] = new ServerThread();
       workers.start();
//in while loop
for(int i=0; i<workers.length; i++){
if(workers[i].isAvailable()){
aServicer = new Servicer(clientSocket, reg_Users);
workers[i].execute(aServicer);
if(cleanFlag){
startCleanEngine();
aServicer = null;
clientSocket = null;
if(cleanFlag){
Thread.yield();
iLoop++;
continue mainLoop;
//in this code I am also doing some cleaning checking
//mainLoop is the label for the while() statement
//here is the code for the ServerThread
class ServerThread extends Thread{
* The thread executing the submitted jobs.
private Runnable workToDo;
* Creates new ServerThread and sets its type
* as being a daemon thread.
public ServerThread(){
          setDaemon(true);
* Waits until the internal Runnable reference is null
* then assigns it a new job.
* @param job an objecxt that requires a
* thread resource
     public void execute(Runnable job){
          synchronized(this){
               while(workToDo != null){
                    try{
                         wait();
                    }catch(InterruptedException ie){
                    workToDo = job;
                    notifyAll();
* Checks once to see if no job is pending and if not a new job
* is assigned, the boolean flag is set to true and all waiting
* threads notified.
* @param job the object that needs to be executed
* @return boolean true is the new job has been assigned
* and false otherwise
     public boolean executeIfAvailable(Runnable job){
          boolean executed = false;
synchronized(this){
               if(workToDo == null){
                    workToDo = job;
                    executed = true;
                    notifyAll();
          return executed;
* Checks for the availability of current thread.
* @return boolean true is the thread is available and
* false otherwise
     public boolean isAvailable(){
          return (workToDo == null);
     * Rejects any thread that is not owned by the current
     * instance. Waits until a Runnable job is assigned, then
     * calls its run() method directly, acting as its surrogate
     * Thread instance. Signals for another job by dereferencing
     * the current one.
     public void run(){
          if(Thread.currentThread() == this){
               Runnable job = null;
               for(; ;){
                    synchronized(this){
                         while(workToDo == null){
                              try{
                                   wait();
                              }catch(InterruptedException ie){
System.out.println("ServerThread - current thread interrupted: " + ie.getMessage());
                         job = workToDo;
                         notifyAll();
                    job.run();
                    workToDo = null;
You can read the documentation to see how it works.