Java 并发专题： Executor详细介绍打造基于Executor的Web服务器

来源：互联网发布：python qq机器人编辑：程序博客网时间：2024/05/16 17:01

转载标明出处：http://blog.csdn.NET/lmj623565791/article/details/26938985

继续并发，貌似并发的文章很少有人看啊~哈~

今天准备详细介绍Java并发包下的Executor，以及Java提供了很多灵活的且极其方便的线程池的创建。

嗯，那就慢慢说，大家肯定都学过Socket，JavaSe的时候写聊天程序，游戏的服务器，以及Android程序自己需要提供服务器的，都会拿Socket来自己写个：

最初我们的服务器可能写成这样：

1、单线程服务器

[java] view plain copy

print?

package com.zhy.concurrency.executors;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 单线程Web服务器
*
* @author zhy
*
*/
public class SingleThreadWebServer
{
public static void main(String[] args) throws IOException
{
ServerSocket server = new ServerSocket(7711);
while (true)
{
Socket client = server.accept();
handleReq(client);
}
}
/**
* 处理请求
* @param client
*/
private static void handleReq(Socket client)
{
}
}

package com.zhy.concurrency.executors;import java.io.IOException;import java.net.ServerSocket;import java.net.Socket;/** * 单线程Web服务器 *  * @author zhy *  */public class SingleThreadWebServer{    public static void main(String[] args) throws IOException    {        ServerSocket server = new ServerSocket(7711);        while (true)        {            Socket client = server.accept();            handleReq(client);        }    }    /**     * 处理请求     * @param client     */    private static void handleReq(Socket client)    {    }}

这样的服务器代码很简单，理论上也是正确的，但是在实现的环境中却很糟糕，因为它每次只能处理一个请求，如果每个请求的耗时过长，后面的请求会长时间等待或者超时错误。

于是乎，出现了下面这种写法：

2、每个请求分配一个线程的服务器

[java] view plain copy

print?

package com.zhy.concurrency.executors;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 为每个请求分配一个线程
* @author zhy
*
*/
public class TaskPreThreadServer
{
public static void main(String[] args) throws IOException
{
ServerSocket server = new ServerSocket(8811);
while (true)
{
final Socket client = server.accept();
new Thread()
{
public void run()
{
handleReq(client);
};
}.start();
}
}
protected static void handleReq(Socket client)
{
}
}

package com.zhy.concurrency.executors;import java.io.IOException;import java.net.ServerSocket;import java.net.Socket;/** * 为每个请求分配一个线程 * @author zhy * */public class TaskPreThreadServer{    public static void main(String[] args) throws IOException    {        ServerSocket server = new ServerSocket(8811);        while (true)        {            final Socket client = server.accept();            new Thread()            {                public void run()                {                    handleReq(client);                };            }.start();        }    }    protected static void handleReq(Socket client)    {    }}

为每一个请求开辟一个线程，首先我得承认我也经常用这样的写法~但是我们还是要吐槽下这样写法的不足：

a、线程的生命周期的开销还是相当高的，大量的线程的创建将消耗大量的计算机资源

b、可创建线程的数量存在一个限制值（这个值由平台觉得，且受很多因素的制约），如果超过这个限制，可能会报OOM错误

c、在一定范围内，增加线程可以提高系统吞吐量，但是超过了这个范围，就物极必反了，只会降低程序的执行速度。

所以我们要继续改进我们的服务器代码，Executor提供了非常方便的方式：

3、基于Executor的服务器

[java] view plain copy

print?

package com.zhy.concurrency.executors;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
/**
* 基于Executor的服务器
* @author zhy
*
*/
public class TaskExecutionServer
{
private static final int THREAD_COUNT = 100;
private static final Executor exec = Executors
.newFixedThreadPool(THREAD_COUNT);
public static void main(String[] args) throws IOException
{
ServerSocket server = new ServerSocket(9911);
while (true)
{
final Socket client = server.accept();
Runnable task = new Runnable()
{
@Override
public void run()
{
handleReq(client);
}
};
exec.execute(task);
}
}
protected static void handleReq(Socket client)
{
}
}

package com.zhy.concurrency.executors;import java.io.IOException;import java.net.ServerSocket;import java.net.Socket;import java.util.concurrent.Executor;import java.util.concurrent.Executors;/** * 基于Executor的服务器 * @author zhy * */public class TaskExecutionServer{    private static final int THREAD_COUNT = 100;    private static final Executor exec = Executors            .newFixedThreadPool(THREAD_COUNT);    public static void main(String[] args) throws IOException    {        ServerSocket server = new ServerSocket(9911);        while (true)        {            final Socket client = server.accept();            Runnable task = new Runnable()            {                @Override                public void run()                {                    handleReq(client);                }            };            exec.execute(task);        }    }    protected static void handleReq(Socket client)    {    }}

创建一个固定长度的线程池，既解决了单线程的阻塞问题，也解决了无限创建线程带来的内存消耗过多等问题。

4、Executors的API介绍

Java类库提供了许多静态方法来创建一个线程池：

a、newFixedThreadPool 创建一个固定长度的线程池，当到达线程最大数量时，线程池的规模将不再变化。

b、newCachedThreadPool 创建一个可缓存的线程池，如果当前线程池的规模超出了处理需求，将回收空的线程；当需求增加时，会增加线程数量；线程池规模无限制。

c、newSingleThreadPoolExecutor 创建一个单线程的Executor，确保任务对了，串行执行

d、newScheduledThreadPool 创建一个固定长度的线程池，而且以延迟或者定时的方式来执行，类似Timer；后面后单独使用Blog介绍它与Timer区别

小结一下：在线程池中执行任务比为每个任务分配一个线程优势更多，通过重用现有的线程而不是创建新线程，可以在处理多个请求时分摊线程创建和销毁产生的巨大的开销。当请求到达时，通常工作线程已经存在，提高了响应性；通过配置线程池的大小，可以创建足够多的线程使CPU达到忙碌状态，还可以防止线程太多耗尽计算机的资源。

好了，结束~欢迎大家留言~

阅读全文

0 0

Java 并发专题 ： Executor详细介绍 打造基于Executor的Web服务器

1、单线程服务器

2、每个请求分配一个线程的服务器

3、基于Executor的服务器

4、Executors的API介绍

Java 并发专题： Executor详细介绍打造基于Executor的Web服务器