java.nio.channels.AsynchronousChannelGroup Java Examples

public synchronized void startServer(SocketAddress addr, Object attachment, AsynchronousChannelGroup group)
{
	stopServer();
	try
	{
		_acceptor = AsynchronousServerSocketChannel.open(group);
		int backlog = onAcceptorCreated(_acceptor, attachment);
		if (backlog >= 0)
		{
			_acceptor.bind(addr, backlog);
			beginAccept();
			return;
		}
	}
	catch (Throwable e)
	{
		doException(null, e);
	}
	stopServer();
}
 

@Override
public void startService() {
	super.startService();
	try {
		//启动acceptor，开始接受连接
		acceptHandler = new RpcAcceptCompletionHandler();
		acceptHandler.startService();
		channelGroup = AsynchronousChannelGroup.withThreadPool(Executors.newFixedThreadPool(channelGroupThreads));
		serverChannel = AsynchronousServerSocketChannel.open(channelGroup).bind(new InetSocketAddress(this.getHost(), this.getPort()));
		serverChannel.accept(this, acceptHandler);
		this.startListeners();
		this.fireStartNetListeners();
	} catch (IOException e) {
		throw new RpcException(e);
	}
}
 

public void startClient(SocketAddress addr, Object attachment, AsynchronousChannelGroup group)
{
	AsynchronousSocketChannel channel = null;
	try
	{
		channel = AsynchronousSocketChannel.open(group);
		int recvBufSize = onChannelCreated(channel, attachment);
		if (recvBufSize >= 0)
			channel.connect(addr, new ConnectParam(channel, recvBufSize), _connectHandler);
		else
			channel.close();
	}
	catch (Throwable e)
	{
		doException(null, e);
		closeChannel(channel);
	}
}
 

public void test(AsynchronousChannelGroup asynchronousChannelGroup, BufferPagePool bufferPagePool, AbstractMessageProcessor<String> processor) throws InterruptedException, ExecutionException, IOException {
        AioQuickClient<String> client = new AioQuickClient<>("localhost", 8888, new StringProtocol(), processor);
        client.setBufferPagePool(bufferPagePool);
        client.setWriteBuffer(1024 * 1024, 10);
        AioSession<String> session = client.start(asynchronousChannelGroup);
        WriteBuffer outputStream = session.writeBuffer();

        byte[] data = "smart-socket".getBytes();
        while (true) {
            int num = (int) (Math.random() * 10) + 1;
//            int num = 4;
            outputStream.writeInt(data.length * num);
            while (num-- > 0) {
                outputStream.write(data);
            }

//            Thread.sleep(100);
        }
    }
 

/**
 * 连接服务端，指定绑定地址
 *
 * @param remote 远程地址
 * @param bind 本机绑定地址
 * @return channelContext
 * @throws IOException io异常时抛出
 */
public ChannelContext connect(InetSocketAddress remote, InetSocketAddress bind)
    throws IOException {
  AsynchronousChannelGroup channelGroup = AsynchronousChannelGroup
      .withThreadPool(groupContext.getGroupExecutor());
  groupContext.setChannelGroup(channelGroup);
  AsynchronousSocketChannel channel = IoUtils.create(channelGroup, bind);
  groupContext.setAioListener(new ComposeAioListener().add(ClientAioListener.INSTANCE)
      .add(groupContext.getAioListener()));

  ChannelContext channelContext = new ChannelContext(groupContext, channel, false);
  channelContext.setServerAddress(remote);
  channel.connect(remote, channelContext, ConnectHandler.INSTANCE);

  BeatProcessor beat = new BeatProcessor(channelContext);
  ThreadUtils.globalTimer()
      .scheduleWithDelay(beat, groupContext.getBeatInterval(), TimeUnit.MILLISECONDS, beat);
  return channelContext;
}
 

public void test(AsynchronousChannelGroup asynchronousChannelGroup, BufferPagePool bufferPagePool, AbstractMessageProcessor<String> processor) throws InterruptedException, ExecutionException, IOException {
        AioQuickClient<String> client = new AioQuickClient<>("localhost", 8888, new StringProtocol(), processor);
        client.setBufferPagePool(bufferPagePool);
        client.setWriteBuffer(1024 * 1024, 10);
        AioSession<String> session = client.start(asynchronousChannelGroup);
        WriteBuffer outputStream = session.writeBuffer();

        byte[] data = "smart-socket".getBytes();
        while (true) {
            int num = (int) (Math.random() * 10) + 1;
//            int num = 4;
            outputStream.writeInt(data.length * num);
            while (num-- > 0) {
                outputStream.write(data);
            }

//            Thread.sleep(100);
        }
    }
 

@Override
public void listen(int thread, int port, AioServerListener listener) {
    this.port = port;
    this.listener = listener;
    try {
        channelGroup = AsynchronousChannelGroup.withFixedThreadPool(thread, Executors.defaultThreadFactory());
        serverSocketChannel = AsynchronousServerSocketChannel.open(channelGroup);
        serverSocketChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
        serverSocketChannel.bind(new InetSocketAddress(port));
        serverSocketChannel.accept(null, this);

        if (logger.isInfoEnable())
            logger.info("启动AIO监听[{}]服务。", port);
    } catch (IOException e) {
        logger.warn(e, "启动AIO监听[{}]服务时发生异常！", port);
    }
}
 

private void initAioProcessor(int processorCount) throws IOException {
    for (int i = 0; i < processorCount; i++) {
        asyncChannelGroups[i] = AsynchronousChannelGroup.withFixedThreadPool(processorCount,
                new ThreadFactory() {
                    private int inx = 1;

                    @Override
                    public Thread newThread(Runnable r) {
                        Thread th = new Thread(r);
                        //TODO
                        th.setName(DirectByteBufferPool.LOCAL_BUF_THREAD_PREX + "AIO" + (inx++));
                        LOGGER.info("created new AIO thread " + th.getName());
                        return th;
                    }
                }
        );
    }
}
 

/**
 * 通道异步线程池
 */
private void checkChannelGroup(){
	//检查group
	if(channelGroup==null){
		try {
			channelGroup = AsynchronousChannelGroup.withThreadPool(Executors.newFixedThreadPool(channelGroupThreads));
		} catch (IOException e) {
			throw new RpcException(e);
		}
	}
}
 

public static AsynchronousChannelGroup register() {
    synchronized (lock) {
        if (usageCount == 0) {
            group = createAsynchronousChannelGroup();
        }
        usageCount++;
        return group;
    }
}
 

public void setUpHandlers() {
	try {
		AsynchronousChannelGroup asyncChannelGroup = AsynchronousChannelGroup
				.withFixedThreadPool(poolSize,Executors.defaultThreadFactory());
		serverSocketChannel = AsynchronousServerSocketChannel
				.open(asyncChannelGroup).bind(new InetSocketAddress(listenPort));
		serverSocketChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
		//serverSocketChannel.setOption(StandardSocketOption.TCP_NODELAY, true);
	} catch (IOException e) {
		e.printStackTrace();
	}

	log.info("** " + poolSize + " handler thread has been setup! **");
	log.info("** Socket Server has been startup, listen port is " + listenPort + "! **");
}
 

static void testAttackingTask(AsynchronousChannelGroup group) throws Exception {
    Executor executor = (Executor)group;
    Attack task = new Attack();
    executor.execute(task);
    task.waitUntilDone();
    if (!task.failedDueToSecurityException())
        throw new RuntimeException("SecurityException expected");
}
 

static void testSimpleTask(AsynchronousChannelGroup group) throws Exception {
    Executor executor = (Executor)group;
    final CountDownLatch latch = new CountDownLatch(1);
    executor.execute(new Runnable() {
        public void run() {
            latch.countDown();
        }
    });
    latch.await();
}
 

public static void main(String[] args) throws Exception {
    // create channel groups
    ThreadFactory factory = new PrivilegedThreadFactory();
    AsynchronousChannelGroup group1 = AsynchronousChannelGroup
        .withFixedThreadPool(5, factory);
    AsynchronousChannelGroup group2 = AsynchronousChannelGroup
        .withCachedThreadPool(Executors.newCachedThreadPool(factory), 0);
    AsynchronousChannelGroup group3 = AsynchronousChannelGroup
        .withThreadPool(Executors.newFixedThreadPool(10, factory));

    try {
        // execute simple tasks
        testSimpleTask(group1);
        testSimpleTask(group2);
        testSimpleTask(group3);

        // install security manager and test again
        System.setSecurityManager( new SecurityManager() );
        testSimpleTask(group1);
        testSimpleTask(group2);
        testSimpleTask(group3);

        // attempt to execute tasks that run with only frames from boot
        // class loader on the stack.
        testAttackingTask(group1);
        testAttackingTask(group2);
        testAttackingTask(group3);
    } finally {
        group1.shutdown();
        group2.shutdown();
        group3.shutdown();
    }
}
 

static void testAttackingTask(AsynchronousChannelGroup group) throws Exception {
    Executor executor = (Executor)group;
    Attack task = new Attack();
    executor.execute(task);
    task.waitUntilDone();
    if (!task.failedDueToSecurityException())
        throw new RuntimeException("SecurityException expected");
}
 

public void setUpHandlers() {
	try {
		AsynchronousChannelGroup asyncChannelGroup = AsynchronousChannelGroup.withFixedThreadPool(poolSize, Executors.defaultThreadFactory());
		serverSocketChannel = AsynchronousServerSocketChannel.open(asyncChannelGroup).bind(new InetSocketAddress(listenPort));
		serverSocketChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
		
		log.info("** " + poolSize + " handler thread has been setup! **");
		log.info("** Socket Server has been startup, listen port is " + listenPort + "! **");
	} catch (IOException e) {
		log.error("setUpHandlers error: ", e);
	}
}
 

public AIOAcceptor(String name, String ip, int port,
		FrontendConnectionFactory factory, AsynchronousChannelGroup group)
		throws IOException {
	this.name = name;
	this.port = port;
	this.factory = factory;
	serverChannel = AsynchronousServerSocketChannel.open(group);
	/** 设置TCP属性 */
	serverChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
	serverChannel.setOption(StandardSocketOptions.SO_RCVBUF, 1024 * 16 * 2);
	// backlog=100
	serverChannel.bind(new InetSocketAddress(ip, port), 100);
}
 

static void testSimpleTask(AsynchronousChannelGroup group) throws Exception {
    Executor executor = (Executor)group;
    final CountDownLatch latch = new CountDownLatch(1);
    executor.execute(new Runnable() {
        public void run() {
            latch.countDown();
        }
    });
    latch.await();
}
 

public static void main(String[] args) throws Exception {
    // create channel groups
    ThreadFactory factory = new PrivilegedThreadFactory();
    AsynchronousChannelGroup group1 = AsynchronousChannelGroup
        .withFixedThreadPool(5, factory);
    AsynchronousChannelGroup group2 = AsynchronousChannelGroup
        .withCachedThreadPool(Executors.newCachedThreadPool(factory), 0);
    AsynchronousChannelGroup group3 = AsynchronousChannelGroup
        .withThreadPool(Executors.newFixedThreadPool(10, factory));

    try {
        // execute simple tasks
        testSimpleTask(group1);
        testSimpleTask(group2);
        testSimpleTask(group3);

        // install security manager and test again
        System.setSecurityManager( new SecurityManager() );
        testSimpleTask(group1);
        testSimpleTask(group2);
        testSimpleTask(group3);

        // attempt to execute tasks that run with only frames from boot
        // class loader on the stack.
        testAttackingTask(group1);
        testAttackingTask(group2);
        testAttackingTask(group3);
    } finally {
        group1.shutdown();
        group2.shutdown();
        group3.shutdown();
    }
}
 

static void testAttackingTask(AsynchronousChannelGroup group) throws Exception {
    Executor executor = (Executor)group;
    Attack task = new Attack();
    executor.execute(task);
    task.waitUntilDone();
    if (!task.failedDueToSecurityException())
        throw new RuntimeException("SecurityException expected");
}
 

/**
 * get next AsynchronousChannel ,first is exclude if multi
 * AsynchronousChannelGroups
 *
 * @return
 */
public AsynchronousChannelGroup getNextAsyncChannelGroup() {
    if (asyncChannelGroups.length == 1) {
        return asyncChannelGroups[0];
    } else {
        int index = (++channelIndex) % asyncChannelGroups.length;
        if (index == 0) {
            ++channelIndex;
            return asyncChannelGroups[1];
        } else {
            return asyncChannelGroups[index];
        }

    }
}
 

public static void main(String[] args) throws Exception {
    // create channel groups
    ThreadFactory factory = new PrivilegedThreadFactory();
    AsynchronousChannelGroup group1 = AsynchronousChannelGroup
        .withFixedThreadPool(5, factory);
    AsynchronousChannelGroup group2 = AsynchronousChannelGroup
        .withCachedThreadPool(Executors.newCachedThreadPool(factory), 0);
    AsynchronousChannelGroup group3 = AsynchronousChannelGroup
        .withThreadPool(Executors.newFixedThreadPool(10, factory));

    try {
        // execute simple tasks
        testSimpleTask(group1);
        testSimpleTask(group2);
        testSimpleTask(group3);

        // install security manager and test again
        System.setSecurityManager( new SecurityManager() );
        testSimpleTask(group1);
        testSimpleTask(group2);
        testSimpleTask(group3);

        // attempt to execute tasks that run with only frames from boot
        // class loader on the stack.
        testAttackingTask(group1);
        testAttackingTask(group2);
        testAttackingTask(group3);
    } finally {
        group1.shutdown();
        group2.shutdown();
        group3.shutdown();
    }
}
 

static void testSimpleTask(AsynchronousChannelGroup group) throws Exception {
    Executor executor = (Executor)group;
    final CountDownLatch latch = new CountDownLatch(1);
    executor.execute(new Runnable() {
        public void run() {
            latch.countDown();
        }
    });
    latch.await();
}
 

static void testSimpleTask(AsynchronousChannelGroup group) throws Exception {
    Executor executor = (Executor)group;
    final CountDownLatch latch = new CountDownLatch(1);
    executor.execute(new Runnable() {
        public void run() {
            latch.countDown();
        }
    });
    latch.await();
}
 

public static void main(String[] args) throws Exception {
    // create channel groups
    ThreadFactory factory = new PrivilegedThreadFactory();
    AsynchronousChannelGroup group1 = AsynchronousChannelGroup
        .withFixedThreadPool(5, factory);
    AsynchronousChannelGroup group2 = AsynchronousChannelGroup
        .withCachedThreadPool(Executors.newCachedThreadPool(factory), 0);
    AsynchronousChannelGroup group3 = AsynchronousChannelGroup
        .withThreadPool(Executors.newFixedThreadPool(10, factory));

    try {
        // execute simple tasks
        testSimpleTask(group1);
        testSimpleTask(group2);
        testSimpleTask(group3);

        // install security manager and test again
        System.setSecurityManager( new SecurityManager() );
        testSimpleTask(group1);
        testSimpleTask(group2);
        testSimpleTask(group3);

        // attempt to execute tasks that run with only frames from boot
        // class loader on the stack.
        testAttackingTask(group1);
        testAttackingTask(group2);
        testAttackingTask(group3);
    } finally {
        group1.shutdown();
        group2.shutdown();
        group3.shutdown();
    }
}
 

static void testAttackingTask(AsynchronousChannelGroup group) throws Exception {
    Executor executor = (Executor)group;
    Attack task = new Attack();
    executor.execute(task);
    task.waitUntilDone();
    if (!task.failedDueToSecurityException())
        throw new RuntimeException("SecurityException expected");
}
 

static void testSimpleTask(AsynchronousChannelGroup group) throws Exception {
    Executor executor = (Executor)group;
    final CountDownLatch latch = new CountDownLatch(1);
    executor.execute(new Runnable() {
        public void run() {
            latch.countDown();
        }
    });
    latch.await();
}
 

public static void main(String[] args) throws Exception {
    // create channel groups
    ThreadFactory factory = new PrivilegedThreadFactory();
    AsynchronousChannelGroup group1 = AsynchronousChannelGroup
        .withFixedThreadPool(5, factory);
    AsynchronousChannelGroup group2 = AsynchronousChannelGroup
        .withCachedThreadPool(Executors.newCachedThreadPool(factory), 0);
    AsynchronousChannelGroup group3 = AsynchronousChannelGroup
        .withThreadPool(Executors.newFixedThreadPool(10, factory));

    try {
        // execute simple tasks
        testSimpleTask(group1);
        testSimpleTask(group2);
        testSimpleTask(group3);

        // install security manager and test again
        System.setSecurityManager( new SecurityManager() );
        testSimpleTask(group1);
        testSimpleTask(group2);
        testSimpleTask(group3);

        // attempt to execute tasks that run with only frames from boot
        // class loader on the stack.
        testAttackingTask(group1);
        testAttackingTask(group2);
        testAttackingTask(group3);
    } finally {
        group1.shutdown();
        group2.shutdown();
        group3.shutdown();
    }
}
 

static void testAttackingTask(AsynchronousChannelGroup group) throws Exception {
    Executor executor = (Executor)group;
    Attack task = new Attack();
    executor.execute(task);
    task.waitUntilDone();
    if (!task.failedDueToSecurityException())
        throw new RuntimeException("SecurityException expected");
}
 

/**
 * get next AsynchronousChannel ,first is exclude if multi
 * AsynchronousChannelGroups
 *
 * @return AsynchronousChannelGroup
 */
public AsynchronousChannelGroup getNextAsyncChannelGroup() {
    if (asyncChannelGroups.length == 1) {
        return asyncChannelGroups[0];
    } else {
        int index = (channelIndex.incrementAndGet()) % asyncChannelGroups.length;
        if (index == 0) {
            channelIndex.incrementAndGet();
            return asyncChannelGroups[1];
        } else {
            return asyncChannelGroups[index];
        }

    }
}