My Own ThreadPool implementation
Generic code review
This is know as a busy loop:
    while(socket == null) {

    }

Not a good idea in any language.
Do you hear your fans spin up when your threads start executing this loop?
You should probably block the thread until the condition becomes true: See is there a 'block until condition becomes true' function in java?
Recursively calling your own function is not a good idea:
 public void serve() {
    .. DO WORK ITEM 1
    serve();
}

That would not explode immediately. But in a production system that is running a long time that will eventually fill up the stack and cause the application to crash. People will spend years trying to work out why it crashed (because its not obvious that this is a slow and steady memory leak that is undetectable).
Why not put that in a loop?
public synchronized void run() {
    while(!finished) {
        serve();
    }
     // remove the recursive call inside serve()
}

This is another hidden busy loop:
        while (currentNumberOfConnections &lt; 2) {
            Socket accept = serverSocket.accept();
            MySocketThread mySocketThread = mySocketThreads.pop();
            mySocketThread.setSocket(accept);
            currentNumberOfConnections++;
        }

When you have two active connections then this will spin like mad and just eat CPU resources. Put another block in there so that the thread is paused until your worker threads can keep going
Design Review:
I think your socket and your threads are to tightly coupled. I would rather separate them and make them independent of each other.
Have your socket class accepts incoming requests and for each request create a work item in a queue. That way it keeps accepting requests and does not need to drop any. If the threads get there two slowly then the client will close the connection and your thread will see this when it tries to service the client rquest.
One the other side make your threads collect work items from the queue (mentioned above). You then can add more threads without the socket class knowing about any of the threads (they just know about the queue).