Closing socket connection from 2nd thread

Question

I did some research on different operating systems to find a unique solution how to timeout a blocking recv call in one thread.
Closing the connection from another thread helps but I found that there are two different methods how to close the connection:
- either just calling close with the correct linger options
- call shutdown first and then close
Unfortunately most platforms work fine with only one of these methods and fail more or less severe with the other method.
While I think to fully understand the behavior of Windows and Linux, Solaris is still a big question mark for me.
I have some machines (running Solaris 8, 7 and 2.6) which work well with just closing and crash the system when using shutdown (while having bad luck in the timing of the other peer). And I have another 2.6 machine that behaves the other way around.
I created a detailed description about the whole problem and my findings in a PDF if you are interested: http://www.webwasher.com/download/notes/timeoutblockingsocketcall.pdf
Is anybody able to explain how the Solaris implementation works here?
And does anybody know why I see the differences with the two 2.6 boxes? (I changed patch level and exchanged clib without success.
Martin

Answer 1

I have a main program which creates a thread.Why not create a thread once the object has been read.
The thread would take some time to process this
object before it accepts another object to be passed
in from the main program.Threads are used for concurrent execution. If you don't want concurrent execution, don't use additional threads. Have the main program do the reading and execution and then it cannot read another object until it has finished executing the previous one.
>
However, I realise that my main program:
s = new Socket("localhost", 2001);
will produce a socket connection
socket connection even if the thread is still
processing the object. Why is this possible?This is what threads do. It is call multi-threading.
Initially I thought the thread would lock the socketIt will lock the sockect when you lock it with synchronized. Howver you are creating a new socket each time so even this would not do what you suggest.
and my main program would not be able to get a socket
connection until my thread releases the socket.Everytime you call new Socket() it creates a NEW socket. You can open as many socket as the server can handle. (10000+)
Code in my thread to accept a socket connection:
server = new ServerSocket(2001);
ois = new ObjectInputStream(server.accept().getInputStream());I would suggest putting the Socket created by server.accept() into a variable. Otherwise you will not be able to reply to the request, nor will you be able to close() the connection.
How can I workaround this issue. Hope somebody can help. Thanks.You don't need a workaround, you need to fix the logic of your application.