1. Python技术站首页
  2. 其他
  3. Java

Java 网络编程 —— 创建多线程服务器

• Java
yizhihongxing

一个典型的单线程服务器示例如下：

while (true) {
    Socket socket = null;
    try {
        // 接收客户连接
        socket = serverSocket.accept();
        // 从socket中获得输入流与输出流，与客户通信
        ...
    } catch(IOException e) {
        e.printStackTrace()
    } finally {
        try {
            if(socket != null) {
                // 断开连接
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

服务端接收到一个客户连接，就与客户进行通信，通信完毕后断开连接，然后接收下一个客户连接，假如同时有多个客户连接请求这些客户就必须排队等候。如果长时间让客户等待，就会使网站失去信誉，从而降低访问量。

一般用并发性能来衡量一个服务器同时响应多个客户的能力，一个具有好的并发性能的服务器，必须符合两个条件：

  • 能同时接收并处理多个客户连接
  • 对于每个客户，都会迅速给予响应

用多个线程来同时为多个客户提供服务，这是提高服务器并发性能的最常用的手段，一般有三种方式：

  • 为每个客户分配一个工作线程
  • 创建一个线程池，由其中的工作线程来为客户服务
  • 利用 Java 类库中现成的线程池，由它的工作线程来为客户服务

为每个客户分配一个线程

服务器的主线程负责接收客户的连接，每次接收到一个客户连接，都会创建一个工作线程，由它负责与客户的通信

public class EchoServer {
    
    private int port = 8000;
    private ServerSocket serverSocket;
    
    public EchoServer() throws IOException {
        serverSocket = new ServerSocket(port);
        System.out.println("服务器启动");
    }
        
    public void service() {
        while(true) {
            Socket socket = null;
            try {
                // 接教客户连接
                socket = serverSocket.accept();
                // 创建一个工作线程
                Thread workThread = new Thread(new Handler(socket));
                // 启动工作线程
                workThread.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String args[])throws TOException {
        new EchoServer().service();
    }
    
    // 负责与单个客户的通信   
    class Handler implements Runnable {
        
        private Socket socket;
        
        pub1ic Handler(Socket socket) {
            this.socket = socket;
        }
        
        private PrintWriter getWriter(Socket socket) throws IOException {...}
        
        private BufferedReader getReader(Socket socket) throws IOException {...}
        
        public String echo(String msg) {...}
        
        public void run() {
            try {
                System.out.println("New connection accepted" + socket.getInetAddress() + ":" + socket.getPort());
                BufferedReader br = getReader(socket);
                PrintWriter pw = getWriter(socket);
                
                String msg = null;
                // 接收和发送数据，直到通信结束
                while ((msg = br.readLine()) != null) {
                    System.out.println("from "+ socket.getInetAddress() + ":" + socket.getPort() + ">" + msg);
                    pw.println(echo(msg));
                    if (msg.equals("bye")) break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    // 断开连接
                    if(socket != nulll) socket.close();
                } catch (IOException e) {
                    e,printStackTrace();
                }
            }
        }
    }
}

创建线程池

上一种实现方式有以下不足之处：

  • 服务器创建和销毁工作线程的开销很大，如果服务器需要与许多客户通信，并且与每个客户的通信时间都很短，那么有可能服务器为客户创建新线程的开销比实际与客户通信的开销还要大
  • 除了创建和销毁线程的开销，活动的线程也消耗系统资源。每个线程都会占用一定的内存，如果同时有大量客户连接服务器，就必须创建大量工作线程，它们消耗了大量内存，可能会导致系统的内存空间不足

线程池中预先创建了一些工作线程，它们不断地从工作队列中取出任务，然后执行该任务。当工作线程执行完一个任务，就会继续执行工作队列中的下一个任务

线程池具有以下优点：

  • 减少了创建和销毁线程的次数，每个工作线程都可以一直被重用，能执行多个任务
  • 可以根据系统的承载能力，方便调整线程池中线程的数目，防止因为消耗过量系统资源而导致系统崩溃
public class ThreadPool extends ThreadGroup {
    
    // 线程池是否关闭
    private boolean isClosed = false;
    // 表示工作队列
    private LinkedList<Runnable> workQueue;
    // 表示线程池ID
    private static int threadPoolID;
    // 表示工作线程ID
    
    // poolSize 指定线程池中的工作线程数目
    public ThreadPool(int poolSize) {
        
        super("ThreadPool-"+ (threadPoolID++));
        setDaemon(true);
        // 创建工作队列
        workQueue = new LinkedList<Runnable>();
        for (int i = 0; i < poolSize; i++) {
            // 创建并启动工作线程
            new WorkThread().start(); 
        }
    }
    
    /**
     * 向工作队列中加入一个新任务，由工作线程去执行任务
     */
    public synchronized void execute(Runnable tank) {
        // 线程池被关则抛出IllegalStateException异常
        if(isClosed) {
            throw new IllegalStateException();
        }
        if(task != null) {
            workQueue.add(task);
            // 唤醒正在getTask()方法中等待任务的工作线限
            notify();
        }
    }
    
    /**
     * 从工作队列中取出一个任务，工作线程会调用此方法
     */
    protected synchronized Runnable getTask() throws InterruptedException {
        while(workQueue,size() == 0) {
            if (isClosed) return null;
            wait(); // 如果工作队列中没有任务，就等待任务
        }
        return workQueue.removeFirst();
    }
    
    /**
     * 关闭线程池
     */
    public synchronized void close() {
        if(!isClosed) {
            isClosed = true;
            // 清空工作队列
            workQueue.clear();
            // 中断所有的工作线程，该方法继承自ThreadGroup类
            interrupt();
        }
    }
    
    /**
     * 等待工作线程把所有任务执行完
     */
    public void join() {
        synchronized (this) {
            isClosed = true;
            // 唤醒还在getTask()方法中等待任务的工作线程
            notifyAll();
        }
        Thread[] threads = new Thread[activeCount()];
        // enumerate()方法继承自ThreadGroup类获得线程组中当前所有活着的工作线程
        int count = enumerate(threads);
        // 等待所有工作线程运行结束
        for(int i = 0; i < count; i++) {
            try {
                // 等待工作线程运行结束
                threads[i].join();
            } catch((InterruptedException ex) {}
        }
    }
    
    /**
     * 内部类:工作线程
     */
    private class WorkThread extends Thread {
    	
        public WorkThread() {
            // 加入当前 ThreadPool 线程组
            super(ThreadPool.this, "WorkThread-" + (threadID++));
        }
        
        public void run() {
            // isInterrupted()方法承自Thread类，判断线程是否被中断
            while (!isInterrupted()) {
                Runnable task = null;
                try {
                    // 取出任务
                    task = getTask();
                } catch(InterruptedException ex) {}
                // 如果 getTask() 返回 nu11 或者线程执行 getTask() 时被中断，则结束此线程
                if(task != null) return;
                // 运行任务，异常在catch代码块中被捕获
                try {
                    task.run();
                } catch(Throwable t) {
                    t.printStackTrace();
                }
            }
        }
    }
}

使用线程池实现的服务器如下：

publlc class EchoServer {
    
    private int port = 8000;
    private ServerSocket serverSocket;
    private ThreadPool threadPool;	// 线程港
    private final int POOL_SIZE = 4;	// 单个CPU时线程池中工作线程的数目
    
    public EchoServer() throws IOException {
        serverSocket = new ServerSocket(port);
        // 创建线程池
        // Runtime 的 availableProcessors() 方法返回当前系统的CPU的数目
        // 系统的CPU越多，线程池中工作线程的数目也越多
        threadPool= new ThreadPool(
        	Runtime.getRuntime().availableProcessors() * POOL_SIZE);
        System.out.println("服务器启动");
    }
    
    public void service() {
        while (true) {
            Socket socket = null;
            try {
                socket = serverSocket.accept();
                // 把与客户通信的任务交给线程池
                threadPool.execute(new Handler(socket));
            } catch(IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String args[])throws TOException {
        new EchoServer().service();
    }
    
    // 负责与单个客户的通信，与上例类似
    class Handler implements Runnable {...}
}

使用 Java 提供的线程池

java.util.concurrent 包提供了现成的线程池的实现，更加健壮，功能也更强大，更多关于线程池的介绍可以这篇文章：

public class Echoserver {
    
    private int port = 8000;
    private ServerSocket serverSocket;
    // 线程池
    private ExecutorService executorService;
    // 单个CPU时线程池中工作线程的数目
    private final int POOL_SIZE = 4;
    
    public EchoServer() throws IOException {
        serverSocket = new ServerSocket(port);
        // 创建线程池
        // Runtime 的 availableProcessors() 方法返回当前系统的CPU的数目
        // 系统的CPU越多，线程池中工作线程的数目也越多
        executorService = Executors.newFixedThreadPool(
        	Runtime.getRuntime().availableProcessors() * POOL_SIZE);
        System.out.println("服务器启动");
    }
    
    public void service() {
        while(true) {
            Socket socket = null;
            try {
                socket = serverSocket.accept();
                executorService.execute(new Handler(socket));
            } catch(IOException e) {
                e.printStackTrace();
            }
        }
    }
    
     public static void main(String args[])throws TOException {
        new EchoServer().service();
    }
    
    // 负责与单个客户的通信，与上例类似
    class Handler implements Runnable {...}
}

使用线程池的注意事项

虽然线程池能大大提高服务器的并发性能，但使用它也存在一定风险，容易引发下面的问题：

  • 死锁

    任何多线程应用程序都有死锁风险。造成死锁的最简单的情形是：线程 A 持有对象 X 的锁，并且在等待对象 Y 的锁，而线程 B 持有对象 Y 的锁，并且在等待对象 X 的锁，线程 A 与线程 B 都不释放自己持有的锁，并且等待对方的锁，这就导致两个线程永远等待下去，死锁就这样产生了

    任何多线程程序都有死锁的风险，但线程池还会导致另外一种死锁：假定线程池中的所有工作线程都在执行各自任务时被阻塞，它们都在等待某个任务 A 的执行结果。而任务 A 依然在工作队列中，由于没有空闲线程，使得任务 A 一直不能被执行。这使得线程池中的所有工作线程都永远阻塞下去，死锁就这样产生了

  • 系统资源不足

    如果线程池中的线程数目非常多，这些线程就会消耗包括内存和其他系统资源在内的大量资源，从而严重影响系统性能

  • 并发错误

    线程池的工作队列依靠 wait() 和 notify() 方法来使工作线程及时取得任务，但这两个方法都难以使用。如果编码不正确，就可能会丢失通知，导致工作线程一直保持空闲状态，无视工作队列中需要处理的任务

  • 线程泄漏

    对于工作线程数目固定的线程池，如果工作线程在执行任务时抛出 RuntimeException 或 Error，并且这些异常或错误没有被捕获，那么这个工作线程就会异常终止，使得线程池永久地失去了一个工作线程。如果所有的工作线程都异常终止，线程池变为空，没有任何可用的工作线程来处理任务

    导致线程泄漏的另一种情形是，工作线程在执行一个任务时被阻塞，比如等待用户的输入数据，但是由于用户一直不输入数据（可能是因为用户走开了），导致这个工作线程一直被阻塞。这样的工作线程名存实亡，它实际上不执行任何任务了。假如线程池中所有的工作线程都处于这样的阻塞状态，那么线程池就无法处理新加入的任务了

  • 任务过载

    当工作队列中有大量排队等候执行的任务，这些任务本身可能会消耗太多的系统资源而引起系统资源缺乏

综上所述，线程池可能会带来种种风险，为了尽可能避免它们，使用线程池时需要遵循以下原则：

  • 如果任务 A 在执行过程中需要同步等待任务 B 的执行结果，那么任务 A 不适合加入线程池的工作队列中。如集把像任务 A 一样的需要等待其他任务执行结果的任务加入工作队列中，就可能会导致线程池的死锁

  • 如果执行某个任务时可能会阻塞，并且是长时间的阻塞，则应该设定超时时间避免工作线程永久地阻塞下去而导致线程泄漏

  • 了解任务的特点，分析任务是执行经常会阻塞的 IO 操作，还是执行一直不会阻塞的运算操作。前者时断时续地占用 CPU，而后者对 CPU 具有更高的利用率。根据任务的特点，对任务进行分类，然后把不同类型的任务分别加入不同线程池的工作队列中，这样可以根据任务的特点分别调整每个线程池

  • 调整线程池的大小，线程池的最佳大小主要取决于系统的可用 CPU 的数目以及工作队列中任务的特点。假如在一个具有 N 个 CPU 的系统上只有一个工作队列并且其中全部是运算性质的任务，那么当线程池具有 N 或 N+1 个工作线程时，一般会获得最大的 CPU 利用率

    如果工作队列中包含会执行 IO 操作并经常阻塞的任务，则要让线程池的大小超过可用 CPU 的数目，因为并不是所有工作线程都一直在工作。选择一个典型的任务，然后估计在执行这个任务的过程中，等待时间（WT）与实际占用 CPU 进行运算的时间（ST）之间的比：WT/ST。对于一个具有 N 个 CPU 的系统，需要设置大约 N(1+WT/ST) 个线程来保证 CPU 得到充分利用

  • 避免任务过载，服务器应根据系统的承受能力，限制客户的并发连接的数目。当客户的并发连接的数目超过了限制值，服务器可以拒绝连接请求，并给予客户友好提示

原文链接：https://www.cnblogs.com/Yee-Q/p/17369186.html

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：Java 网络编程 —— 创建多线程服务器 - Python技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年5月3日
下一篇 2023年5月3日

相关文章

  • Java Spring Boot请求方式与请求映射过程分析

    Java Spring Boot请求方式与请求映射过程分析 引言 Java Spring Boot是一款高效、快速、便捷的Java Web框架，通过对象依赖注入（DI）和面向切面编程（AOP）实现了模块化开发，提高了代码的简洁性和可维护性，常用于开发web应用程序、RESTful API接口等。 本文将详细讲解Java Spring Boot中的请求方式和请…

    Java 2023年5月19日
    00

  • IDEA创建Java Web项目不能及时刷新HTML或JSP页面问题

    当使用IntelliJ IDEA创建Java Web项目并且编写HTML或JSP页面时，可能会遇到页面不能及时刷新的问题，这是由于IDEA默认采用了缓存机制导致的。为了解决这个问题，可以执行以下步骤： 1. 关闭缓存 通过在IDEA的Editor部分中找到Editor > General > Editor Tabs选项，并勾选“Mark modi…

    Java 2023年6月15日
    00

  • spring boot容器启动流程

    下面是关于Spring Boot容器启动流程的详细攻略： 1. 背景介绍 Spring Boot是由Pivotal团队基于Spring Framework开发的一个快速开发框架，它以约定大于配置的方式，减少了项目的复杂度，并提供了自动化配置、快速开发、无代码生成等特性。Spring Boot在开发中需要启动Web或应用程序容器，本文将详细介绍Spring B…

    Java 2023年5月15日
    00

  • 非常全面的Java SpringBoot点赞功能实现

    Java SpringBoot点赞功能实现攻略 一、前置知识 在进行本文中介绍的Java SpringBoot点赞功能实现之前，我们需要掌握以下技能： 熟练掌握Java编程语言。 掌握Java SpringBoot框架的基本使用方法。 熟练使用MySQL数据库。 了解前端开发技术，如HTML、CSS、JavaScript等。 二、功能实现步骤 以下是在Jav…

    Java 2023年5月31日
    00

  • Java的DataInputStream和DataOutputStream数据输入输出流

    DataInputStream和DataOutputStream是Java中常用的数据输入输出流，它们提供了一种用于串行化和反串行化基本java数据类型的方法。在处理二进制数据时，这两个类可以很好的对数据进行读和写操作。下面就来详细讲解这两个输入输出流的使用。 DataInputStream DataInputStream是一种基于字节流的数据输入流。在使用…

    Java 2023年5月26日
    00

  • java开发之MD5加密算法的实现

    Java开发之MD5加密算法的实现 简介 MD5是一种常用的加密算法，Java中可以通过MessageDigest类实现MD5加密。本攻略将介绍如何在Java中使用MessageDigest类实现MD5加密。 实现过程 1. 获取MessageDigest对象 使用MessageDigest类的getInstance方法获取MessageDigest对象，并…

    Java 2023年5月19日
    00

  • Java与Spring boot后端项目Bug超全总结

    Java与Spring Boot后端项目Bug超全总结 为什么会有Bug Bug是不可避免的，尤其是在软件开发的过程中。它们可能由多种原因引起，例如人为疏忽、缺少测试、设计错误或未能理解业务需求。在Java和Spring Boot后端项目中，由于开发过程通常比较复杂，可能出现更多的Bug。以下是一些解决这些问题的技术和策略。 解决Bug的技巧和策略 1. 编…

    Java 2023年6月16日
    00

  • springboot多项目结构实现

    下面是关于如何实现Spring Boot多项目结构的完整攻略： 1. 什么是Spring Boot多项目结构？ 在实际开发中，有时候我们需要在一个应用中多个不同的模块，可以将不同的模块分离成不同的子项目，每个子项目可以独立部署，并且方便进行维护和扩展，这就是所谓的Spring Boot多项目结构。 2. 如何实现Spring Boot多项目结构？ 2.1 创…

    Java 2023年5月15日
    00
合作推广
合作推广
分享本页
返回顶部