在CPU和内存还有磁盘IO并没有充分利用的时候，就可以在重构的时候，使用线程操作，将过去需要占用一定时间的同步操作，进行并发处理。这样，创建多个线程来解决同一个问题。这样就可以使操作成为异步，不需要进行等待就可以同时操作很多事情。
那么线程需要创建多少呢？
每监听到一个请求就创建一个线程，然后操作之后就销毁。这种办法可行么？
如果突然在客户端提交了1000000 * N 个请求，这些请求都进入服务器，然后在这里，为每一个请求都创建一个线程来执行。这样程序就会失去控制。最终挤爆服务器CPU和内存，使程序崩溃。
怎么样合理、可控的处理操作，变成了重点。
线程池，顾名思义，在池化开发的现在，如数据库连接池这种开发模式已经广泛流行。
在池中创建连接实例，在访问数据库时，从连接池中取得连接，操作之后归还。这样就可以有效的限制资源数量，但是又能提高操作速度。
package test.dao;
import java.util.LinkedList;
import org.apache.log4j.Logger;
/**
*
* @author Andy.xiaomeng
*
*/
public class ThreadPool {
private static final Logger Log = Logger.getLogger(ThreadPool.class);
private ThreadWorker[] worker;
private LinkedList queue;
private int poolSize;
public int getPoolSize(){
return poolSize;
}
//initialize thread pool with pool size
public ThreadPool(int size){
poolSize = size;
worker = new ThreadWorker[size];
queue = new LinkedList();
for (int i = 0; i < size; i++) {
worker[i] = new ThreadWorker();
worker[i].start();
}
}
//add work queue
public void addQueue(Runnable runnable){
synchronized(queue) {
queue.add(runnable);
queue.notify();
}
}
//worker do work
private class ThreadWorker extends Thread{
public void run(){
//runnable
Runnable runable;
while (true) {
synchronized(queue) {
while (queue.isEmpty()) {
try
{
//is work queue is empty, wait
queue.wait();
}
catch (Exception e)
{
Log.error("pool queue wait", e);
}
}
//get work in queue, and remove it
runable = queue.removeFirst();
}
try {
//do work
runable.run();
}
catch (RuntimeException e) {
Log.error("unknow runtime exception", e);
}
}
}
}
public static void main(String[] args) {
//test
ThreadPool pool = new ThreadPool(111);
//
class SSS implements Runnable{
private String abc;
public void setAbc(String aaaaa){
this.abc = aaaaa;
}
public void run() {
System.out.println("do runnable " + abc);
}
}
for (int i = 0; i < 200; i++) {
SSS a = new SSS();
a.setAbc(String.valueOf(i + 1));
pool.addQueue(a);
}
}
}
Java高架构师、分布式架构、高可扩展、高性能、高并发、性能优化、Spring boot、Redis、ActiveMQ、Nginx、Mycat、Netty、Jvm大型分布式项目实战学习架构师视频免费获取架构群：854180697 加群链接
网友评论