Java Selector.open方法代码示例

import java.nio.channels.Selector; //导入方法依赖的package包/类
public NIOAcceptor(String name, String bindIp,int port, 
		FrontendConnectionFactory factory, NIOReactorPool reactorPool)
		throws IOException {
	super.setName(name);
	this.port = port;
	this.selector = Selector.open();
	this.serverChannel = ServerSocketChannel.open();
	this.serverChannel.configureBlocking(false);
	/** 设置TCP属性 */
	serverChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
	serverChannel.setOption(StandardSocketOptions.SO_RCVBUF, 1024 * 16 * 2);
	// backlog=100
	serverChannel.bind(new InetSocketAddress(bindIp, port), 100);
	// 注册OP_ACCEPT，监听客户端连接 // 准备好接受新的连接   // 监听到之后是图-MySql第2步，(接受TCP连接)
	this.serverChannel.register(selector, SelectionKey.OP_ACCEPT);
	//FrontendConnectionFactory,用来封装channel成为FrontendConnection
	this.factory = factory;
	//NIOReactor池
	this.reactorPool = reactorPool;
}
 

import java.nio.channels.Selector; //导入方法依赖的package包/类
private void openSocketForTransferPort(int port) throws IOException {

        executor = Utils.getStandardExecService("[ Acceptable ServersThreadPool ] ",
                2,
                10,
                new ArrayBlockingQueue<Runnable>(65500),
                Thread.NORM_PRIORITY - 2);
        ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);
        FDTSession sess = FDTSessionManager.getInstance().getSession(sessionID);
        ss = ssc.socket();
        String listenIP = config.getListenAddress();
        if (listenIP == null) {
            ss.bind(new InetSocketAddress(port));
        }
        else
        {
            ss.bind(new InetSocketAddress(InetAddress.getByName(listenIP), port));
        }

        sel = Selector.open();
        ssc.register(sel, SelectionKey.OP_ACCEPT);
        sc = ssc.accept();
        config.setSessionSocket(ssc, ss, sc, s, port);
    }
 

import java.nio.channels.Selector; //导入方法依赖的package包/类
public static void main(String[] argv) throws Exception {
    try (ByteServer server = new ByteServer();
         SocketChannel sc = SocketChannel.open(server.address())) {

        server.acceptConnection();

        try (Selector sel = Selector.open()) {
            sc.configureBlocking(false);
            sc.register(sel, SelectionKey.OP_WRITE);
            sel.select();
            sel.selectedKeys().clear();
            if (sel.select() == 0) {
                throw new Exception("Select returned zero");
            }
        }
    }
}
 

import java.nio.channels.Selector; //导入方法依赖的package包/类
/**
 * Starts a new Thread and connects to server
 *
 * @throws IOException
 */
public Thread connect() throws IOException {
    this.running = true;
    this.readyState = WEBSOCKET_STATE_CONNECTING;
    // open socket
    socketChannel = SocketChannel.open();
    socketChannel.configureBlocking(false);
    // set address
    socketChannel.connect(new InetSocketAddress(uri.getHost(), port));
    // start a thread to make connection

    // More info:
    // http://groups.google.com/group/android-developers/browse_thread/thread/45a8b53e9bf60d82
    // http://stackoverflow.com/questions/2879455/android-2-2-and-bad-address-family-on-socket-connect
    System.setProperty("java.net.preferIPv4Stack", "true");
    System.setProperty("java.net.preferIPv6Addresses", "false");

    selector = Selector.open();
    socketChannel.register(selector, SelectionKey.OP_CONNECT);
    Log.v("websocket", "Starting a new thread to manage data reading/writing");

    Thread th = new Thread(this);
    th.start();
    // return thread object for explicit closing, if needed
    return th;
}
 

import java.nio.channels.Selector; //导入方法依赖的package包/类
@Override
public void start() throws IOException {

	this.sctpServerChannel = SctpServerChannel.open();		
	sctpServerChannel.bind( new InetSocketAddress(this.getIpAddress(),this.getPort()) );
	sctpServerChannel.configureBlocking( false );
	
	this.selector = Selector.open();
	this.key = sctpServerChannel.register( selector, SelectionKey.OP_ACCEPT );
			
	// Start a daemon thread to handle reception
	this.isRunning = true;
       Thread thread = new Thread(this);
       thread.setDaemon(true);
       thread.setName("SCTPMessageProcessorThread");
       thread.setPriority(Thread.MAX_PRIORITY);
       thread.start();
}
 

import java.nio.channels.Selector; //导入方法依赖的package包/类
private synchronized void OpenSockets() {
	if (mode == CLIENT) {
		try
		{
			attemptClientConnection();
			receiving = true;
		} catch (IOException e) {
			log.error(e);
		}
	} else if (mode == SERVER) {
		try {

			selector = Selector.open();
			serverSocketChannel = ServerSocketChannel.open();
			serverSocketChannel.configureBlocking(false);
			serverSocketChannel.socket().bind(new InetSocketAddress(port));
			serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
			receiving = true;
		} catch (IOException ex) {
			selector = null;
		}

	}
}
 

import java.nio.channels.Selector; //导入方法依赖的package包/类
private void applyProperties() throws IOException
{
	if(mode==SERVER)
	{
		selector = Selector.open();
	}
}
 

import java.nio.channels.Selector; //导入方法依赖的package包/类
public Poller() throws IOException {
    synchronized (Selector.class) {
        // Selector.open() isn't thread safe
        // http://bugs.sun.com/view_bug.do?bug_id=6427854
        // Affects 1.6.0_29, fixed in 1.7.0_01
        this.selector = Selector.open();
    }
}
 

import java.nio.channels.Selector; //导入方法依赖的package包/类
public FDTServer(int port) throws Exception {
    hasToRun = new AtomicBoolean(true);

    // We are not very happy to welcome new clients ... so the priority will be lower
    executor = Utils.getStandardExecService("[ Acceptable ServersThreadPool ] ",
            5,
            10,
            new ArrayBlockingQueue<Runnable>(65500),
            Thread.NORM_PRIORITY - 2);
    ssc = ServerSocketChannel.open();
    ssc.configureBlocking(false);

    ss = ssc.socket();

    String listenIP = config.getListenAddress();
    if (listenIP == null) {
        ss.bind(new InetSocketAddress(port));
    }
    else
    {
        ss.bind(new InetSocketAddress(InetAddress.getByName(listenIP), port));
    }

    sel = Selector.open();
    ssc.register(sel, SelectionKey.OP_ACCEPT);

    if (config.isGSIModeEnabled()) {
        FDTGSIServer gsiServer = new FDTGSIServer(config.getGSIPort());
        gsiServer.start();
        logger.log(Level.INFO, "FDT started in GSI mode on port: " + config.getGSIPort());
    }
    // Monitoring & Nice Prnting
    final ScheduledExecutorService monitoringService = Utils.getMonitoringExecService();

    monitoringService.scheduleWithFixedDelay(new FDTServerMonitorTask(), 10, 10, TimeUnit.SECONDS);

    // in SSH mode this is a ACK message for the client to inform it that the server started ok
    // (the server stdout is piped to client through the SSH channel)
    System.out.println("READY");
}
 

import java.nio.channels.Selector; //导入方法依赖的package包/类
Reactor(int port) throws IOException { // Reactor初始化
	selector = Selector.open();
	serverSocket = ServerSocketChannel.open();
	serverSocket.socket().bind(new InetSocketAddress(port));
	serverSocket.configureBlocking(false); // 非阻塞
	SelectionKey sk = serverSocket.register(selector, SelectionKey.OP_ACCEPT); // 分步处理,第一步,接收accept事件
	sk.attach(new Acceptor()); // attach callback object, Acceptor
}
 

import java.nio.channels.Selector; //导入方法依赖的package包/类
@Override
@SneakyThrows
public void execute () {
    log.info("catcher.CatcherCommandExecutor.greeting");
    log.debug("catcher.CatcherCommandExecutor.options", options);

    try (val server = ServerSocketChannel.open();
         val selector = Selector.open()) {

        server.socket().setReuseAddress(true);
        server.configureBlocking(false);
        server.socket().bind(new InetSocketAddress(options.getBind(), options.getPort()));
        server.register(selector, OP_ACCEPT);

        while (!Thread.currentThread().isInterrupted()) {
            if (!selector.isOpen()) {
                Thread.currentThread().interrupt();
            }
            if (selector.select() > 0) {
                handle(server, selector.selectedKeys());
            }
        }
    } catch (IOException | RuntimeException ex) {
        val exception = I18nExceptionUtil.throwRuntime("catcher.server.UnableToStart", ex.getMessage());
        log.error("catcher.CatcherCommandExecutor.error", exception);
        throw exception;
    }
}
 

import java.nio.channels.Selector; //导入方法依赖的package包/类
private void init() throws Exception {
    buffPool = ByteBufferPool.getInstance();
    executor = JIperf.getExecutor();

    ssc = ServerSocketChannel.open();
    ssc.configureBlocking(false);

    ss = ssc.socket();
    ss.bind(new InetSocketAddress(port));

    sel = Selector.open();
    ssc.register(sel, SelectionKey.OP_ACCEPT);
}
 

import java.nio.channels.Selector; //导入方法依赖的package包/类
/**
 * open selector
 * @param msg
 * msg
 * @return
 * selector
 */
public Selector openSelector(String msg) {
	Selector selector;
	do {
		try {
			selector = Selector.open();
			// selector open
			return selector;
		} catch (IOException e) {
			this.logger.warning(msg + e.toString());
		}
	} while (true);
}
 

import java.nio.channels.Selector; //导入方法依赖的package包/类
@SuppressWarnings("InfiniteLoopStatement")
public void start() throws Exception {

    try (ServerSocketChannel serverSocketChannel = ServerSocketChannel.open()) {
        serverSocketChannel.bind(new InetSocketAddress("localhost", PORT));

        serverSocketChannel.configureBlocking(false); //non blocking mode
        int ops = SelectionKey.OP_ACCEPT;
        Selector selector = Selector.open();
        serverSocketChannel.register(selector, ops, null);

        logger.info("Started on port: " + PORT);

        while (true) {
            selector.select();//blocks
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                try {
                    if (key.isAcceptable()) {
                        SocketChannel client = serverSocketChannel.accept(); //non blocking accept
                        System.out.println("Connection Accepted: " + client.getLocalAddress());

                        client.configureBlocking(false);
                        client.register(selector, SelectionKey.OP_READ);

                    } else if (key.isReadable()) {
                        SocketChannel channel = (SocketChannel) key.channel();

                        ByteBuffer buffer = ByteBuffer.allocate(CAPACITY);
                        int read = channel.read(buffer);
                        if (read != -1) {
                            String result = new String(buffer.array()).trim();
                            if (!result.isEmpty())
                                System.out.println("Message received: " + result + " from: " + channel.getRemoteAddress());
                        } else {
                            key.cancel();
                            System.out.println("Connection closed, key canceled");
                        }
                    }
                } catch (IOException e) {
                    logger.log(Level.SEVERE, e.getMessage());
                } finally {
                    iterator.remove();
                }
            }
        }
    }
}
 

import java.nio.channels.Selector; //导入方法依赖的package包/类
public static void main(String[] argv) throws Exception {

        // server: accept connection and write one byte
        try (ByteServer server = new ByteServer();
             SocketChannel sc = SocketChannel.open(server.address())) {

            server.acceptConnection();
            server.write(1);

            try (Selector sel = Selector.open()) {
                sc.read(ByteBuffer.allocate(1));
                sc.configureBlocking(false);
                sc.register(sel, SelectionKey.OP_READ);
                // previously on Windows select would select channel here, although there was
                // nothing to read
                if (sel.selectNow() != 0)
                    throw new Exception("Select returned nonzero value");
            }
        }

        // Now we will test a two reads combination
        // server: accept connection and write two bytes
        try (ByteServer server = new ByteServer();
             SocketChannel sc = SocketChannel.open(server.address())) {

            server.acceptConnection();
            server.write(2);

            try (Selector sel = Selector.open()) {
                sc.configureBlocking(false);
                sc.register(sel, SelectionKey.OP_READ);
                if (sel.select(TIMEOUT) != 1)
                    throw new Exception("One selected key expected");
                sel.selectedKeys().clear();
                // previously on Windows a channel would get selected only once
                if (sel.selectNow() != 1)
                    throw new Exception("One selected key expected");
                // Previously on Windows two consequent reads would cause select()
                // to select a channel, although there was nothing remaining to
                // read in the channel
                if (sc.read(ByteBuffer.allocate(1)) != 1)
                    throw new Exception("One byte expected");
                if (sc.read(ByteBuffer.allocate(1)) != 1)
                    throw new Exception("One byte expected");
                if (sel.selectNow() != 0)
                    throw new Exception("Select returned nonzero value");
            }
        }
    }