1. 一般的互联网项目，都涉及多数据的处理，这个是再常见不过的事情了，如果是但线程去对数据做处理，明显性能上是慢了很多，那么有没有什么好的方式呐？

当然有，这就是java本身的多线程机制对应java 多线程的问题，有一大堆的demo去做参考，在jdk的的 java.util.concurrent 包下，提供了很多的可以使用的api ，不再类述了。。。

2. 主要用的到是ThreadPoolExecutor：常用构造方法为：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,

long keepAliveTime, TimeUnit unit,

BlockingQueue<Runnable> workQueue,

RejectedExecutionHandler handler)

corePoolSize： 线程池维护线程的最少数量

maximumPoolSize：线程池维护线程的最大数量

keepAliveTime： 线程池维护线程所允许的空闲时间

unit： 线程池维护线程所允许的空闲时间的单位

workQueue： 线程池所使用的缓冲队列

handler： 线程池对拒绝任务的处理策略

一个任务通过 execute(Runnable)方法被添加到线程池，任务就是一个 Runnable类型的对象，任务的执行方法就是 Runnable类型对象的run()方法。

当一个任务通过execute(Runnable)方法欲添加到线程池时：

如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。

如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。

如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。

如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。

也就是：处理任务的优先级为：

核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。

当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性：

NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。

workQueue我常用的是：java.util.concurrent.ArrayBlockingQueue

handler有四个选择：

ThreadPoolExecutor.AbortPolicy()

抛出java.util.concurrent.RejectedExecutionException异常

ThreadPoolExecutor.CallerRunsPolicy()

重试添加当前的任务，他会自动重复调用execute()方法

ThreadPoolExecutor.DiscardOldestPolicy()

抛弃旧的任务

ThreadPoolExecutor.DiscardPolicy()

抛弃当前的任务

3. 最近在做一个项目，将这个使用记一下，方便发现问题和后期做修改。其他不说了，主要看代码：

public class AcceptServer implements Runnable {

public final Logger logger = Logger.getLogger(AcceptServer.class);

//服务端,用来接收来自c程序发送的字节码数据.

private ServerSocket server = null;

//线程池

public static ThreadPoolExecutor executor = null;

/**

* 初始化方法，工程启动时调用

*/

public void initRevc(){

try {

executor = new ThreadPoolExecutor(200,300,1,TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(300),

new ThreadPoolExecutor.CallerRunsPolicy()

);

logger.debug("PersonaeServer start to run");

server = new ServerSocket(Integer.parseInt(getOperatePort("ServerPort","25105")));

AcceptServer recv = new AcceptServer();

recv.setServer(server);

Thread thread = new Thread(recv);

thread.start();

} catch (IOException e) {

logger.error(e.getMessage());

} catch (Exception ex) {

logger.error(ex.getMessage());

}

}

public void run() {

Socket client = null;

while(true){

try {

logger.debug("PersonaeServer befor server.accept()");

client = this.getServer().accept();

client.setSoTimeout(60000*10);

logger.debug("PersonaeServer after server.accept()");

//对流文件做处理的入口方式

QueryReader.parseByteReader(new BufferedInputStream(client.getInputStream()), client);

} catch (IOException e) {

logger.error(e.getMessage());

} catch (Exception ex) {

logger.error(ex.getMessage());

}

}

}

/**

* 读配置文件取接收端口

* @param property

* @param defaultValue

* @return

*/

private String getOperatePort(String property,String defaultValue){

Properties prop = new Properties();

InputStream fis = getClass().getClassLoader().getResourceAsStream("config.properties");

try {

prop.load(fis);

} catch (IOException e) {

logger.error(e.getMessage());

}

String value = prop.getProperty(property,defaultValue).trim();

logger.debug(property+" value=="+value);

return value;

}

public ServerSocket getServer() {

return server;

}

public void setServer(ServerSocket server) {

this.server = server;

}

}

通过这个框架代码，就可以用来在服务端处理客户端发过来的请求，并做出相应的相应。

QueryReader.parseByteReader(new BufferedInputStream(client.getInputStream()), client); 主要是对数据做处理的，并返回相应的成功代码的。

4. 部署注意点：

1). 此方法采用动态读取ip和端口的方式来获取客户端的流信息，所以要动态的配置config.properties文件中的ip和端口；

2). 采用spring的ben工程来初始化，将该线程放入beanFactory中去：

<bean class="com.AcceptServer " init-method="initRevc">

5. 在使用多线程处理问题的时候，可以根据自己的习惯，采用java.util.concurrent 包下提供的api 来做对数据，对业务的处理工作。