maintain @readiness in Watcher::IO, fix #1

lib/lightio/library/io.rb

@@ -118,6 +118,10 @@ def wait_readable
       @io_watcher.wait_readable
     end
 
+    def io_watcher
+      @io_watcher
+    end
+
     class << self
       def open(*args)
         io = self.new(*args)
@@ -141,14 +145,16 @@ def pipe(*args)
 
       def select(read_fds, write_fds=nil, _except_fds=nil, timeout=nil)
         timer = timeout && Time.now
-        # run once ioloop
-        LightIO.sleep 0
         loop do
-          r_fds = (read_fds || []).select {|fd| fd.closed? ? raise(IOError, 'closed stream') : fd.instance_variable_get(:@io_watcher).readable?}
-          w_fds = (write_fds || []).select {|fd| fd.closed? ? raise(IOError, 'closed stream') : fd.instance_variable_get(:@io_watcher).writable?}
+          # clear io watcher status
+          read_fds.each {|fd| fd.send(:io_watcher).clear_status}
+          write_fds.each {|fd| fd.send(:io_watcher).clear_status}
+          # run ioloop once
+          LightIO.sleep 0
+          r_fds = (read_fds || []).select {|fd| fd.closed? ? raise(IOError, 'closed stream') : fd.send(:io_watcher).readable?}
+          w_fds = (write_fds || []).select {|fd| fd.closed? ? raise(IOError, 'closed stream') : fd.send(:io_watcher).writable?}
           e_fds = []
           if r_fds.empty? && w_fds.empty?
-            LightIO.sleep 0
             if timeout && Time.now - timer > timeout
               return nil
             end

lib/lightio/watchers/io.rb

@@ -23,6 +23,8 @@ def initialize(io, interests=:rw)
       @waiting = false
       ObjectSpace.define_finalizer(self, self.class.finalizer(@monitor))
       @error = nil
+      # maintain socket status, see https://github.com/socketry/lightio/issues/1
+      @readiness = nil
     end
 
     # NIO::Monitor
@@ -41,18 +43,26 @@ def finalizer(monitor)
     extend Forwardable
     def_delegators :monitor, :interests, :interests=, :closed?
 
+    # this method return previous IO.select status
+    # should avoid to directly use
     def readable?
       check_monitor_read
-      monitor.readable?
+      @readiness == :r || @readiness == :rw
     end
 
+    # this method return previous IO.select status
+    # should avoid to directly use
     def writable?
       check_monitor_write
-      monitor.writable?
+      @readiness == :w || @readiness == :rw
     end
 
     alias :writeable? :writable?
 
+    def clear_status
+      @readiness = nil
+    end
+
     # Blocking until io is readable
     # @param [Numeric]  timeout return nil after timeout seconds, otherwise return self
     # @return [LightIO::Watchers::IO, nil]
@@ -142,6 +152,8 @@ def in_waiting(mode)
     end
 
     def callback_on_waiting
+      # update readiness on callback
+      @readiness = monitor.readiness
       # only call callback on waiting
       return unless io_is_ready?
       if @error