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

        }
    } // Select
    
    public void Add(Socket x)
    {
        SelectableChannel ch = x.GetChannel();
        try
        {
            SelectionKey key = ch.register( m_selector, ch.validOps(), x);
            x.SetKey(key);
            x.OnInitialOps();
            m_sockets.add(x);
            PrintSockets();
        } catch (Exception e)

View Full Code Here

        if(io instanceof RubyIO && 
           (((RubyIO)io).getOpenFile().getMainStream() instanceof ChannelStream) &&
           (((ChannelStream)((RubyIO)io).getOpenFile().getMainStream()).getDescriptor().getChannel() instanceof SelectableChannel))  {


            ((RubyObject)recv).extend(new IRubyObject[]{((RubyModule)recv.getRuntime().getModule("Net").getConstant("BufferedIO")).getConstant("NativeImplementation")});
            SelectableChannel sc = (SelectableChannel)(((ChannelStream)((RubyIO)io).getOpenFile().getMainStream()).getDescriptor().getChannel());
            recv.dataWrapStruct(new NativeImpl(sc));
        }


        recv.getInstanceVariables().setInstanceVariable("@io", io);
        recv.getInstanceVariables().setInstanceVariable("@read_timeout", recv.getRuntime().newFixnum(60));

View Full Code Here

    
    public boolean select(RubyIO io, int ops) {
        Channel channel = io.getChannel();
        
        if (channel instanceof SelectableChannel) {
            SelectableChannel selectable = (SelectableChannel)channel;
            
            synchronized (selectable.blockingLock()) {
                boolean oldBlocking = selectable.isBlocking();


                try {
                    selectable.configureBlocking(false);
                    
                    io.addBlockingThread(this);
                    currentSelector = selectable.provider().openSelector();


                    SelectionKey key = selectable.register(currentSelector, ops);


                    int result = currentSelector.select();


                    // check for thread events, in case we've been woken up to die
                    pollThreadEvents();


                    if (result == 1) {
                        Set<SelectionKey> keySet = currentSelector.selectedKeys();


                        if (keySet.iterator().next() == key) {
                            return true;
                        }
                    }


                    return false;
                } catch (IOException ioe) {
                    throw io.getRuntime().newRuntimeError("Error with selector: " + ioe);
                } finally {
                    if (currentSelector != null) {
                        try {
                            currentSelector.close();
                        } catch (IOException ioe) {
                            throw io.getRuntime().newRuntimeError("Could not close selector");
                        }
                    }
                    currentSelector = null;
                    io.removeBlockingThread(this);
                    try {
                        selectable.configureBlocking(oldBlocking);
                    } catch (IOException ioe) {
                        // ignore; I don't like doing it, but it seems like we
                        // really just need to make all channels non-blocking by
                        // default and use select when implementing blocking ops,
                        // so if this remains set non-blocking, perhaps it's not

View Full Code Here

        int nWritten = 0;
        buffer.flip();


        // For Sockets, only write as much as will fit.
        if (descriptor.getChannel() instanceof SelectableChannel) {
            SelectableChannel selectableChannel = (SelectableChannel)descriptor.getChannel();
            synchronized (selectableChannel.blockingLock()) {
                boolean oldBlocking = selectableChannel.isBlocking();
                try {
                    if (oldBlocking != block) {
                        selectableChannel.configureBlocking(block);
                    }
                    nWritten = descriptor.write(buffer);
                } finally {
                    if (oldBlocking != block) {
                        selectableChannel.configureBlocking(oldBlocking);
                    }
                }
            }
        } else {
            nWritten = descriptor.write(buffer);

View Full Code Here

        if (buf == null || buf.length() == 0) return 0;
        
        if (buffer.position() != 0 && !flushWrite(false)) return 0;
        
        if (descriptor.getChannel() instanceof SelectableChannel) {
            SelectableChannel selectableChannel = (SelectableChannel)descriptor.getChannel();
            synchronized (selectableChannel.blockingLock()) {
                boolean oldBlocking = selectableChannel.isBlocking();
                try {
                    if (oldBlocking) {
                        selectableChannel.configureBlocking(false);
                    }
                    return descriptor.write(ByteBuffer.wrap(buf.unsafeBytes(), buf.begin(), buf.length()));
                } finally {
                    if (oldBlocking) {
                        selectableChannel.configureBlocking(oldBlocking);
                    }
                }
            }
        } else {
            return descriptor.write(ByteBuffer.wrap(buf.unsafeBytes(), buf.begin(), buf.length()));

View Full Code Here

        if (number == 0) {
            return null;
        }


        if (descriptor.getChannel() instanceof SelectableChannel) {
            SelectableChannel selectableChannel = (SelectableChannel)descriptor.getChannel();
            synchronized (selectableChannel.blockingLock()) {
                boolean oldBlocking = selectableChannel.isBlocking();
                try {
                    selectableChannel.configureBlocking(false);
                    return readpartial(number);
                } finally {
                    selectableChannel.configureBlocking(oldBlocking);
                }
            }
        } else if (descriptor.getChannel() instanceof FileChannel) {
            return fread(number);
        } else {

View Full Code Here

           w.addAll(unselectable_writes);
           
           // make all sockets blocking as configured again
           for (Iterator i = selector.keys().iterator(); i.hasNext(); ) {
               SelectionKey key = (SelectionKey) i.next();
               SelectableChannel channel = key.channel();
               synchronized(channel.blockingLock()) {
                   RubyIO originalIO = (RubyIO) TypeConverter.convertToType(
                           (IRubyObject) key.attachment(), runtime.getIO(),
                           MethodIndex.TO_IO, "to_io");
                   boolean blocking = originalIO.getBlocking();
                   key.cancel();
                   channel.configureBlocking(blocking);
               }
           }
           selector.close();
           
           if (r.size() == 0 && w.size() == 0 && e.size() == 0) {

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

            // Open a new selector
            Selector newSelector = Selector.open();


            // Loop on all the registered keys, and register them on the new selector
            for (SelectionKey key : keys) {
                SelectableChannel ch = key.channel();
                
                // Don't forget to attache the session, and back !
                NioSession session = (NioSession)key.attachment();
                SelectionKey newKey = ch.register(newSelector, key.interestOps(), session);
                session.setSelectionKey( newKey );
            }


            // Now we can close the old selector and switch it
            selector.close();

View Full Code Here

            Set<SelectionKey> keys = selector.keys();


            // Loop on all the keys to see if one of them
            // has a closed channel
            for (SelectionKey key : keys) {
                SelectableChannel channel = key.channel();


                if ((((channel instanceof DatagramChannel) && ((DatagramChannel) channel)
                        .isConnected()))
                        || ((channel instanceof SocketChannel) && ((SocketChannel) channel)
                                .isConnected())) {

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