protected AbstractSelectableChannel(SelectorProvider provider) 
{
                
        this.provider = provider;
}

Initializes a new instance of this class.

 public final Object blockingLock() 
{
        return regLock;
}

 public final SelectableChannel configureBlocking(boolean block) throws IOException 
{
        if (!isOpen())
            throw new ClosedChannelException();
        synchronized (regLock) {
            if (blocking == block)
                return this;
            if (block && haveValidKeys())
                throw new IllegalBlockingModeException();
            implConfigureBlocking(block);
            blocking = block;
        }
        return this;
}

Adjusts this channel's blocking mode.

If the given blocking mode is different from the current blocking mode then this method invokes the implConfigureBlocking method, while holding the appropriate locks, in order to change the mode.

 protected final  void implCloseChannel() throws IOException 
{
        implCloseSelectableChannel();
        synchronized (keyLock) {
            int count = (keys == null) ? 0 : keys.length;
            for (int i = 0; i <  count; i++) {
                SelectionKey k = keys[i];
                if (k != null)
                    k.cancel();
            }
        }
}

Closes this channel.

This method, which is specified in the AbstractInterruptibleChannel class and is invoked by the close method, in turn invokes the implCloseSelectableChannel method in order to perform the actual work of closing this channel. It then cancels all of this channel's keys.

 abstract protected  void implCloseSelectableChannel() throws IOException
Closes this selectable channel.

 This method is invoked by the 
close  method in order to perform the actual work of closing the
channel. This method is only invoked if the channel has not yet been
closed, and it is never invoked more than once.

 An implementation of this method must arrange for any other thread
that is blocked in an I/O operation upon this channel to return
immediately, either by throwing an exception or by returning normally.

 abstract protected  void implConfigureBlocking(boolean block) throws IOException
Adjusts this channel's blocking mode.

 This method is invoked by the 
configureBlocking  method in order to perform the actual work of
changing the blocking mode. This method is only invoked if the new mode
is different from the current mode. 

 public final boolean isBlocking() 
{
        synchronized (regLock) {
            return blocking;
        }
}

 public final boolean isRegistered() 
{
        synchronized (keyLock) {
            return keyCount != 0;
        }
}

 public final SelectionKey keyFor(Selector sel) 
{
        return findKey(sel);
}

 public final SelectorProvider provider() 
{
        return provider;
}

Returns the provider that created this channel.

 public final SelectionKey register(Selector sel,
    int ops,
    Object att) throws ClosedChannelException 
{
        if (!isOpen())
            throw new ClosedChannelException();
        if ((ops & ~validOps()) != 0)
            throw new IllegalArgumentException();
        synchronized (regLock) {
            if (blocking)
                throw new IllegalBlockingModeException();
            SelectionKey k = findKey(sel);
            if (k != null) {
                k.interestOps(ops);
                k.attach(att);
            }
            if (k == null) {
                // New registration
                k = ((AbstractSelector)sel).register(this, ops, att);
                addKey(k);
            }
            return k;
        }
}

Registers this channel with the given selector, returning a selection key.

This method first verifies that this channel is open and that the given initial interest set is valid.

If this channel is already registered with the given selector then the selection key representing that registration is returned after setting its interest set to the given value.

Otherwise this channel has not yet been registered with the given selector, so the register method of the selector is invoked while holding the appropriate locks. The resulting key is added to this channel's key set before being returned.

  void removeKey(SelectionKey k) 
{
                    // package-private
        synchronized (keyLock) {
            for (int i = 0; i <  keys.length; i++)
                if (keys[i] == k) {
                    keys[i] = null;
                    keyCount--;
                }
            ((AbstractSelectionKey)k).invalidate();
        }
}