Re: What should TCPSocket#close do to a blocked #readline?

On Thu, Feb 10, 2011 at 12:59 PM, Alex Young <[e-mail]> wrote:
>
> Take the following code:
>
> =A0require 'socket'
> =A0require 'thread'
>
> =A0server =3D TCPServer.new("localhost", 0)
> =A0serv_thread =3D Thread.new{ server.accept }
> =A0sleep(0.1)
> =A0sock =3D TCPSocket.new("localhost", server.addr[1])
>
> =A0q =3D Queue.new
> =A0client_thread =3D Thread.new{
> =A0 =A0begin
> =A0 =A0 =A0sock.readline
> =A0 =A0rescue StandardError =3D> e
> =A0 =A0 =A0q.push(e)
> =A0 =A0end
> =A0}
>
>
> =A0sleep(0.1) while client_thread.status =3D=3D "run"
> =A0sock.close
> =A0# client_thread.wakeup rescue nil
> =A0err =3D q.pop
> =A0client_thread.join
> =A0fail "Failure!" unless err.is_a?(IOError)
> =A0puts "Success!"
>
>
> So, we've got one thread blocked on a #readline, and another thread
> closes the socket out from under it. On 1.8.7-p302, this completes
> successfully. On 1.9.2-p136, it hangs at q.pop.

I cannot confirm this:

15:40:10 Temp$ ruby19 -v
ruby 1.9.2p136 (2010-12-25 revision 30365) [i386-cygwin]
15:40:50 Temp$ ruby19 s.rb
#<IOError: closed stream>
Success!
15:41:31 Temp$ cat s.rb
require 'socket'
 require 'thread'

 server =3D TCPServer.new("localhost", 0)
 serv_thread =3D Thread.new{ server.accept }
 sleep(0.1)
 sock =3D TCPSocket.new("localhost", server.addr[1])

 q =3D Queue.new
 client_thread =3D Thread.new{
   begin
     sock.readline
     q.push "OK"
   rescue StandardError =3D> e
     p e
     q.push(e)
   end
 }


 sleep(0.1) while client_thread.status =3D=3D "run"
 sock.close
 # client_thread.wakeup rescue nil
 err =3D q.pop
 # client_thread.join
 fail "Failure!" unless err.is_a?(IOError)
 puts "Success!"

15:41:36 Temp$


> If I uncomment the client_thread.wakeup call, both complete (although
> the rescue is necessary to prevent a ThreadError on 1.8.7).
>
> Is this expected? Which is "correct"?

Hm...  I would expect your 1.9.2 to also throw.

Btw, one thing is odd about your test case: you have two mechanisms to
synchronize threads - you read from the queue and you join
client_thread.  If you really only want to track status of the thread
you could as well use Thread#value:

 client_thread =3D Thread.new{
   begin
     sock.readline
     nil
   rescue StandardError =3D> e
     e
   end
 }

err =3D client_thread.value

Kind regards

robert

--
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/