互联网技术17——socket编程之BIO

最新推荐文章于 2024-02-26 10:00:00 发布
最新推荐文章于 2024-02-26 10:00:00 发布
阅读量233 收藏
点赞数
分类专栏： socket 互联网技术学习 文章标签： socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_28240551/article/details/82229120
版权

TCP直连接Socket与ServerSocket，先看代码

服务端：Server.java

package com.socketBio;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * Created by BaiTianShi on 2018/8/29.
 */
public class Server {
    final static int PORT = 8765;
    public static void main(String[] args) {
        ServerSocket server = null;

        while(true){
            try {
                //创建服务端
                server = new ServerSocket(PORT);
                System.out.println("server start");
                //服务端阻塞，监听客户端连接，一旦有客户端连接就能获取到这个客户端的socket
                Socket socket = server.accept();
                //每当有客户端请求的时候就创建一个线程，这个线程启动色事先设计好的ServerHandler的run方法
                new Thread( new ServerHandler(socket)).start();

            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(server != null){
                    try {
                        //关闭
                        server.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                server = null;
            }
        }

    }
}

 

服务端处理程序：ServerHdndler.java

package com.socketBio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * Created by BaiTianShi on 2018/8/29.
 */
public class ServerHandler implements Runnable {

    private Socket socket;

    public ServerHandler(Socket socket) {
        //构造方法中一定要传入客户端请求的socket才能读取其中的信息或向其写入
        this.socket = socket;
    }

    @Override
    public void run() {
        System.out.println("运行hanndler的run方法");
        //缓冲字符流
        BufferedReader reader = null;
        //打印输出流
        PrintWriter out = null;

        try {
            //使用输入流声明一个缓冲字节输入流再包装成一个缓冲字符输入流
            reader = new BufferedReader( new InputStreamReader( this.socket.getInputStream() ));
            //通过输出字符流声明一个打印输出流
            out = new PrintWriter(this.socket.getOutputStream(),true);
            String body = null;
            while(true){//轮询的关键点1
                body = reader.readLine();//轮询的关键点2
                if(body == null) break;
                System.out.println("Server :" + body);
                out.println("服务器端返回给客户端的响应数据.");
            }

           
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(reader != null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(out != null){
                try {
                    out.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            socket = null;

        }
    }
}

 

客户端：Client.java

package com.socketBio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * Created by BaiTianShi on 2018/8/29.
 */
public class Client {

    final static String ADDRESS = "127.0.0.1";
    final static int PORT = 8765;

    public static void main(String[] args) {
        Socket socket= null;
        BufferedReader in = null;
        PrintWriter out = null;

        try {
            socket = new Socket(ADDRESS,PORT);
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(),true);
            out.println("客户端client1向服务器发送请求测试数据");
            String response = in.readLine();
            System.out.println("Client:"+ response);


        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(in != null) try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            if(out != null)out.close();
            if(socket != null) try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            socket = null;
        }
    }
}

启动server：

启动client：

server端监测到client建立连接后：

 

但是，这样的的运行过程是每当有客户端请求的时候都会启动一个线程，会占用过多的资源。如果client与server建立的连接很多，可能耗尽机器资源。

 

补充知识：

网络编程的基本模型是client/server模型，即服务端 绑定某个端口进行监听，而客户端通过制定ip和端口号向服务端发送连接请求。通过三次握手建立连接若连接成功，则客户端就可与服务端进行通信。

三次握手：参见:  https://mp.youkuaiyun.com/postedit/82230273

 

在jdk105之前，采用伪异步的方式避免Server Scoket建立过多的线程处理客户端的请求，其内部维护着一个线程池，将客户端请求建立的socket封装成一个任务Task(实现Runnable)对象，把任务对象交给线程池管理，并配置响应的阻塞队列BlockingQueue用于缓冲任务对象。可以在线程中设置处理Client建立连接Scoket的线程池最大数量，这样就避免了无线创建子线程而造成系统资源耗尽。

Clien.java

package com.scoketExecutorBio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * Created by BaiTianShi on 2018/8/30.
 */
public class Client {

    private final static String ADDRESS="127.0.0.1";
    private final static int PORT= 8764;
    public static void main(String[] args) {
        BufferedReader in = null;
        PrintWriter  out = null;
        Socket socket = null;
        try {
            socket = new Socket(ADDRESS,PORT);

            in= new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(),true);
            out.println("客户端发送的请求");

            String body = in.readLine();
            System.out.println("客户端接收到的响应："+body);

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(in != null){
                try {
                    in.close();
                } catch (Exception e1) {
                    e1.printStackTrace();
                }
            }
            if(out != null){
                try {
                    out.close();
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (Exception e3) {
                    e3.printStackTrace();
                }
            }
            socket = null;
        }
    }
}

 

server.java

在srever使用自定义HandlerExeuctorPool，通过构造函数core和max设置核心线程数和最大线程数。服务端监听客户端请求连接的方式是通过ServerScoket.accept(）方法监听，一旦有连接，马上获取到次客户端套接字（Scoket），并将此Socket传入封装好的Task任务中，开启线程通过处理Scoket，可读客户端传过来的数据，亦可向客户端写数据。

package com.scoketExecutorBio;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * Created by BaiTianShi on 2018/8/30.
 */
public class Server {
     static final String ADDRESS = "127.0.0.1";
     static final int PORT = 8764;

    public static void main(String[] args) {
        Socket socket = null;
        ServerSocket server = null;

        System.out.println("服务端:"+ADDRESS+":"+PORT+"等待客户端连接中");
        HandlerExecutor executorService = new HandlerExecutor(Runtime.getRuntime().availableProcessors(),20);
        try {
            server = new ServerSocket(PORT);
            while (true){
                socket = server.accept();
                System.out.println("服务端接收到客户端连接");
                executorService.execute( new ServerHandler(socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(null != socket){
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            server = null;
        }


    }
}

 

HandlerExeuctorPool.java

package com.scoketExecutorBio;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created by BaiTianShi on 2018/8/30.
 */
public class HandlerExecutor{

    private ExecutorService executorService;
    public HandlerExecutor(int core, int max) {
        executorService = new ThreadPoolExecutor(core,max,120L, TimeUnit.SECONDS, new LinkedBlockingDeque());
    }


    public void execute(Runnable command) {
        executorService.execute(command);
    }
}

其中涉及的 new threadPoolExecutor()的方法使用详解见：https://mp.youkuaiyun.com/postedit/81917146

 

serverHandler.java

在server.java代码中，通过new ServerHandler(socket)将监听到的客户端socket传递给了ServerHandler，ServerHandler实现了Runnable接口，在run()方法中获取Client端传递给来的数据流,经过处理转换后输出。

启动server：

启动client：

启动clinet后，服务端的相应

 

 

 

 

 

 

 

【并发编程七】C++进程通信——套接字（socket)_80行代码实现一个聊天软件
junxuezheng的博客
12-17 1638
c++,80行代码实现一个聊天软件。刚写完《【操作系统二】图解TCP/IP模型+实战》、和《【操作系统三】图解网络IO（bio\nio\slect\epoll）》，和网络通信相关的基本都介绍清楚了，所以原本这篇socket通信不想再写了，但是考虑到【并发编程】系列不完整，所以才写了下了这篇。所以本篇文章所以本篇文章侧重Windows系统下socket的代码实战（写了一个简单的聊天软件），如果对什么是socket还没有清晰的印象，建议先读上面的两篇文章，然后再看本篇。
全方位技术攻关 | 带你建立Netty网络编程技术栈 ——【进阶篇】​传统NIO编程模型与实现细节探讨（3）[通信篇]
最新发布
世界上并没有完美的程序，但是我们并不因此而沮丧，因为写程序就是一个不断追求完美的过程。
03-26 44
在掌握了FileChannel与Buffer的核心机制后，让我们将视野转向更复杂的网络通信领域。作为NIO三大核心组件之一，SocketChannel通过其独特的非阻塞特性，彻底改变了传统IO模型的交互范式。传统BIO模型中，套接字的accept/read/write操作可能因等待资源而永久阻塞线程，导致线程利用率低下。例如，在一个非阻塞式ServerSocketChannel上调用accept()方法，如果有连接请求来了，则返回客户端SocketChannel，否则返回null。NIO通过配置，使这些关键
服务器socket线程池实现异步处理请求
is_Javaer的博客
02-10 713
之前我们写的服务器Socket示例demo，都是只能接收单次请求，一般服务器肯定是需要持续提供服务的，我们可以对demo进行一些改造。 服务器Socket持续同步接收请求 为了让服务器Socket能够持续接收请求，我们可以利用while循环。 例如： import java.io.IOException; import java.io.InputStream; import java.net.Se...
Socket编程（一）（BIO）
吃四碗饭的嘤嘤怪的博客
10-13 4606
1.套接字地址 一个客户端要发起一次通信，首先要知道运行服务器端程序的主机IP地址。然后由网络基础设施利用目标地址将客户端发送的信息传递到正确主机上。在Java中，地址可以由一个字符串定义，可以是数字型的地址（192.168.1.10（IPv4地址），fe20:12a0::0abc:1234（IPv6地址）），也可以是主机名（www.baidu.com）。在后面的例子中，主机名必须被解析出数字型...
Socket（BIO）实现的客户端与服务端之间通信
woaiwojialanxi的专栏
03-18 1658
Socket（BIO）实现的客户端与服务端之间通信
网络编程- Socket-BIO
qq_31142237的博客
05-30 295
网络编程- Scoket-BIO 上图时对socket做一个简单介绍, 具体的实现这里就说了。主要将一下java网络编程几大IO模型实现、原理、演变，IO模型分别为BIO、OS级别的NIO(NONBLOCKING IO)、NIO java jdk1.4升级的NEW IO。 BIO模型 前提知识：想要彻底的了解IO模型及其原理和演变，你需要了解一下操作系统底层相关的一些系统调用知识，我上篇文章介绍过了，参考学习，有错误的望指出。系统调用|内核程序 想必大家都知道IO操作肯定需要系统调用的，因为网络传输势必会
socket的BIO 演示 -- 补充linux知识
bintoYu的博客
06-09 521
本文学自视频：https://www.bilibili.com/video/BV11K4y1C7rm?p=1 开启服务端以及基础知识铺垫 第一步，写一个服务端ServerSocketTest： public class ServerSocketTest { private static final ExecutorService executorService = Executors.newCachedThreadPool(); public static void main(Stri.
tomcat 分配请求之——socket获取请求
07-13
标题“Tomcat分配请求之——Socket获取请求”主要涉及的是Tomcat服务器在处理HTTP请求时的核心机制。在Web服务器中，Tomcat是一个广泛使用的开源应用服务器，它负责解析并响应来自客户端（如浏览器）的HTTP请求。这...
Java网络编程（BIO和NIO）
zhangshuai66的博客
08-24 802
简单的简绍JAVA网络编程中的BIO和NIO
Netty学习——基础篇1（同步阻塞IO-BIO）
geminigoth的博客
02-26 1040
阻塞I/O模型：最常用的I/O模型就是阻塞I/O模型，缺省情况下，所有文件操作都是阻塞的。以套接字接口为例来讲解此模型：在进程空间中调用recvfrom，其系统调用直到数据包到达且被复制到应用进程的缓冲区或者发生错误时才返回，再次期间一直会等待，进程在从调用recvfrom开始到它返回的整段时间内都是被阻塞的，因此成为阻塞I/O模型模型。如下图所示：非阻塞I/O模型：r。
Java网络编程之BIO(Socket 伪异步)-yellowcong
10-07 473
上一篇Java网络编程之BIO(Socket)-yellowcong写到，客户端，每次发送一个请求，就会创建一个线程的方式来完成请求的处理，效率低下，可以通过添加线程池的方式来解决处理瓶颈问题 案例线程池定义个线程池，ThreadPoolExecutor ，使用的是ArrayBlockingQueue 固定长度队列，通过线程池来添加请求的队列，如果请求操过了poolSize，就会将数据放到队列中。
Socket通信之BIO(同步阻塞IO)、PAIO(伪异步阻塞IO)、NIO(异步非阻塞IO)、AIO(异步非阻塞IO)、netty5之IO
undergrowth的专栏
07-01 1793
参考源： http://ifeve.com/netty5-user-guide/ 书籍 netty权威指南    对于这本书 很多人褒贬不一  但是对于新手 我觉得还是比较好的 记录下学习的笔记 * 使用BIO方式(同步阻塞IO) * 使用ServerSocket绑定IP地址，启动端口，使用Socket进行握手连接，连接成功后，双方通过输入输出流进行同步阻塞式通信 * 每
Socket之bio和nio
u013239236的专栏
09-15 4822
在此之前先谈论一下网络io.当一个客户端和服务端之间相互通信,交互我们称之为网络io(网络通讯).网络通讯基本都是通过socket来通讯的。客户端和服务端这样建立连接:第一步客户端发起建立连接的请求，第二部服务端收到请求建立连接的请求,并同意和该客户端建立连接，并响应给客户端，第三步客户端收到服务端响应的建立连接的消息,并确认和服务端建立连接，通过这样三部客户端和服务端就真正的建立了连接，服务端和
BIO、NIO、AIO理解
qq_56919740的博客
04-05 8149
一些对BIO、NIO、AIO通信模型的总结
Socket 编程中的BIO和NIO
majie639的博客
05-26 993
Socket 编程 Internet中应用嘴广泛的网络应用编程接口实现与3种底层协议接口: 数据报类型套接字SCOK_DGRAM(面向UDP接口) 流式套接字SOCK_STREAM(面向TCP接口) 原始套接字SOCK_RAW(面向网络层协议接口IP、ICMP等) 主要socket API及其调用过程 ： 创建套接字 - -> 端点绑定 - -> 发送数据 - -> 接...
BIO基本介绍以及使用
weixin_42408447的博客
08-19 1288
BIO
BIO编程的主要原理
weixin_44007988的博客
02-06 721
同步和异步是针对应用程序和内核的交互而言的，同步指的是用户进程触发IO操作并等待或者轮询的去查看IO操作是否就绪，而异步是指用户进程触发IO操作以后便开始做自己的事情，而当IO操作已经完成的时候会得到IO完成的通知。 阻塞和非阻塞是针对于进程在访问数据的时候，根据IO操作的就绪状态来采取的不同方式，说白了是一种读取或者写入操作方法的实现方式，阻塞方式下读取或者写入函数将一直等待，而非阻塞方式下，读...
Socket实现网络聊天室和联系人私聊功能
热门推荐
jike_chengwei的博客
05-05 1万+
使用socket技术实现网络聊天室和私聊功能话不多说先上图： 聊天室群聊页面在线用户的联系人列表 socket连接页面 私聊页面 项目介绍 与服务端实现socket连接：每个客户端连接到服务器的时候，服务器会将每个连接的socket保存在list集合中。 群聊功能：当有一个用户发送群聊消息给服务器的时候，服务器会将所有信息转发给list列表中的所有已连接的客户端。 私聊功能：用户发送私聊信息给服务器
Java网络编程深度解析：BIO、NIO与AIO学习笔记
资源摘要信息:"《一站式学习Java网络编程——全面理解BIO、NIO、AIO》是一本专注于Java网络编程技术的书籍。本书的标题明确指出了其主要内容和学习目标，即通过一个全面的学习过程来理解Java中的三种I/O模型：阻塞IO...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值