Java NIO Selector

In Java NIO the selector is a multiplexor of selectable channels, which is used as a special type of channel that can be put into non-blocking mode. It can examine one or more NIO Channel's and determines which channel is ready for communication i.e. reading or writing.

What is the use of Selector

The selector is used for handling the multiple channels using a single thread. Therefore it need less threads to handle the channels. Switching between the threads is expensive for operating system. Therefore, for improving the system efficiency it is use.

Let's see the illustration of a thread using Selector to handle 3 Channel's:

Let's see the simple illustration of the Gather principle:

Creating a Selector

We can create a selector by calling Selector.open() method, as given below:

Opening a server socket channel

Let's see the example for opening a server socket channel:

ServerSocketChannel serverSocket = ServerSocketChannel.open();
InetSocketAddress hostAddress = new InetSocketAddress("localhost", 8080);
serverSocket.bind(hostAddress);

Selection of Channels using a Selector

On registering one or more channels with a selector we can call one of a select() methods. This method return a channel which is ready for the events we want to perform i.e. connect, read, write or accept.

The various select() methods available for selection of channel are:

int select(): The integer value return by the select() method inform about how many channels are ready for the communication.
int select(long TS): This method is same as select() except it blocks the output for a maximum of TS(in millisecond) time period.
int selectNow(): It doesn't block the output and returns immediately with any channel which are ready.

selectedKeys()

Once we have called any one of the select() methods and it will return a value as indicated that one or more channels are ready, then we can access the ready channels by using the ?selected key set?, by calling a selectors selectedkeys() method as given below:

We can iterate the selected key set for accessing the ready channels as given below:

Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
while(keyIterator.hasNext()) {	
    SelectionKey key = keyIterator.next();
    if(key.isConnectable()) {
        // The connection was established with a remote server.
    } else if (key.isAcceptable()) {
        // The connection was accepted by a ServerSocketChannel.
    } else if (key.isWritable()) {
        //  The channel is ready for writing
    } else if (key.isReadable()) {
        // The channel is ready for reading
    }
    keyIterator.remove();
}

The above loop iterates a key in the selected key set for determining the operation performed using a selected channel.

The complete select loop block diagram is shown below:

Basic Selector Example

Main Program:

package com.javatpoint;

import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.channels.Selector;
import java.nio.channels.SelectionKey;
import java.nio.ByteBuffer;
import java.io.IOException;
import java.util.Set;
import java.util.Iterator;
import java.net.InetSocketAddress;
public class SelectorExample {
   public static void main (String [] args)
            throws IOException {
        // Get the selector
        Selector selector = Selector.open();
        System.out.println("Selector is open for making connection: " + selector.isOpen());
        // Get the server socket channel and register using selector
        ServerSocketChannel SS = ServerSocketChannel.open();
        InetSocketAddress hostAddress = new InetSocketAddress("localhost", 8080);
        SS.bind(hostAddress);
        SS.configureBlocking(false);
        int ops = SS.validOps();
        SelectionKey selectKy = SS.register(selector, ops, null);
        for (;;) {
            System.out.println("Waiting for the select operation...");
            int noOfKeys = selector.select();
            System.out.println("The Number of selected keys are: " + noOfKeys);
            Set selectedKeys = selector.selectedKeys();
            Iterator itr = selectedKeys.iterator();
            while (itr.hasNext()) {
                SelectionKey ky = (SelectionKey) itr.next();
                if (ky.isAcceptable()) {
                    // The new client connection is accepted
                    SocketChannel client = SS.accept();
                    client.configureBlocking(false);
                    // The new connection is added to a selector
                    client.register(selector, SelectionKey.OP_READ);
                    System.out.println("The new connection is accepted from the client: " + client);
                }
                else if (ky.isReadable()) {
                    // Data is read from the client
                    SocketChannel client = (SocketChannel) ky.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(256);
                    client.read(buffer);
                    String output = new String(buffer.array()).trim();
                    System.out.println("Message read from client: " + output);
                    if (output.equals("Bye Bye")) {
                        client.close();
                        System.out.println("The Client messages are complete; close the session.");
                    }
                }
                itr.remove();
            } // end of while loop
        } // end of for loop
    }
}

Client Program:

package com.javatpoint;

import java.nio.channels.SocketChannel;
import java.nio.ByteBuffer;
import java.io.IOException;
import java.net.InetSocketAddress;
public class Client {
    public static void main (String [] args)
            throws IOException, InterruptedException {
        InetSocketAddress hA = new InetSocketAddress("localhost", 8080);
        SocketChannel client = SocketChannel.open(hA);
        System.out.println("The Client is sending messages to server...");
        // Sending messages to the server	
        String [] msg = new String [] {"Time goes fast.", "What next?", "Bye Bye"};
        for (int j = 0; j < msg.length; j++) {
            byte [] message = new String(msg [j]).getBytes();
            ByteBuffer buffer = ByteBuffer.wrap(message);
            client.write(buffer);
            System.out.println(msg [j]);
            buffer.clear();
            Thread.sleep(3000);
        }
        client.close();				
    }
}

Output:

The Main Program Output is:

Selector is open for making connection: true
Waiting for the select operation...
The Number of selected keys are: 1
The new connection is accepted from the client: java.nio.channels.SocketChannel[connected 

local=/127.0.0.1:8080 remote=/127.0.0.1:51367]
Waiting for the select operation...
The Number of selected keys are: 1
Message read from client: Time goes fast.
Waiting for the select operation...
The Number of selected keys are: 1
Message read from client: What next?
Waiting for the select operation...
The Number of selected keys are: 1
Message read from client: Bye Bye
The Client messages are complete; close the session.
Waiting for the select operation...

The Client Program Output is:

The Client is sending messages to server...
Time goes fast.
What next?
Bye Bye

Next TopicJava NIO SocketChannel

← prev next →

Latest Courses

We provides tutorials and interview questions of all technology like java tutorial, android, java frameworks

Contact info

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

[email protected].

Python

AI, ML and Data Science

Java

B.Tech and MCA

Web Technology

Software Testing

Technical Interview

Java Interview

Web Interview

Database Interview

Company Interviews

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

Java String

Java String Methods

Java Regex

Exception Handling

Java Inner Class

Java Multithreading

Java Synchronization

Java Networking

Java Applet

Java Reflection

Java Conversion

Java JDBC

RMI

Internationalization

Java Array Class

Java AtomicInteger Class

Java AtomicLong Methods

Java Authenticator

Java BigDecimal class

Big Integer Class

Java Boolean class

Java Byte Class

Java Class

Java Collections class

Java Compiler Class

CopyOnWriteArrayList

Java Math Methods

LinkedBlockingDeque

Java Long class

LinkedTransferQueue

Java List

Java MulticastSocket

Java Number Class

Java Phaser Class

ArrayList Methods

Java Thread Methods

Java Projects

Java Programs

Java Misc

Java Date Class

Java ListIterator Class

Java NIO Tutorial

HttpURLConnection

Java Deque

Java HttpCookie Class

Java URL class

Java List Methods

Java Vector class

Java Collection Methods

Java Socket Class

Java Executors