Examples of java.nio.channels.SelectableChannel

java.nio.channels.SelectableChannel
A channel that can be multiplexed via a {@link Selector}.
In order to be used with a selector, an instance of this class must first be registered via the {@link #register(Selector,int,Object) register} method. This method returns a new {@link SelectionKey} objectthat represents the channel's registration with the selector.
Once registered with a selector, a channel remains registered until it is deregistered. This involves deallocating whatever resources were allocated to the channel by the selector.
A channel cannot be deregistered directly; instead, the key representing its registration must be cancelled. Cancelling a key requests that the channel be deregistered during the selector's next selection operation. A key may be cancelled explicitly by invoking its {@link SelectionKey#cancel() cancel} method. All of a channel's keys are cancelledimplicitly when the channel is closed, whether by invoking its {@link Channel#close close} method or by interrupting a thread blocked in an I/Ooperation upon the channel.
If the selector itself is closed then the channel will be deregistered, and the key representing its registration will be invalidated, without further delay.
A channel may be registered at most once with any particular selector.
Whether or not a channel is registered with one or more selectors may be determined by invoking the {@link #isRegistered isRegistered} method.
Selectable channels are safe for use by multiple concurrent threads.

Blocking mode
A selectable channel is either in blocking mode or in non-blocking mode. In blocking mode, every I/O operation invoked upon the channel will block until it completes. In non-blocking mode an I/O operation will never block and may transfer fewer bytes than were requested or possibly no bytes at all. The blocking mode of a selectable channel may be determined by invoking its {@link #isBlocking isBlocking} method.
Newly-created selectable channels are always in blocking mode. Non-blocking mode is most useful in conjunction with selector-based multiplexing. A channel must be placed into non-blocking mode before being registered with a selector, and may not be returned to blocking mode until it has been deregistered. @author Mark Reinhold @author JSR-51 Expert Group @version 1.35, 05/11/17 @since 1.4 @see SelectionKey @see Selector

            for (SelectionKey skey : keys) {
                SelectionKeyImpl key = (SelectionKeyImpl) skey;
                key.oldInterestOps = key.interestOps();
                boolean isReadableChannel = ((SelectionKey.OP_ACCEPT | SelectionKey.OP_READ) & key.oldInterestOps) != 0;
                boolean isWritableChannel = ((SelectionKey.OP_CONNECT | SelectionKey.OP_WRITE) & key.oldInterestOps) != 0;
                SelectableChannel channel = key.channel();                  
                if (isReadableChannel) {
                    readChannelList.add(channel.keyFor(this));
                    readableFDs.add(((FileDescriptorHandler)channel).getFD());
                }
                if (isWritableChannel) {
                    writeChannelList.add(channel.keyFor(this));
                    writableFDs.add(((FileDescriptorHandler)channel).getFD());
                }
            }
        }
        readableChannels = readChannelList.toArray(new SelectionKey[readChannelList.size()]);

View Full Code Here

        return new IoSessionIterator(selector.selectedKeys());
    }


    @Override
    protected void init(NioSession session) throws Exception {
        SelectableChannel ch = (SelectableChannel) session.getChannel();
        ch.configureBlocking(false);
        session.setSelectionKey(ch.register(selector, SelectionKey.OP_READ, session));
    }

View Full Code Here

                      }
                      else if (o instanceof ChangeSelectableChannel)
                      {
                        // finish accepting/connecting this connection
                        final ChangeSelectableChannel asc = (ChangeSelectableChannel)o;
                        final SelectableChannel channel=asc._channel;
                        final Object att = asc._attachment;


                        if ((channel instanceof SocketChannel) && ((SocketChannel)channel).isConnected())
                        {
                          key = channel.register(selector,SelectionKey.OP_READ,att);
                          SelectChannelEndPoint endpoint = newEndPoint((SocketChannel)channel,this,key);
                          key.attach(endpoint);
                          endpoint.dispatch();
                        }
                        else if (channel.isOpen())
                        {
                          channel.register(selector,SelectionKey.OP_CONNECT,att);
                        }
                      }
                      else if (o instanceof SocketChannel)
                      {
                        final SocketChannel channel=(SocketChannel)o;


                        if (channel.isConnected())
                        {
                          key = channel.register(selector,SelectionKey.OP_READ,null);
                          SelectChannelEndPoint endpoint = newEndPoint(channel,this,key);
                          key.attach(endpoint);
                          endpoint.dispatch();
                        }
                        else if (channel.isOpen())
                        {
                          channel.register(selector,SelectionKey.OP_CONNECT,null);
                        }
                      }
                      else if (o instanceof ServerSocketChannel)
                      {
                        ServerSocketChannel channel = (ServerSocketChannel)o;
                        channel.register(getSelector(),SelectionKey.OP_ACCEPT);
                      }
                      else if (o instanceof ChangeTask)
                      {
                        ((ChangeTask)o).run();
                      }
                      else
                        throw new IllegalArgumentException(o.toString());
                    }
                    catch (Exception e)
                    {
                      if (isRunning())
                        Log.warn(e);
                      else
                        Log.debug(e);
                    }
                    catch (Error e)
                    {
                      if (isRunning())
                        Log.warn(e);
                      else
                        Log.debug(e);
                    }
                  }
                }
                finally
                {
                  changes.clear();
                }
                
                long idle_next = 0;
                long retry_next = 0;
                long now=System.currentTimeMillis();
                synchronized (this)
                {
                    _idleTimeout.setNow(now);
                    _retryTimeout.setNow(now);
                    if (_lowResourcesConnections>0 && selector.keys().size()>_lowResourcesConnections)
                        _idleTimeout.setDuration(_lowResourcesMaxIdleTime);
                    else 
                        _idleTimeout.setDuration(_maxIdleTime);
                    idle_next=_idleTimeout.getTimeToNext();
                    retry_next=_retryTimeout.getTimeToNext();
                }


                // workout how low to wait in select
                long wait = 1000L;  // not getMaxIdleTime() as the now value of the idle timers needs to be updated.
                if (idle_next >= 0 && wait > idle_next)
                    wait = idle_next;
                if (wait > 0 && retry_next >= 0 && wait > retry_next)
                    wait = retry_next;
    
                // Do the select.
                if (wait > 2) // TODO tune or configure this
                {
                    // If we are in pausing mode
                    if (_pausing)
                    {
                        try
                        {
                            Thread.sleep(__BUSY_PAUSE); // pause to reduce impact of  busy loop
                        }
                        catch(InterruptedException e)
                        {
                            Log.ignore(e);
                        }
                    }
                        
                    long before=now;
                    int selected=selector.select(wait);
                    now = System.currentTimeMillis();
                    _idleTimeout.setNow(now);
                    _retryTimeout.setNow(now);
                    _selects++;


                    // Look for JVM bugs over a monitor period.
                    // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6403933
                    // http://bugs.sun.com/view_bug.do?bug_id=6693490
                    if (now>_monitorNext)
                    {
                        _selects=(int)(_selects*__MONITOR_PERIOD/(now-_monitorStart));
                        _pausing=_selects>__MAX_SELECTS;
                        if (_pausing)
                            _paused++;
                            
                        _selects=0;
                        _jvmBug=0;
                        _monitorStart=now;
                        _monitorNext=now+__MONITOR_PERIOD;
                    }
                    
                    if (now>_log)
                    {
                        if (_paused>0)  
                            Log.info(this+" Busy selector - injecting delay "+_paused+" times");


                        if (_jvmFix2>0)
                            Log.info(this+" JVM BUG(s) - injecting delay"+_jvmFix2+" times");


                        if (_jvmFix1>0)
                            Log.info(this+" JVM BUG(s) - recreating selector "+_jvmFix1+" times, canceled keys "+_jvmFix0+" times");


                        else if(Log.isDebugEnabled() && _jvmFix0>0)
                            Log.info(this+" JVM BUG(s) - canceled keys "+_jvmFix0+" times");
                        _paused=0;
                        _jvmFix2=0;
                        _jvmFix1=0;
                        _jvmFix0=0;
                        _log=now+60000;
                    }
                    
                    // If we see signature of possible JVM bug, increment count.
                    if (selected==0 && wait>10 && (now-before)<(wait/2))
                    {
                        // Increment bug count and try a work around
                        _jvmBug++;
                        if (_jvmBug>(__JVMBUG_THRESHHOLD))
                        {
                            try
                            {
                                if (_jvmBug==__JVMBUG_THRESHHOLD+1)
                                    _jvmFix2++;
                                    
                                Thread.sleep(__BUSY_PAUSE); // pause to avoid busy loop
                            }
                            catch(InterruptedException e)
                            {
                                Log.ignore(e);
                            }
                        }
                        else if (_jvmBug==__JVMBUG_THRESHHOLD)
                        {
                            synchronized (this)
                            {
                                // BLOODY SUN BUG !!!  Try refreshing the entire selector.
                                _jvmFix1++;
                                
                                final Selector new_selector = Selector.open();
                                Iterator iterator = _selector.keys().iterator();
                                while (iterator.hasNext())
                                {
                                    SelectionKey k = (SelectionKey)iterator.next();
                                    if (!k.isValid() || k.interestOps()==0)
                                        continue;
                                    
                                    final SelectableChannel channel = k.channel();
                                    final Object attachment = k.attachment();
                                    
                                    if (attachment==null)
                                        addChange(channel);
                                    else
                                        addChange(channel,attachment);
                                }
                                Selector old_selector=_selector;
                                _selector=new_selector;
                                try 
                                {
                                    old_selector.close();
                                }
                                catch(Exception e)
                                {
                                    Log.warn(e);
                                }
                                return;
                            }
                        }
                        else if (_jvmBug%32==31) // heuristic attempt to cancel key 31,63,95,... loops
                        {
                            // Cancel keys with 0 interested ops
                            int cancelled=0;
                            Iterator iter = selector.keys().iterator();
                            while(iter.hasNext())
                            {
                                SelectionKey k = (SelectionKey) iter.next();
                                if (k.isValid()&&k.interestOps()==0)
                                {
                                    k.cancel();
                                    cancelled++;
                                }
                            }
                            if (cancelled>0)
                                _jvmFix0++;
                            
                            return;
                        }
                    }
                    else if (__BUSY_KEY>0 && selected==1 && _selects>__MAX_SELECTS)
                    {
                        // Look for busy key
                        SelectionKey busy = (SelectionKey)selector.selectedKeys().iterator().next();
                        if (busy==_busyKey)
                        {
                            if (++_busyKeyCount>__BUSY_KEY && !(busy.channel() instanceof ServerSocketChannel))
                            {
                                final SelectChannelEndPoint endpoint = (SelectChannelEndPoint)busy.attachment();
                                Log.warn("Busy Key "+busy.channel()+" "+endpoint);
                                busy.cancel();
                                if (endpoint!=null)
                                {
                                    dispatch(new Runnable()
                                    {
                                        public void run()
                                        {
                                            try
                                            {
                                                endpoint.close();
                                            }
                                            catch (IOException e)
                                            {
                                                Log.ignore(e);
                                            }
                                        }
                                    });
                                }
                            }
                        }
                        else
                            _busyKeyCount=0;
                        _busyKey=busy;
                    }
                }
                else 
                {
                    selector.selectNow();
                    _selects++;
                }


                // have we been destroyed while sleeping
                if (_selector==null || !selector.isOpen())
                    return;


                // Look for things to do
                Iterator iter = selector.selectedKeys().iterator();
                while (iter.hasNext())
                {
                    key = (SelectionKey) iter.next();
                                        
                    try
                    {
                        if (!key.isValid())
                        {
                            key.cancel();
                            SelectChannelEndPoint endpoint = (SelectChannelEndPoint)key.attachment();
                            if (endpoint != null)
                                endpoint.doUpdateKey();
                            continue;
                        }
                        
                        Object att = key.attachment();
                        
                        if (att instanceof SelectChannelEndPoint)
                        {
                            SelectChannelEndPoint endpoint = (SelectChannelEndPoint)att;
                            endpoint.dispatch();
                        }
                        else if (key.isAcceptable())
                        {
                            SocketChannel channel = acceptChannel(key);
                            if (channel==null)
                                continue;


                            channel.configureBlocking(false);


                            // TODO make it reluctant to leave 0
                            _nextSet=++_nextSet%_selectSet.length;


                            // Is this for this selectset
                            if (_nextSet==_setID)
                            {
                                // bind connections to this select set.
                                SelectionKey cKey = channel.register(_selectSet[_nextSet].getSelector(), SelectionKey.OP_READ);
                                SelectChannelEndPoint endpoint=newEndPoint(channel,_selectSet[_nextSet],cKey);
                                cKey.attach(endpoint);
                                if (endpoint != null)
                                    endpoint.dispatch();
                            }
                            else
                            {
                                // nope - give it to another.
                                _selectSet[_nextSet].addChange(channel);
                                _selectSet[_nextSet].wakeup();
                            }
                        }
                        else if (key.isConnectable())
                        {
                            // Complete a connection of a registered channel
                            SocketChannel channel = (SocketChannel)key.channel();
                            boolean connected=false;
                            try
                            {
                                connected=channel.finishConnect();
                            }
                            catch(Exception e)
                            {
                                connectionFailed(channel,e,att);
                            }

View Full Code Here

            {
                if (_interestOps>0)
                {
                    if (_key==null || !_key.isValid())
                    {
                        SelectableChannel sc = (SelectableChannel)getChannel();
                        if (sc.isRegistered())
                        {
                            updateKey();   
                        }
                        else
                        {

View Full Code Here

        } else { 
           int osize = Math.max(8192,  _sslengine.getSession().getPacketBufferSize());
           ByteBuffer outputBB = ByteBuffer.allocate(osize);
           outputBB.position(0);


           SelectableChannel sc = _selectionkey.channel();
           synchronized(sc) {


           SSLOutputWriter.flushChannel(sc, bb, outputBB, _sslengine);


           }

View Full Code Here

                        }
                    };
                    ctx.getAsyncQueueWritable().writeToAsyncQueue(bb, awcb);
                }
            } else {
                SelectableChannel sc = ctx.getSelectionKey().channel();


                synchronized(sc) {
                    SSLOutputWriter.flushChannel(sc, bb);
                }

View Full Code Here

            {
                if (_interestOps>0)
                {
                    if (_key==null || !_key.isValid())
                    {
                        SelectableChannel sc = (SelectableChannel)getChannel();
                        if (sc.isRegistered())
                        {
                            updateKey();   
                        }
                        else
                        {

View Full Code Here


    if ((0 == readChannels.length) && (0 == writeChannels.length)) {
      return (new int[0]);
    }
    for (val = 0; val < countRead; val++, fdHandler = null) {
      SelectableChannel element = readChannels[val];
      if (element instanceof FileDescriptorHandler) {
        fdHandler = ((FileDescriptorHandler) element).getFD();
      }
      if (null != fdHandler) {
        readFDs[val] = fdHandler;
      }
    }
    FileDescriptor[] writeFDs = new FileDescriptor[countWrite];
    for (val = 0; val < countWrite; val++, fdHandler = null) {
      SelectableChannel element = writeChannels[val];
            if (element instanceof FileDescriptorHandler) {
                fdHandler = ((FileDescriptorHandler) element).getFD();
            }
      if (null != fdHandler) {
        writeFDs[val] = fdHandler;

View Full Code Here

            }
        }
    }


    private boolean isConnected(SelectionKeyImpl key) {
        SelectableChannel channel = key.channel();
        if (channel instanceof SocketChannel) {
            return ((SocketChannel) channel).isConnected();
        }
        return true;
    }

View Full Code Here

        return new IoSessionIterator(selector.selectedKeys());
    }


    @Override
    protected void init(NioSession session) throws Exception {
        SelectableChannel ch = (SelectableChannel) session.getChannel();
        ch.configureBlocking(false);
        session.setSelectionKey(ch.register(selector, SelectionKey.OP_READ, session));
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.nio.channels.SelectableChannel

ch.unifr.nio.framework.HandlerAdapter

com.cloudera.util.InputStreamPipe

com.ericsson.ssa.container.GrizzlyNetworkManager

com.ericsson.ssa.container.GrizzlyNetworkManager$ClientCertSSLReadFilter

com.ericsson.ssa.container.GrizzlyNetworkManager$ConnectionManager

com.ericsson.ssa.container.GrizzlyNetworkManager$SharedAsyncWriteCallbackHandler

com.ericsson.ssa.container.GrizzlyNetworkManager$SharedReadFilter

com.ericsson.ssa.container.OLDNetworkManager

com.facebook.presto.jdbc.internal.netty.channel.socket.nio.AbstractNioSelector

com.google.code.hs4j.network.nio.impl.Reactor

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of java.nio.channels.SelectableChannel

Blocking mode

Related Classes of java.nio.channels.SelectableChannel