/* * Copyright 2012-2015 org.opencloudb. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.opencloudb.net; import java.io.IOException; import java.util.Iterator; import java.util.Map.Entry; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import org.opencloudb.buffer.BufferPool; import org.opencloudb.statistic.CommandCount; import org.opencloudb.util.ExecutorUtil; import org.opencloudb.util.NameableExecutor; /** * @author mycat */ public final class NIOProcessor { private static final int DEFAULT_BUFFER_SIZE = 1024 * 1024 * 64; private static final int DEFAULT_BUFFER_CHUNK_SIZE = 4096; private static final int AVAILABLE_PROCESSORS = Runtime.getRuntime() .availableProcessors(); private final String name; private final NIOReactor reactor; private final BufferPool bufferPool; // private final NameableExecutor handler; private final NameableExecutor executor; private final ConcurrentMap<Long, FrontendConnection> frontends; private final ConcurrentMap<Long, BackendConnection> backends; private final CommandCount commands; private long netInBytes; private long netOutBytes; public NIOProcessor(String name) throws IOException { this(name, DEFAULT_BUFFER_SIZE, DEFAULT_BUFFER_CHUNK_SIZE, AVAILABLE_PROCESSORS, AVAILABLE_PROCESSORS); } public NIOProcessor(String name, int handler, int executor) throws IOException { this(name, DEFAULT_BUFFER_SIZE, DEFAULT_BUFFER_CHUNK_SIZE, handler, executor); } public NIOProcessor(String name, int buffer, int chunk, int handler, int executor) throws IOException { this.name = name; this.reactor = new NIOReactor(name); this.bufferPool = new BufferPool(buffer, chunk); // this.handler = (handler > 0) ? ExecutorUtil // .create(name + "-H", handler) : null; this.executor = (executor > 0) ? ExecutorUtil.create(name + "-E", executor) : null; this.frontends = new ConcurrentHashMap<Long, FrontendConnection>(); this.backends = new ConcurrentHashMap<Long, BackendConnection>(); this.commands = new CommandCount(); } public String getName() { return name; } public BufferPool getBufferPool() { return bufferPool; } public int getRegisterQueueSize() { return reactor.getRegisterQueue().size(); } public int getWriteQueueSize() { return reactor.getWriteQueue().size(); } // public NameableExecutor getHandler() { // return handler; // } public NameableExecutor getExecutor() { return executor; } public void startup() { reactor.startup(); } public void postRegister(NIOConnection c) { reactor.postRegister(c); } public void postWrite(NIOConnection c) { reactor.postWrite(c); } public CommandCount getCommands() { return commands; } public long getNetInBytes() { return netInBytes; } public void addNetInBytes(long bytes) { netInBytes += bytes; } public long getNetOutBytes() { return netOutBytes; } public void addNetOutBytes(long bytes) { netOutBytes += bytes; } public long getReactCount() { return reactor.getReactCount(); } public void addFrontend(FrontendConnection c) { frontends.put(c.getId(), c); } public ConcurrentMap<Long, FrontendConnection> getFrontends() { return frontends; } public void addBackend(BackendConnection c) { backends.put(c.getId(), c); } public ConcurrentMap<Long, BackendConnection> getBackends() { return backends; } /** * 定时执行该方法,回收部分资源。 */ public void check() { frontendCheck(); backendCheck(); } // 前端连接检查 private void frontendCheck() { Iterator<Entry<Long, FrontendConnection>> it = frontends.entrySet() .iterator(); while (it.hasNext()) { FrontendConnection c = it.next().getValue(); // 删除空连接 if (c == null) { it.remove(); continue; } // 清理已关闭连接,否则空闲检查。 if (c.isClosed()) { it.remove(); c.cleanup(); } else { c.idleCheck(); } } } // 后端连接检查 private void backendCheck() { Iterator<Entry<Long, BackendConnection>> it = backends.entrySet() .iterator(); while (it.hasNext()) { BackendConnection c = it.next().getValue(); // 删除空连接 if (c == null) { it.remove(); continue; } // 清理已关闭连接,否则空闲检查。 if (c.isClosed()) { it.remove(); c.cleanup(); } else { c.idleCheck(); } } } }