（4）多线程服务器与连接池

最新推荐文章于 2023-10-09 14:09:26 发布
最新推荐文章于 2023-10-09 14:09:26 发布
阅读量375 收藏
点赞数
分类专栏： java网络编程 文章标签： java socket 博客 服务器 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30040421/article/details/75008525
版权
在我第一篇博客给出的例子中，EchoServer接收到一个客户端连接，就与客户进行通信，通信完毕后断开连接，然后再接收下一个客户端的连接。而如果有多个客户端请求连接，那么这些客户端就需要排队等候。
在实际应用中，一个服务器往往同时为多个客户端提供服务，还是以HTTP服务器为例，HTTP服务器可能同时收到大量客户的请求，每个客户都希望尽快得到响应，如果让客户等待时间过长，就是造成网站客户量流失，访问量下降等严重后果
 通常我们用并发性能，来衡量一个服务器同时响应多个客户的能力，一个优秀的服务器，应该满足一下两点：
（1）能同时处理大量请求
（2）对于每个客户，都能迅速给予响应。

用多个线程来为多个客户提供服务，是提高并发性能的通用手段。
这篇文章中我会通过几个实例由浅入深来说一说如何实现多线程的套接字通信：
例1：为每个客户分配一个线程
服务器主线程负责与接收客户端连接，每接到一个连接，就会创建一个工作线程，由工作线程负责与客户端通信，在EchoServer类中： 
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();
        }

    }
}

以上方法中，将接收到的每一个连接请求都交给一个新线程的Handle。Handle类实现了Runable接口，在重写的run()方法中进行与客户端交换数据。

在EchoClient的talk()方法中： 
public void talk() throws IOException {
    for (int i = 0; i < 100; i++) {
        try {
            socket = new Socket(host, port);
            BufferedReader br = getReader(socket);
            PrintWriter pw = getWriter(socket);
            String msg = "你好，我是第" + i + "个客户端";
            pw.println(i);
            System.out.println(br.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

我们通过for循环，向服务器发送100此连接请求，并每次都向服务器发送不同的数据。
以下为完整代码：
EchoService: 
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class EchoServer {

    private int port = 8001;
    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();  //创建Socket对象，接收客户端的连接
                Thread workThread = new Thread(new Handler(socket)); //将接收到的每一个连接请求都交给一个新线程的Handle
                workThread.start();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    public static void main(String[] args) throws IOException {
        new EchoServer().service();
    }

}
class Handler implements Runnable {   //处理Socket连接的handle类
    private Socket socket = null;
    public Handler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            System.out.print("新的连接已建立,");
            System.out.print("客户端IP" + socket.getInetAddress()); //打印客户端地址
            System.out.print(",客户端端口号" + socket.getPort());  //打印客户端端口号
            BufferedReader br = getReader(socket);
            PrintWriter pw = getWriter(socket);

            String msg = null;
            while ((msg = br.readLine()) != null) {
                System.out.println(msg);  //打印客户端发来的数据
                pw.println(echo(msg));  //给客户端返回数据
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public String echo(String msg) {
        return "服务器传回的数据:" + msg;
    }

    private PrintWriter getWriter(Socket socket) throws IOException {
        OutputStream out = socket.getOutputStream();
        return new PrintWriter(out, true);
    }

    private BufferedReader getReader(Socket socket) throws IOException {
        InputStream in = socket.getInputStream();
        return new BufferedReader(new InputStreamReader(in));
    }
}
EchoClient: 
import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class EchoClient extends Thread{

    private String host = "localhost";
    private int port = 8001;
    private Socket socket = null;

    private PrintWriter getWriter(Socket socket) throws IOException {
        OutputStream out = socket.getOutputStream();
        return new PrintWriter(out, true);
    }

    private BufferedReader getReader(Socket socket) throws IOException {
        InputStream in = socket.getInputStream();
        return new BufferedReader(new InputStreamReader(in));
    }

    public void talk() throws IOException {
        for (int i = 0; i < 100; i++) {  //发起100次连接请求
            try {
                socket = new Socket(host, port);   //创建Socket对象，向服务器发起连接请求
                BufferedReader br = getReader(socket);
                PrintWriter pw = getWriter(socket);
                String msg = "你好，我是第" + i + "个客户端";
                pw.println(msg);      //向服务器发送数据
                System.out.println(br.readLine());   //打印服务器传回的数据
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws IOException {
        new EchoClient().talk();
    }
}


先执行服务器的主方法，再执行客户端的主方法，出现以下运行结果：
      

在上述例子中，虽然解决了单服务器与多客户端连接的问题，但是有以下几点不足：
（1）创建和销毁线程的开销十分大，上述例子中，我们的通信时间很短，导致为了通信而造成的开销比通信本身花费的开销还大，得不偿失。
（2）除了创建和销毁占用资源，活动的线程也消耗资源，每个线程占用约1MB，上述我们才100个请求，而实际当并发量很高的时候，这是一个非常大的开销。
（3）正常情况下，切换线程(在操作系统底层调度下，线程之间转让CPU使用权)的切换周期大概为20ms，而频繁的创建和销毁会导致线程之间的切换不遵循固定的切换周期，线程切换的开销甚至比创建和销毁线程的开销还大。

为了解决这些问题，就需要引入线程池的概念，线程池有以下几点好处：
（1）减少了创建和销毁的次数，每一个线程都可以被重用，执行多个任务。
（2）可以根据系统的承载能力，方便的调整线程的数目，防止系统过载。

例2：通过线程池实现套接字
java.util.concurr包中提供了线程池的实现，篇幅原因这里不详细说jdk的线程池如何实现，只是通过具体的例子演示如何用线程池实现C/S通信，服务器的代码实现和上面的例子差不多，只是改变了多线程处理socket对象的方法： 
private ExecutorService executorService;
private final int POOL_SIZE = 4;
public EchoServer() throws IOException {
    
    //创建线程池，这里线程个数的思想是CPU越多，开的线程越多，
          Runtime.getRuntime().availableProcessors()返回的是当前操作系统的CPU数目
    executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);
}

以上代码创建线程池，并规定开的线程的个数。 
public void service() {
    while (true) {
        Socket socket = null;
        try {
            socket = serverSocket.accept();  //创建Socket对象，接收客户端的连接
            executorService.execute(new Handler(socket)); //将接收到的每一个连接请求都交给线程池处理
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

在service(）方法中使用线程池， 调用excute( Runable task)方法执行Runable型任务。
以下为用线程池实现的服务器的代码：
EchoServer: 
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RunnableFuture;

public class EchoServer {

    private int port = 8001;
    private ServerSocket serverSocket;
    private ExecutorService executorService;
    private final int POOL_SIZE = 4;

    public EchoServer() throws IOException {
        serverSocket = new ServerSocket(port);
        System.out.println("服务器启动");
        //创建线程池，这里线程个数的思想是CPU越多，开的线程越多，Runtime.getRuntime().availableProcessors()返回的是当前操作系统的CPU数目
        executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);
    }


    public void service() {
        while (true) {
            Socket socket = null;
            try {
                socket = serverSocket.accept();  //创建Socket对象，接收客户端的连接
                executorService.execute(new Handler(socket)); //将接收到的每一个连接请求都交给线程池处理
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    public static void main(String[] args) throws IOException {
        new EchoServer().service();
    }

}

class Handler implements Runnable {   //处理Socket连接的handle类
    private Socket socket = null;

    public Handler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            System.out.print("新的连接已建立,");
            System.out.print("客户端IP" + socket.getInetAddress()); //打印客户端地址
            System.out.print(",客户端端口号" + socket.getPort());  //打印客户端端口号
            BufferedReader br = getReader(socket);
            PrintWriter pw = getWriter(socket);

            String msg = null;
            while ((msg = br.readLine()) != null) {
                System.out.println(msg);  //打印客户端发来的数据
                pw.println(echo(msg));  //给客户端返回数据
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public String echo(String msg) {
        return "服务器传回的数据:" + msg;
    }

    private PrintWriter getWriter(Socket socket) throws IOException {
        OutputStream out = socket.getOutputStream();
        return new PrintWriter(out, true);
    }

    private BufferedReader getReader(Socket socket) throws IOException {
        InputStream in = socket.getInputStream();
        return new BufferedReader(new InputStreamReader(in));
    }
}
使用这个客户端的运行结果和例1相同，但是却大大的节省了系统资源。
qq_30040421
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
支持多线程的SFTP类代码
11-18
适用多线程的SFTP类，支持代理服务器，是spring服务类，无需修改可直接与spring结合使用。 代码经过大量的并发使用验证，稳定可靠。 依赖的jar包如下： <groupId>com.jcraft</groupId> <artifactId>...
什么是连接池？为什么需要连接池呢？连接池的组成原理又是什么呢？
热门推荐
四季轮换叶，一路招摇胜
12-07 1万+
目录 1.为什么需要连接池呢？ 2.什么是连接池 3. 连接池的工作原理 3.1详解连接池的工作原理 3.1.1连接池的创建： 3.1.2连接池的管理 3.1.3连接池的关闭 3.1.4相关词组详解 4.连接池的规范 4.1JavaEE规范规定： 4.2常见的第三方连接池 5.如何使用Druid 5.1 导入jar包 5.2 入门案例 1.为什么需要连接池呢？ Java程序操作数据库，必须获得一个连接Connection 实际操作中，我们要先获得..
Java中数据库连接池原理机制的详细讲解
weixin_43860634的博客
06-27 859
Java中数据库连接池原理机制的详细讲解
使用多线程实现多客户端连接服务端——多线程概念、创建
lxt185794853的博客
06-02 703
纳秒级别，我们感觉不到切换线程运行的过程。所以微观上走走停停，宏观上感觉一起运行的现象成为并发运行!定义一个线程类，重写run方法，在其中定义线程要执行的任务(希望和其他线程并发执行的任务)。程序会再次分配一个时间片段给一个线程使得CPU执行它。由于CPU执行时间在。多个线程实际运行是走走停停的。线程调度程序会将CPU运行时间划分为若干个时间片段并。尽可能均匀的分配给每个线程，拿到时间片的线程被CPU执行这段时间。在于结构简单，便于匿名内部类形式创建。该方法可以获取运行这个方法的线程。
8年测试老鸟，性能测试-数据库连接池问题定位/分析，一篇打通...
大佬云集技术答疑交流群：743262921(进群暗号:222)
10-09 301
1、环境准备1）编写脚本2）执行压测3）打印快照2、问题定位1）在快照中，搜索是否存在BLOCKED 或者 TIMED_WAITING字段2）查看TIMED_WAITING日志中是否存在，跟自身业务相关的日志信息3）检查是否存在getconnection的关键字，便是数据库连接等待3、问题分析1）查看压测中的应用，数据库链接数执行压测，应用服务器输入命令：安装netstat：gerp 10.196.130.102：3306 为过滤数据库服务器；grep 39671 为过滤应用程序；
多线程连接池
qq_41665476的博客
07-02 1150
package com.mom.pi.common; import org.apache.log4j.Logger; import java.util.HashMap; import java.util.concurrent.*; public class ThreadPool { private static ThreadPool threadPool; // ...
SpringBoot2.2+commons-pool2实现多Ftp连接池完整项目，开箱即用，经过长期生产使用稳定可靠
04-04
使用JDK1.8、SpringBoot2.2.10.RELEASE、lombok1.18.8、guava23.0、hutool5.3.10、commons-pool2 2.7.0、tika1.22等实现多Ftp连接池实现，通过守护线程实现连接池内连接可用性校验，配置最大、最小连接个数防止Ftp...
Alex-Word-Filter-MFC网络版java客户端（多线程连接池版）
02-12
此版为MFC的客户端版本，此版将主要运算放在了MFC的服务器上，java client只发送socket请求和接收计算结果，此版能够承受的负载极高，200个并发，PC机服务器端基本只占用15%的cpu。java服务器版请下载alex-word-...
基于C++实现多线程连接池MySQL源码+项目说明+详细代码注释.zip
最新发布
10-26
基于C++实现多线程连接池MySQL源码+项目说明+详细代码注释.zip C++ 调用 MYSQL API 连接池 ## environment： * VS2022 * MySQL8.0.27 ## 高并发下频繁处理瓶颈 * 建立通信：`TCP三次握手` * 数据库服务器的`连接认证...
php异步多线程swoole用法实例
12-18
一般来说，Swoole提供了PHP语言的异步多线程服务器，异步TCP/UDP网络客户端，异步MySQL，数据库连接池，AsyncTask，消息队列，毫秒定时器，异步文件读写，异步DNS查询. swoole以前听过, 拿来做游戏服务器简直是神器...
Linux + C + Epoll实现高并发服务器(线程池 + 数据库连接池)
09-27
在Linux 系统下面用C 语言实现的高并发服务器的代码，具体用到了Epoll，线程池，数据库连接池。 具体可以看下连接http://blog.csdn.net/wuyuxing24/article/details/48758927
多线程服务器端程序（支持多台客户端建立连接并向所有客户端转发收到的消息）
11-11
用java编写，运用socket套接字编程，支持多台客户端建立连接并向所有客户端转发收到的消息
支持多线程的数据库连接池(Linux C/C++ mysql)
Think88666的博客
08-03 1535
前言： 网上关于Linux C/C++的连接池相关项目很少，即便是有也难以满足我的需求，比如： 1、无法支持阻塞形式（线程休眠等待空闲连接）获取空闲连接， 2、网上流传的基于mysql++开发的连接池，还需要引入boost等三方库，稍显繁琐，不利于中小型项目的开发。 基于以上原因，本人自己写了这个连接池，有问题下方留言，大家共同进步！ 本连接池的特点： 1、支持多线程； 2、从连接池获取空闲连接时支持阻塞（直到获取到空闲连接）和非阻塞（没有空闲连接直接返回）两种形式； 3、托管了mysq
java 多线程 连接池_Java四种线程池的学习与总结
weixin_39804523的博客
02-21 587
在Java开发中，有时遇到多线程的开发时，直接使用Thread操作，对程序的性能和维护上都是一个问题，使用Java提供的线程池来操作可以很好的解决问题。一、new Thread的弊端执行一个异步任务你还只是如下new Thread吗？new Thread(new Runnable(){@Overridepublic void run(){//TODO Auto-generatedmethod st...
连接池
前端精髓
07-05 1079
什么是连接？ 连接可以定义为客户机与服务器通信的一种方式。它需要发送命令并接收结果。 例如，浏览器使用TCP连接与您喜爱的网站进行对话。类似地，数据库连接允许您以结果集的形式发出命令并接收结果。 连接池可以应用于任何连接，如TCP连接、数据库连接甚至Redis连接。但在本文中，我将主要以数据库连接为例。 正常连接有什么问题？ 假设我们有一个Postgres数据库，您想对它运行这个查询。 select chairs from dining_table; 为了得到结果，我们需要提供数据库详细信息和身份验
多线程情况下创建连接池
爱雨轩
05-05 4953
JAVA数据库连接池实现 博客分类： • 数据库连接池 JAVA数据库连接池连接池原理连接池实现JAVA连接池 连接池的管理用了了享元模式，这里对连接池进行简单设计。 一、设计思路 1.连接池配置属性DBbean：里面存放可以配置的一些属性 2.连接池接口IConnectionPool：里面定义一些基本的获取连接的一些方法 3.接口实现Conne
Java多线程之线程池（合理分配资源）
快乐学习
09-15 1676
一、故事讲解 1.故事 有一家月饼店开业了，店里面有3个核心员工，这些人负责月饼的制作，3人同时工作制作100个月饼，每个人做完自己的月饼就会忙着下一个月饼的制作。因为总不可能要100个员工来做这些月饼吧，那也太浪费了。这些月饼的制作顺序是按照先后排队等待被制作的。 中秋佳节来临了，这些月饼的单子一下子赶了起来。忙不过来那就只能请一些临时员工来帮忙，但是核心员工忙得过来就用不上临时员工了。同时根据这些核心员工和临时员工的工作能力来判断接单情况，超过工作情况就不接单了，等先忙完这些再说。忙完这些月饼的制做
多进程/多线程实现服务器的并发
oorik的博客
09-24 1825
上一节提到的 TCP Socket 调用流程是最简单、最基本的，它基本只能一对一通信，因为使用的是同步阻塞的方式，当服务端在还没处理完一个客户端的网络 I/O 时，或者 读写操作发生阻塞时，其他客户端是无法与服务端连接的。本节我们讲讲最简单的两种方式，使用多线程和多进程实现服务器的并发。
多线程并发服务器
l_ethan的博客
07-25 249
一般情况下，main函数所在的线程我们称之为主线程(main线程)，其余创建的线程称之为子线程程序中默认只有一个进程，fork()函数调用，2进程程序中默认只有一个线程，phtread_create()函数调用，2个线程。线程在第三方库中所以需要-phtread或者-lpthread来编译连接。......
qt 多线程 数据库链接池
08-09
在使用Qt多线程进行数据库操作时，可以通过创建线程池来实现对数据库链接池的管理。首先，在主线程中创建一个数据库链接池对象，在该对象中创建一定数量的数据库连接，并将这些连接存放在一个容器中（比如使用队列）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值