TCP/IP学习笔记一：BIO的网络编程-简单实例

motui motui 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 2.3k累计阅读 2.3k平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄10年
关注
原创 最新推荐文章于 2026-02-13 14:53:28 发布 2.3k 阅读 AI 写同款· GEO 优化 ›
squirrel校园二手交易平台 squirrel校园二手交易平台 （适合寻找SSM项目练手的你。） 项目起源： 　　期末的课程设计，三人一组，我和两个舍友，一时起兴，决定做一个校园二手交易平台，一开始兴致与激情满满，可是后期时间上的冲突，让我们三个人对于这个项目有点累。 　　这个项目刚定题两天，BezosLee由于通过了360的网上在线笔试，收到了360公司的免费培训邀请，要去北京的360总部进行培训一周，值得庆... 阅读详情

TCP/IP学习笔记一：BIO的网络编程-简单实例

标签（空格分隔）： BIO 网络编程

一、简单的BIO网络编程

实例：实现简单的web服务器（简单模仿Tomcat的请求和响应）

服务器端的实现：

    package com.bio.socket;

    import java.io.BufferedReader;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.PrintWriter;
    import java.net.InetSocketAddress;
    import java.net.ServerSocket;
    import java.net.Socket;

    /**
     * 服务器端
     * @author MOTUI
     *
     */
    public class BIOServerSocket {

        public static void main(String[] args) throws Exception {

            //1.创建serverSocket
            ServerSocket serverSocket = new ServerSocket();

            //2.设置端口号
            serverSocket.bind(new InetSocketAddress(8989));

            System.out.println("监听端口为8989的服务器");

            //3.获取报文
            Socket socket = serverSocket.accept();

            //a.获得客户端的意图   request
            InputStream is = socket.getInputStream();
            //字符流和字节流的转换
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(isr);

            //存储读取的数据
            StringBuilder sb = new StringBuilder();
            String line = null;
            //读取数据
            while((line = br.readLine()) != null){
                //将数据存储在StringBuilder中
                sb.append(line);
            }
            System.out.println("服务器收到的数据："+sb.toString());
            //b.返回客户端数据
            OutputStream os = socket.getOutputStream();
            //获得输出流
            PrintWriter pw = new PrintWriter(os);
            pw.write("接收的数据："+sb.toString()+"  服务器已经接收到数据");
            //将数据发送
            pw.flush();
            //关闭流
            br.close();
            pw.close();
            socket.close();
        }
    }

客户端的实现：

    package com.bio.socket;

    import java.io.BufferedReader;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.PrintWriter;
    import java.net.InetSocketAddress;
    import java.net.Socket;

    /**
     * 客户端
     * @author MOTUI
     *
     */
    public class BIOClientSocket {

        public static void main(String[] args) throws Exception {

            //1.创建Socket
            Socket socket = new Socket();

            //2.连接服务器
            socket.connect(new InetSocketAddress("192.168.0.117",8989));

            //a.发送数据到服务器
            OutputStream os = socket.getOutputStream();
            //获得输出流
            PrintWriter pw = new PrintWriter(os);
            pw.write("这是客户端数据");
            //将数据发送
            pw.flush();
            //告知服务器已经到了流的结尾
            socket.shutdownOutput();

            //b.获得服务器的回应
            InputStream is = socket.getInputStream();
            //字符流和字节流的转换
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(isr);

            //存储读取的数据
            StringBuilder sb = new StringBuilder();
            String line = null;
            //读取数据
            while((line = br.readLine()) != null){
                //将数据存储在StringBuilder中
                sb.append(line);
            }
            //打印服务器回应数据
            System.out.println(sb.toString());

            //关闭流
            br.close();
            pw.close();
            socket.close();
        }
    }

运行服务器端：

    监听端口为8989的服务器

运行客户端：

    接收的数据：这是客户端数据  服务器已经接收到数据

运行客户端之后服务器端结果为：

    监听端口为8989的服务器
    服务器收到的数据：这是客户端数据
    到此服务器端和客户端运行结束。这样的结果并和我们想要的结果不同，我们需要的是服务器端一直监听客户端发送的请求并作出响应。我们【服务器端】做如下的修改，客户端代码不做任何修改。

服务器端修改为：

在执行的代码中加上while(true)【第180行】,保证执行代码一直执行。

package com.bio.socket;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 服务器端
 * @author MOTUI
 *
 */
public class BIOServerSocket {

    public static void main(String[] args) throws Exception {

        //1.创建serverSocket
        ServerSocket serverSocket = new ServerSocket();

        //2.设置端口号
        serverSocket.bind(new InetSocketAddress(8989));

        while(true){
            System.out.println("监听端口为8989的服务器");

            //3.获取报文
            Socket socket = serverSocket.accept();

            //a.获得客户端的意图   request
            InputStream is = socket.getInputStream();
            //字符流和字节流的转换
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(isr);

            //存储读取的数据
            StringBuilder sb = new StringBuilder();
            String line = null;
            //读取数据
            while((line = br.readLine()) != null){
                //将数据存储在StringBuilder中
                sb.append(line);
            }
            System.out.println("服务器收到的数据："+sb.toString());
            //b.返回客户端数据
            OutputStream os = socket.getOutputStream();
            //获得输出流
            PrintWriter pw = new PrintWriter(os);
            pw.write("接收的数据："+sb.toString()+"  服务器已经接收到数据");
            //将数据发送
            pw.flush();
            //关闭流
            br.close();
            pw.close();
            socket.close();
        }
    }
}

运行服务器端：

    监听端口为8989的服务器

运行客户端：

    接收的数据：这是客户端数据  服务器已经接收到数据

运行客户端之后服务器端结果为：

   监听端口为8989的服务器
   服务器收到的数据：这是客户端数据
   监听端口为8989的服务器
    到此服务器端和客户端已经执行结束。也达到了一直监听客户端的请求的目的，但是还是有问题：我们处理客户端的请求的时候会存在一个请求没有处理完成，另一个请求不能处理。（在处理的过程中最耗时的操作就是I/O操作）。为了解决这个问题，我们进行如下修改。

服务器端代码修改为：

package com.bio.socket;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 服务器端
 * @author MOTUI
 *
 */
public class BIOServerSocket {

    public static void main(String[] args) throws Exception {

        //1.创建serverSocket
        ServerSocket serverSocket = new ServerSocket();

        //2.设置端口号
        serverSocket.bind(new InetSocketAddress(8989));

        while(true){
            System.out.println("监听端口为8989的服务器");

            //3.获取报文
            final Socket socket = serverSocket.accept();

            //启动线程
            new Thread(){
                public void run() {
                    try {
                        //a.获得客户端的意图   request
                        InputStream is = socket.getInputStream();
                        //字符流和字节流的转换
                        InputStreamReader isr = new InputStreamReader(is);
                        BufferedReader br = new BufferedReader(isr);

                        //存储读取的数据
                        StringBuilder sb = new StringBuilder();
                        String line = null;
                        //读取数据
                        while((line = br.readLine()) != null){
                            //将数据存储在StringBuilder中
                            sb.append(line);
                        }
                        System.out.println("服务器收到的数据："+sb.toString());
                        //b.返回客户端数据
                        OutputStream os = socket.getOutputStream();
                        //获得输出流
                        PrintWriter pw = new PrintWriter(os);
                        pw.write("接收的数据："+sb.toString()+"  服务器已经接收到数据");
                        //将数据发送
                        pw.flush();
                        //关闭流
                        br.close();
                        pw.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }finally{
                        try {
                            socket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }

                };
            }.start();
        }
    }
}

客户端代码修改为：

package com.bio.socket;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.net.Socket;

/**
 * 客户端
 * @author MOTUI
 *
 */
public class BIOClientSocket {

    public static void main(String[] args) throws Exception {

        //使用线程模拟用户 并发访问
        for (int i = 0; i < 20; i++) {
            new Thread(){
                public void run() {
                    try {
                        //1.创建Socket
                        Socket socket = new Socket();

                        //2.连接服务器
                        socket.connect(new InetSocketAddress("192.168.0.117",8989));

                        //a.发送数据到服务器
                        OutputStream os = socket.getOutputStream();
                        //获得输出流
                        PrintWriter pw = new PrintWriter(os);
                        pw.write("这是客户端数据");
                        //将数据发送
                        pw.flush();
                        //告知服务器已经到了流的结尾
                        socket.shutdownOutput();

                        //b.获得服务器的回应
                        InputStream is = socket.getInputStream();
                        //字符流和字节流的转换
                        InputStreamReader isr = new InputStreamReader(is);
                        BufferedReader br = new BufferedReader(isr);

                        //存储读取的数据
                        StringBuilder sb = new StringBuilder();
                        String line = null;
                        //读取数据
                        while((line = br.readLine()) != null){
                            //将数据存储在StringBuilder中
                            sb.append(line);
                        }
                        //打印服务器回应数据
                        System.out.println(sb.toString());

                        //关闭流
                        br.close();
                        pw.close();
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                };
            }.start();
        }   
    }
}

运行服务器端：

    监听端口为8989的服务器

运行客户端：

    接收的数据：这是客户端数据  服务器已经接收到数据
    ....(省略19个：监听端口为8989的服务器)

运行客户端之后服务器端结果为：

    监听端口为8989的服务器
    ....(省略17个：监听端口为8989的服务器)
    监听端口为8989的服务器
    当前线程ID：9
    监听端口为8989的服务器
    当前线程ID：10
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    当前线程ID：11
    当前线程ID：12
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    当前线程ID：13
    服务器收到的数据：这是客户端数据
    当前线程ID：14
    服务器收到的数据：这是客户端数据
    当前线程ID：15
    当前线程ID：17
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    当前线程ID：18
    当前线程ID：21
    当前线程ID：20
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    当前线程ID：23
    当前线程ID：22
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    当前线程ID：24
    当前线程ID：25
    当前线程ID：26
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    当前线程ID：28
    当前线程ID：27
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    当前线程ID：16
    当前线程ID：19
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    到此运行结束，运行结果在不同的机器上有不同的顺序这与机器的运行效率有关。分析到这里我们感觉这种方式已经很合理了。在了解高并发之前，这的确看着不错。但是我们可以思考一个问题：如果我们的并发打到万级或者百万级或者更高的时候，我们的程序有没有问题呢？我们每有一个请求就创建一个线程，而且我们创建线程之后并没有关注这个线程是否正确执行？是否执行结束？我们都没有关注，这时候就出现问题了，当高并发情况下有很多的线程处于阻塞状态，而我们的系统资源已经占用，系统对I/O的处理就会慢，对I/O的处理变慢就会导致我们的线程阻塞，恶性循环直到系统假死（宕机）。这样的处理是不是不合理呢。我们现在虽然无法做到线程不阻塞（不阻塞就是NIO的方式），但是我们可以进行其他的做法，我们可以控制线程的创建个数，这样就会相对打到一个平衡。
    对于我们如何控制线程创建的个数呢？我们可能会想到用计数器，javaAPI中提供了线程池的方式，使用更简单。代码：

服务器端修改为：

package com.bio.socket;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 服务器端
 * @author MOTUI
 *
 */
public class BIOServerSocket {

    public static void main(String[] args) throws Exception {

        //1.创建serverSocket
        ServerSocket serverSocket = new ServerSocket();

        //2.设置端口号
        serverSocket.bind(new InetSocketAddress(8989));

        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        while(true){
            System.out.println("监听端口为8989的服务器");

            //3.获取报文
            final Socket socket = serverSocket.accept();

            executorService.submit(new Runnable() {

                @Override
                public void run() {
                    try {
                        //打印当前线程ID
                        System.out.println("当前线程ID："+Thread.currentThread().getId());

                        //a.获得客户端的意图   request
                        InputStream is = socket.getInputStream();
                        //字符流和字节流的转换
                        InputStreamReader isr = new InputStreamReader(is);
                        BufferedReader br = new BufferedReader(isr);

                        //存储读取的数据
                        StringBuilder sb = new StringBuilder();
                        String line = null;
                        //读取数据
                        while((line = br.readLine()) != null){
                            //将数据存储在StringBuilder中
                            sb.append(line);
                        }
                        System.out.println("服务器收到的数据："+sb.toString());
                        //b.返回客户端数据
                        OutputStream os = socket.getOutputStream();
                        //获得输出流
                        PrintWriter pw = new PrintWriter(os);
                        pw.write("接收的数据："+sb.toString()+"  服务器已经接收到数据");
                        //将数据发送
                        pw.flush();
                        //关闭流
                        br.close();
                        pw.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }finally{
                        try {
                            socket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }       
                }
            });
        }
    }
}

运行服务器端：

    监听端口为8989的服务器

运行客户端：

    接收的数据：这是客户端数据  服务器已经接收到数据
    ....(省略19个：监听端口为8989的服务器)

运行客户端之后服务器端结果为：

    监听端口为8989的服务器
    监听端口为8989的服务器
    监听端口为8989的服务器
    监听端口为8989的服务器
    当前线程ID：9
    监听端口为8989的服务器
    当前线程ID：10
    监听端口为8989的服务器
    监听端口为8989的服务器
    当前线程ID：12
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    当前线程ID：13
    服务器收到的数据：这是客户端数据
    监听端口为8989的服务器
    当前线程ID：11
    监听端口为8989的服务器
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    当前线程ID：14
    监听端口为8989的服务器
    监听端口为8989的服务器
    服务器收到的数据：这是客户端数据
    监听端口为8989的服务器
    监听端口为8989的服务器
    监听端口为8989的服务器
    监听端口为8989的服务器
    监听端口为8989的服务器
    监听端口为8989的服务器
    监听端口为8989的服务器
    监听端口为8989的服务器
    监听端口为8989的服务器
    监听端口为8989的服务器
    当前线程ID：14
    服务器收到的数据：这是客户端数据
    当前线程ID：9
    当前线程ID：13
    当前线程ID：14
    服务器收到的数据：这是客户端数据
    当前线程ID：10
    当前线程ID：12
    服务器收到的数据：这是客户端数据
    当前线程ID：9
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    当前线程ID：12
    当前线程ID：10
    服务器收到的数据：这是客户端数据
    当前线程ID：9
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    当前线程ID：15
    当前线程ID：17
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    当前线程ID：18
    当前线程ID：16
    服务器收到的数据：这是客户端数据
    服务器收到的数据：这是客户端数据
    到此我们的程序就算相对完善的。在服务器端我们设置了线程的最大数为10，所以我们的程序最大并发量为10，这样我们的程序就不需要一直新建线程浪费资源，只需要等待别人用完还回线程池，然后拿到继续使用即可。但是我们的程序依然是线程阻塞的。

总结：

    对于BIO的网络编程，我们实现的是传输层的TCP/IP协议，这样的传输效率更高。对于webService的SOP协议是Http+XML，过度的封装使得效率上不适合对速度要求较高的应用。
    多线程(线程池)实现BIO并非访问,将IO的处理交给线程池里的线程,限定系统线程无止境的创建节省系统资源实现线程复用.
    缺点: 线程会因为IO没有就绪挂起.

问题分析：

    上述程序属于伪异步I/O，存在什么样的弊端？

/**
* Reads some number of bytes from the input stream and stores them into
* the buffer array b. The number of bytes actually read is
* returned as an integer. **This method blocks until input data is
* available, end of file is detected, or an exception is thrown.**
*
*

If the length of b is zero, then no bytes are read and
* 0 is returned; otherwise, there is an attempt to read at
* least one byte. If no byte is available because the stream is at the
* end of the file, the value -1 is returned; otherwise, at
* least one byte is read and stored into b.
* ……..
*/
public int read(byte b[]) throws IOException {
return read(b, 0, b.length);
}

上文中的粗体字对Socket的读操作的说明，当Socket的输入流进行读操作的时候，它会一致阻塞下去，知道发生三件事：

  1. 有数据可读
  2. 可用数据已经读完
  3. 发生空指针或者I/O异常

这样就意味着当发送方请求说这响应消息较慢，或者网络传输较慢，读取输入流的一方的通信线程将会阻塞很长时间，如果对方60s发送完数据，读入一方的通信线程将阻塞60s,在此期间其他接入消息将在消息队列中排队.

收录于
TCP-IP

当前文章被收录于：

TCP-IP
10 篇文章 1 人学习
订阅专栏 查看详情
标签
#网络编程 #实例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
Mamba与iTransformer融合：时间序列预测中的曼巴注意力机制创新实践 本文探讨了Mamba与iTransformer融合在时间序列预测中的创新实践，重点介绍了曼巴注意力机制的设计与优势。通过双路径信息流设计，该方案在保持O(n)复杂度的同时，显著提升了预测精度和训练效率。实验证明，混合架构在电力负荷、气象数据等多变量长序列场景中表现优异，预测误差降低至0.083，内存占用仅4.2GB。 阅读详情

相关推荐

极化码理论及算法研究6-SCL、CA-SCL及matlab仿真

极化码译码算法5——SCL/CA-SCL译码算法系列目录1、引言2、串行抵消列表（SCL）译码算法2.1、路径度量PM 系列目录 （如要找其他内容，欢迎访问我的主页寻找） #前言 #极化码概述 #极化码定义 #极化码编码 #极化码译码 #5G标准中极化码的编译码概述 #5G标准中极化码的编码 #5G标准中极化码的译码 #总结 1、引言 在上一节中，介绍了经典的SC译码算法的理论原理以及其matlab仿真代码，SC译码算法具有较低的译码复杂度，但是由于每个译码的比特信息都依赖于前面所有的比特信息的译码结果，得

1万+

TCP/IP运用实例

（2）客户端可以输入一个音乐文件名，比如《珊瑚海》，服务端收到音乐名后，可以给客户端返回这个。对节点流进行包装，使用数组缓冲的方式，对文件的处理效率更高。.发送数据结束时无需释放资源(因为不是面向连接的)，速度快。.使用TCP协议前，预先建立TCP连接，形成传输数据通道。.将数据、源、目的封装成数据包，不需要建立连接。.传输完毕，需要释放自己建立的连接，效率低。，如果服务器没有这个文件，返回一个默认的。.传输前，采用"三次握手"方式，是可靠的。.在连接中可进行最大数据量的传输。.因无需连接，故是不可靠的。

sinat_27397195的博客 1062

Toeplitz矩阵以及矩阵乘法FFT加速

Toeplitz矩阵以及矩阵乘法FFT加速 1.Toeplitz矩阵 托普利兹矩阵，简称为T型矩阵，它是由Bryc、Dembo、Jiang于2006年提出的。托普利兹矩阵的主对角线上的元素相等，平行于主对角线的线上的元素也相等；矩阵中的各元素关于次对角线对称，即T型矩阵为次对称矩阵。这里我们使用matlab中自带的函数生成一个toeplitz矩阵的例子： x=[1 2 3 4]; y=[1 5 6 7 8 9]; z=toeplitz(x,y); 我们可以得到一个这样的矩阵结果： 我们可以看到，其中x中

thlz 5069

TCP/IP协议类比生活案例

TCP/IP 生活例子比喻

嗯！记录自己学习过程。 1978

livebos报表开发

文章目录1.参数的设定2.展示的内容3.综合展示的效果4.调用过程5.可以在数据库里面查看6.注意事项7.过程代码 1.参数的设定 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-flb5C49A-1619516341977)(/uploads/xinxibuneibuzhishiku/images/m_bc71bb4608053778dbf29e06cd102ae1_r.png)] 2.展示的内容 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-

阿浪的专栏 709

isaaclab无法识别NVIDIA显卡，如何解决？

🏆本文收录于 《全栈Bug调优(实战版)》 专栏，该专栏专注于分享我在真实项目开发中遇到的各类疑难Bug及其深层成因，并系统提供高效、可复现的解决思路和实操方案。无论你是刚入行的新手开发者，还是拥有多年项目经验的资深工程师，本专栏都将为你提供一条系统化、高质量的问题排查与优化路径，助力你加速成长，攻克技术壁垒，迈向技术价值最大化与职业发展的更高峰🚀！    📌 特别说明： 文中部分技术问题来源于真实生产环境及网络公开案例，均经过精挑细选与系统化整理，并结合多位一线资深架构师和工程师多年实战经验沉淀，提

**My Coding Family** 1147

netty（三）【BIO、NIO实例】

文章目录1、BIO实例 1、BIO实例 启动主函数后使用"cmd"窗口： 实验代码： package com.dev.bio; import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService

会飞的小蜗 593

把审批体验做成一体化：SAP Business Workflow 里的 Secondary Method、Before Method 与 After Method

摘要：SAP Business Workflow 中，Task 的 Secondary、Before 和 After 三类方法对提升审批体验和可追溯性至关重要。Secondary Method 可自动展示辅助信息（如审批时弹出排班报表），但需注意其独立会话特性；Before Method 适合预处理和审计留痕；After Method 确保收尾动作可靠执行。三类方法按特定顺序调用，且错误不影响主流程。合理使用这些方法能减少事务码切换，增强审计能力，优化用户体验。（149字）

2007 年 ~ 2025 年，深耕 SAP 技术 18 年 191

网络编程（含案例）

一，ip InetAddress 封装计算机的IP地址，没有端口 1.使用getLocalHost方法创建InetAddress对象 2.根据域名得到netAddress对象 3.根据ip得到netAddress对象 方法 1.getLocaHost：本机 2.getByName：根据域名DNSip地址 二，端口 1.区分软件 2.两个字节（0-65535）UDP TCP 3.同一个协议端口不能冲突 4.定义端口越大越好 InetSocketAddress 包含端口，用于socket通信 三，URL 统一

qq_45811966的博客 1418

STM32F407+OV2640的DCMI+DMA双缓冲JPEG图像采集系统

在嵌入式视觉系统中，数字摄像头接口（DCMI）是MCU连接CMOS图像传感器的关键硬件通道，其与DMA协同实现零CPU干预的高速数据流采集；而JPEG作为一种基于DCT变换与量化压缩的有损图像格式，依赖传感器端硬件编码引擎才能满足实时性要求。理解DCMI三重同步时序（PCLK/HSYNC/VSYNC）与DMA双缓冲机制的流水线协作原理，是突破带宽瓶颈、避免FIFO溢出和帧丢失的技术基础。该架构广泛应用于智能硬件、工业检测与边缘AI前端等需低功耗、高可靠图像捕获的场景，本文以OV2640与STM32F407为

weixin_42103128的博客 157

人工智能在慢病管理中的具体应用全集：从技术落地到场景创新

这一成果的取得，得益于 AI 对居民血压数据的实时监测和分析，以及及时的干预措施。据统计，医疗支出下降了 18%，这主要是由于 AI 慢病管理系统实现了对慢病患者的早筛早诊早治，减少了并发症的发生，降低了医疗资源的浪费，从而减轻了患者和社会的医疗负担。医院信息系统（HIS）、电子病历（EMR）、区域卫生平台、可穿戴设备（如三诺血糖仪、华为手环）、第三方健康APP以及体检中心的数据往往采用不同的数据标准和格式（如HL7、FHIR、JSON、CSV等），且存储在相互隔离的系统中，形成典型的数据孤岛。

AllenLV的博客 2094

基于全硬件TCP/IP的产品应用实例

——WIZnet员工Alex培训笔记 今天Jerry给我培训WIZnet产品应用相关的知识，我做了个简单的总结，同大家分享一下我的学习经验，下面也提到一些产品的应用实例，大家都可以参考下，也给我一些你们的建议。喜欢我这篇文章的朋友一定要记得给我留言噢~ 解决完上次存留下来的问题并对WIZnet专利技术有了大体的了解之后，培训正式步入了产品应用的主题。在如今物联网快速成长的时代，可以说，哪里

WIZnet2012专栏 2397

msfvenom制作windows/linux/android/ios木马

msfvenom选项如下 -p, --payload<payload> 指定 payload(攻击荷载)。如果使用自定义payload,请使用'-'或者stdin指定。 -l, --list [module_typel列出指定模块的所有可用资源。模块类型包括:payloads, encoders, nops, all -n, --nopsled <length>为payload预先指定一个NOP滑动长度。 -f, --format <format>指定输出格式(使

Cwillchris的博客 2734

网络编程及BIO和NIO

从BIO和NIO到Netty入门一：BIO1.1：网络编程1.2：TCP通信1.3：UDP通信二：NIO三：Netty入门 一：BIO 1.1：网络编程 概述 通过计算机网络将多台计算机连接。计算机在网络中进行连接和通信时必须遵守一定规则，这种规则称为网络协议。 网络通信协议有很多种，常用的TCP/IP和UDP协议。 InetAddress 1：概述 jdk提供该类用于封装一个ip，并提供和ip相关方法。 2：常用API public class InetAddressTest {

郝竹本 1218

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

【Netty专题】【网络编程】从OSI、TCP/IP网络模型开始到BIO、NIO（Netty前置知识）

我是有点怕网络编程的，总有点【谈网色变】的感觉。为了让自己不再【谈网色变】，所以我想过系统学习一下，然后再做个笔记这样，加深一下理解。但是真要系统学习，其实还是要花费不少时间的，所以这里也只是简单的，尽可能地覆盖一下，梳理一些我认为比较迫切需要了解的网络编程相关的知识。其实单单网络编程跟TCP/IP协议族就可以拿来写一个独立的笔记了，但是为了让知识点更耦合一点，我还是决定写在一起。当然这样也有坏处，那就是知识点比较密集，然后导致笔记篇幅偏长，所以阅读的朋友给点耐心。

qq_32681589的博客 1781

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

【网络编程：BIO模型（实现群聊）】

希望这篇博客帮助你理解IO模型之BIO模型 网络编程：BIO模型一、什么式BIO模型二、BIO模型的缺点三、BIO 模型的实现 一、什么式BIO模型 网络编程的基本模型是C/S模型，即是两个进程之间的通信。服务端提供 IP 和监听端口，客户端通过连接想操作向服务器地址发送请求，通过三次握手连接，如果建立成功，双方就通过套接字进行通信。 传统的同步阻塞模型开发中，ServerSocket负责绑定IP地址，启动监听端口；Socket负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式的通信。 .

qq_44682003的博客 512

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。，新界面，新视觉，

【java网络编程】TCP三次握手、四次挥手，常见Socket通信BIO

java.io基于流模型实现，提供File抽象，输入输出流等IO功能，交互方式为同步阻塞（读取时不能干其他事情并且必须等待读取完成close），读取输入流或者写入输出流动作完成close之前，**线程就会一直阻塞**， 代码简单，但是IO效率低下，传统的inputstream，outputstream java.net 下面提供网络API，也就是网络编程，提供了Socket接口等，基于TCP/IP协议封装，Socket、ServerSocket、HttpURLConnection也是**同步阻塞IO，因为

a23452的博客 2357

深入解析Java NIO：从BIO到Reactor模式的网络编程演进

本文系统介绍了Java网络编程中的Socket、NIO及相关技术。Socket是应用层与TCP/IP协议族的中间层，通过IP地址和端口号建立通信链路。文章比较了BIO（同步阻塞）和NIO（同步非阻塞）模型，详细讲解了NIO三大核心组件：Selector、Channel和Buffer的工作原理。针对高并发场景，提出了Reactor模式及其多线程优化方案，包括单线程、工作者线程池和主从多线程三种实现方式。最后讨论了RPC框架的设计要点，分析了其与HTTP协议的关系，并指出实现RPC需要考虑代理、序列化和服务实例

qq_74092815的博客 977

原生 JDK 网络编程 BIO（五）

一些常见术语 Socket 是应用层与 TCP/IP 协议族通信的中间软件抽象层，它是一组接口。在设计模式 中，Socket 其实就是一个门面模式，它把复杂的 TCP/IP 协议族隐藏在 Socket 接口后面，对 用户来说，一组简单的接口就是全部，让 Socket 去组织数据，以符合指定的协议。 主机 A 的应用程序要能和主机 B 的应用程序通信，必须通过 Socket 建立连接，而建 立 Socket 连接必须需要底层 TCP/IP 协议来建立 TCP 连接。建立 TCP 连接需要底

nandao158的博客 255

【JavaSE】网络编程：IO演进之路、多线程版BIO、线程池版BIO

尚硅谷+黑马 的学习结合笔记

知识输出、记录学习 924

java - 网络编程 之 bio 编程

1.Socket 在了解什么是 bio 编程之前，先了解以下什么是 socket 1.1 socket 概念 套接字（socket）是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议，本地主机的IP地址，本地进程的协议端口，远地主机的IP地址，远地进程的协议端口。一个Socket是一对IP地址和端口。 Socket可以看成在两个程序进行通讯连接中的一个端点，一个程序将一段信息写入Socket中，该Socket将这段信

saienenen的博客 328

网络编程之BIO/NIO基础

什么是网络编程 网络编程是指编写运行在多个设备上（计算机）的程序, 通过网络进行数据交换. 比如现在流行的微服务, 把一个大的系统按照功能拆分多个微服务, 每个微服务都是一个独立的应用, 部署在不同的服务器上, 不同服务器上的微服务如何进行通信就是属于网络编程的范畴. TCP/UDP、IP、HTTP、Socket的区别 网络模型(OSI)从下往上分为七层, 分别是物理层、数据链路层、网络...

Tyshawn的博客 786

Socket网络编程

Socket概述 Socket，套接字就是两台主机之间逻辑连接的端点。TCP/IP协议是传输层协议，主要解决数据如何在网络中传输，而HTTP是应用层协议，主要解决如何包装数据。Socket是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议、本地主机的IP地址、本地进程的协议端口、远程主机的IP地址、远程进程的协议端口。 Socket整体流程 Socket编程主要涉及到客户端和服务端两个方面，首先是在服务器端创建

dingchengyu的博客 4350

Java 网络编程基础

一个网络请求、服务之间的调用都需要进行网络通讯，在日常开发时我们可能并不会关心我们的服务端是怎么接收到请求的、调用别的服务是怎么调用的，都是直接使用现成的框架或工具，比如，Tomcat、Dubbo、OkHttp等提供网络服务的框架。作为程序员，我们还是要知其然知其所以然。本文将介绍在 Java 中如何进行网络编程以及网络编程的基础知识。

二蛋的博客 3092

BIO、NIO编程与直接内存、零拷贝详解

什么是 NIO？ NIO 库是在 JDK 1.4 中引入的。NIO 弥补了原来的 BIO 的不足，它在标准 Java 代码中提供了高速的、面向块的 I/O。NIO 被称为 no-blocking io 或者 new io 都说得通。 和BIO 的主要区别 面向流与面向缓冲 Java NIO 和 IO 之间第一个最大的区别是，IO 是面向流的，NIO 是面向缓冲区的。 Java IO 面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。

qq_45061342的博客 2050

Java 原生网络编程（BIO | NIO | Reactor 模式）

Java 原生网络编程 BIO、NIO

tmacfrank 1628
上一篇： Shiro的缓存交给redis管理
下一篇： TCP-IP学习笔记二：NIO的网络编程Buffer简单使用
点赞 2
评论 0
书签 书签 3
motui
motui
博客等级 码龄10年 84粉丝 42原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值