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 →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

Java NIO Tutorial