【网络编程】Java网络编程中的基本概念及实现UDP、TCP客户端服务器程序（万字博文）

news2025/1/13 7:51:10

 系列文章目录

【网络通信基础】网络中的常见基本概念

【网络编程】Java网络编程中的基本概念及实现UDP、TCP客户端服务器程序（万字博文）

【网络原理】UDP协议的报文结构 及 校验和字段的错误检测机制（CRC算法、MD5算法）

目录

一、什么是网络编程？

二、网络编程中的基本概念

1. 客户端和服务器

2. 请求和响应

三、Socket套接字

UDP数据报套接字编程

1. DatagramSocket

2. DatagramPacket

3. UDP回显客户端服务器程序

4. UDP字典客户端服务器程序

TCP流套接字编程

1. ServerSocket

2. Socket

3. TCP回显客户端服务器程序

4. 服务器引入多线程

5. 服务器引入线程池

6. TCP字典客户端服务器程序 

一、什么是网络编程？

网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信(或称网络数据传输)。

即便是同一个主机，只要是不同进程，基于网络来传输数据，也属于网络编程。但是，我们的目的是提供网络上的不同主机，基于网络来传输数据资源。

网络编程，本质上就是学习“传输层”给“应用层”提供的API，通过代码的形式，把数据交给传输层，进一步的通过层层封装，就可以把数据通过网卡发送出去了。

二、网络编程中的基本概念

1. 客户端和服务器

客户端：主动发起通信的一方，称为客户端.

服务器：被动接受的一方，称为服务器，可以提供对外服务.

同一个程序在不同场景中，可能是客户端也可能是服务器(服务器可能还需要主动向别的服务器发起通信，此时的服务器相对于被发起通信的服务器来说，就是客户端).

2. 请求和响应

请求（request）：客户端给服务器发送数据。

响应（response）：服务器给客户端返回数据。

一般来说，获取一个网络资源，涉及到两次网络数据传输：

  • 第一次：请求数据的发送.
  • 第二次：响应数据的发送.

就比如在快餐店点一份炒饭：

先要发起请求：点一份炒饭；再有快餐店提供的对于响应：提供一份炒饭。

三、Socket套接字

Socket套接字，是由系统提供的用于网络编程的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程。

前面说过，要想进行网络编程，需要使用的系统API，本质上是由传输层提供的。

传输层涉及到的主要协议有两个：

  1. 流套接字：TCP（传输控制协议）
  2. 数据报套接字：UDP（用户数据报协议）

TCP的特点：                                                                 

  • 有连接(类似于打电话，需要接通才能通信)             
  • 可靠传输(尽可能完成数据传输，起码可以知道当前这个数据对方是否接收到了)                       
  • 面向字节流(此处字节流和文件中的字节流完全一致，网络中传输数据的基本单位就是字节)
  • 全双工(一个信道，可以双向通信)                            

 UDP的特点：

  • 无连接(类似于发微信/短信，直接发送过去)            
  • 不可靠传输(没有确认、重传机制；如果因为网络故障等原因，数据无法发到对方，UDP协议层也不会给应用层返回任何错误信息)
  • 面向数据报(每次传输的基本单位是一个数据报(由一系列的字节构成的)特定的结构)
  • 全双工(一个信道，可以双向通信)     

UDP数据报套接字编程

UDP socket API的使用

1. DatagramSocket

DatagramSocket 是 UDP Socket(套接字)，用于发送和接收UDP数据报

构造方法：

重要方法：

2. DatagramPacket

DatagramPacket 是 UDP Socket(套接字)发送和接收的数据报（每次发送接收数据的基本单位）

构造方法：

3. UDP回显客户端服务器程序

通过这个程序，了解 socket api 的使用，和典型的客户端服务器基本工作流程。

对于服务器，需要指定端口号来创建 socket （类似于饭店，需要指定具体位置），主要流程如下：

  1. 接收客户端请求，并解析
  2. 根据请求，计算出响应(回显服务器，则是直接将请求的数据返回)
  3. 将响应写回给客户端

注意事项详见代码注释： 

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

//Udp回显服务器
public class UdpEchoServer {

    //Udp套接字
    private DatagramSocket socket;

    public UdpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port); //服务器：指定端口号创建
    }

    public void start() throws IOException {
        System.out.println("服务器启动");
        while (true) {
            //1.接收客户端的请求，并解析
            DatagramPacket requestServer = new DatagramPacket(new byte[4096], 4096);
            socket.receive(requestServer);

            //2.根据请求，计算出响应
            String request = new String(requestServer.getData(), 0, requestServer.getLength());
            String response = process(request);

            //3.将响应写回给客户端(需要指定发送到的IP地址及端口号)
            DatagramPacket responseServer = new DatagramPacket(
                    response.getBytes(), response.getBytes().length, requestServer.getSocketAddress());
            socket.send(responseServer);

            //打印日志
            System.out.printf("[%s:%d] request:%s response:%s\n",
                    responseServer.getAddress(), responseServer.getPort(), request, response);
        }
    }

    //根据请求计算响应(由于是回显程序，直接返回请求的内容)
    public String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        UdpEchoServer udpEchoServer = new UdpEchoServer(9090);
        udpEchoServer.start();
    }
}

对于客户端，服务器的端口号可以由系统随机分配，但需要知道服务器的IP地址及端口号（去饭店吃饭，需要知道饭店的地址及具体是哪个门店），主要流程如下：

  1. 客户端读取用户请求
  2. 构造请求的数据报，并发送到服务器（此时就需要指定服务器的IP地址及端口号）
  3. 读取服务器的响应，并解析出响应的内容
  4. 输出服务器的响应
import java.io.IOException;
import java.net.*;
import java.util.Scanner;

//Udp回显客户端
public class UdpEchoClient {

    private DatagramSocket socket;
    private String address;
    private int port;

    //客户端需要知道服务器的IP地址及端口号
    public UdpEchoClient(String address, int port) throws SocketException {
        this.address = address;
        this.port = port;
        socket = new DatagramSocket(); //服务器：随机端口号创建
    }

    public void start() throws IOException {
        System.out.println("客户端启动");
        Scanner in = new Scanner(System.in);
        while (true) {
            System.out.print("-> ");
            if (!in.hasNext()) {
                break;
            }
            //1.控制台读取请求内容
            String request = in.next();

            //2.构造请求的数据报，并发送到服务器(需要指定目的IP地址和目的端口号发送请求)
            DatagramPacket requestPacket = new DatagramPacket(
                    request.getBytes(), request.getBytes().length, InetAddress.getByName(address), port);
            socket.send(requestPacket);

            //3.读取服务器的响应，并解析出响应的内容
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength());

            //4.将响应内容输出到控制台
            System.out.println(response);
        }
    }

    public static void main(String[] args) throws IOException {
        UdpEchoClient udpEchoClient = new UdpEchoClient("127.0.0.1", 9090);
        udpEchoClient.start();
    }
}

先运行服务器，再运行客户端，看程序的执行效果：

  • 可以看到，服务器端能够正确接收到请求并作出响应，并打印出日志（客户端IP，客户端端口号，请求内容，响应内容）
  • 客户端也能够正确发送请求，并正确解析服务器端返回的响应

这个程序并不能直接做到“跨主机通信”，因为这台主机可能不能直接访问到另一台主机（NAT机制）。但是可以通过以下手段实现“跨主机通信”：

  1. 将服务器端程序打成 jar 包
  2. 把 jar 包传到云服务器上，并运行

经过这样的操作，其他主机通过运行上述的客户端程序，就能够发起通信了。

4. UDP字典客户端服务器程序

基于上述回显服务器，还可以实现出一些其他带有一点业务逻辑的服务器。

改进成一个“字典服务器”，英译汉的效果。请求是一个英文单词，响应返回对应的中文翻译。

主要逻辑其实和回显服务器基本一致，唯一的区别就在于，服务器端将客户端请求的数据，计算成响应的方式不一致。回显服务器是直接返回客户端请求的数据，这里的字典服务器则是英译汉效果。

而上述代码中，这个根据请求数据计算响应数据的操作，是通过process方法实现的。因此只需要让这个字典服务器继承回显服务器，并重写process方法即可。这里英译汉的业务逻辑通过打表的方式实现。

import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Map;

//Udp字典服务器
public class UdpDictServer extends UdpEchoServer {

    Map<String, String> map;

    public UdpDictServer(int port) throws SocketException {
        super(port);
        map = new HashMap<>();

        map.put("cat", "小猫");
        map.put("dog", "小狗");
        map.put("animal", "动物");
    }

    //通过重写 计算响应的process方法，达成 英->汉 的效果
    @Override
    public String process(String request) {
        return map.getOrDefault(request, "找不到该单词");
    }

    public static void main(String[] args) throws IOException {
        UdpDictServer udpDictServer = new UdpDictServer(9090);
        udpDictServer.start();
    }
}

还是先运行字典服务器，再运行回显客户端（这里客户端是通用的，因为回显客户端只进行发送请求和接收响应并解析的操作），看程序的执行效果：

  • 同样，服务器端能够正确接收到请求、解析请求，并计算出响应、写回给客户端，并打印出日志（客户端IP，客户端端口号，请求内容，响应内容）
  • 客户端也能够正确发送请求，并正确解析服务器端返回的响应

TCP流套接字编程

1. ServerSocket

ServerSocket 类是创建TCP服务器端Socket的API. (只能给服务器端使用)

构造方法：

重要方法：

2. Socket

Socket 类用于创建客户端 Socket，或服务器端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket. (服务器端和客户端都能使用)

构造方法：

重要方法：

3. TCP回显客户端服务器程序

使用TCP协议实现回显客户端服务器程序。与UDP协议实现的最大区别是，TCP是有连接的，和打电话一样，需要一方(客户端)拨号，一方(服务器)接通，因此TCP协议首要操作就是等待客户端连接。

和UDP回显服务器一样，对于这里的服务器，同样需要指定端口号创建TCP服务器端Socket，即ServerSocket。

  1. 服务器启动后，就需要监听当前绑定端口(accept方法)，等待客户端连接。
  2. 当成功建立连接后，会返回一个Socket对象。这个对象保存了对端信息，即客户端信息，可以用来接收和发送数据（TCP是面向字节流的，通过这个Socket对象获取对应输入流和输出流，通过输入输出流进行对 socket 的读写，达成接收和发送数据的功能）。

后续流程和UCP回显服务器一致。此处由于每有一个客户端连接，就会有一个clientSocket，这里消耗的Socket会越来越多，因此每当一个客户端连接结束，就需要释放这个clientSocket。

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

//TCP回显服务器
public class TcpEchoServer {

    private ServerSocket serverSocket;

    public TcpEchoServer(int port) throws IOException {
        //指定服务器端口号，创建一个serverSocket
        serverSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            //监听当前绑定的端口，等待客户端连接 连接后，返回一个socket，里面保存客户端(对端)信息
            Socket clientSocket = serverSocket.accept();
            processConnection(clientSocket);
        }
    }

    private void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d] 客户端上线\n", clientSocket.getInetAddress(), clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            while (true) {
                //1.读取客户端请求的数据
                //利用scanner读取客户端输入的信息
                Scanner scanner = new Scanner(inputStream);
                if (!scanner.hasNext()) {
                    System.out.printf("[%s:%d] 客户端下线\n",
                            clientSocket.getInetAddress(), clientSocket.getPort());
                    break;
                }
                //这里的next()需要遇到\n才停止，因此需要对端写入的时候，要同时写入\n换行符
                String request = scanner.next();

                //2.解析请求的数据，并计算出响应
                String response = process(request);

                //3.将响应写回到客户端
                //outputStream.write(response.getBytes(), 0, response.getBytes().length);
                PrintWriter writer = new PrintWriter(outputStream);
                writer.println(response);
                writer.flush();

                //打印日志
                System.out.printf("[%s:%d] request:%s response:%s\n",
                        clientSocket.getInetAddress(), clientSocket.getPort(), request, response);
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            clientSocket.close();
        }
    }

    //回显服务器，直接返回原数据
    public String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer tcpEchoServer = new TcpEchoServer(9090);
        tcpEchoServer.start();
    }
}

对于客户端，需要指定服务器的IP和端口号建立连接，即使用 Socket(String host, int port) 创建Socket的时候，就开始发起与对应服务器建立连接的请求了。

主要流程和UDP回显客户端程序的流程也基本一致，只需要注意请求和响应数据的方式是不同的，是通过操作输入输出流完成的即可。

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;

//TCP回显客户端
public class TcpEchoClient {

    private Socket clientSocket;

    //需要指定服务器的IP和端口号
    public TcpEchoClient(String serverAddress, int serverPort) throws IOException {
        //与对应客户端建立连接
        clientSocket = new Socket(InetAddress.getByName(serverAddress), serverPort);
    }

    public void start() {
        System.out.println("客户端启动！");
        try (Scanner scannerConsole = new Scanner(System.in);
             InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            while (true) {
                //1.用户从控制台输入数据
                System.out.print("-> ");
                String request = scannerConsole.next();

                //2.将该数据作为请求，发送给服务器
                //outputStream.write(request.getBytes(), 0, request.getBytes().length);
                //outputStream.write('\n');
                PrintWriter writer = new PrintWriter(outputStream);
                writer.println(request);
                writer.flush(); //刷新缓冲区，确保数据发送出去

                //3.读取服务器的响应，并解析响应的内容
                Scanner scannerNetwork = new Scanner(inputStream);
                String response = scannerNetwork.next();

                //4.将响应输出到控制台
                System.out.println(response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) throws IOException {
        TcpEchoClient tcpEchoClient = new TcpEchoClient("127.0.0.1", 9090);
        tcpEchoClient.start();
    }
}

先运行服务器，再运行客户端，看执行效果：

可以看到，服务器和客户端都能满足我们的需求，但这里其实还存在一个问题。

当我们开启多个客户端想要进行连接通信时，只有第一个连接到的客户端才能正确通信，其他的客户端是没有反应的。要想某个客户端能正常通信，只有当其他客户端都下线（结束程序），这个客户端才能接收到响应数据。

可以看到，此处的这个客户端并没有正确通信，当另一个客户端下线之后，该客户端此前发送的数据又正常请求并响应了。

分析过程：

  • 第一个客户端连上服务器之后，服务器就会从accept这里返回（解除阻塞），然后进入到processConnection方法中.
  • 接下来服务器就会在processConnection循环处理客户端的请求，只有当客户端退出之后，连接结束，才会退出循环.
  • 而服务器在循环处理客户端请求的时候，第二个客户端发起连接请求，而服务器这里并不能执行到accept。因此并不能成功连接，只有当客户端退出，才会执行回到accept进行连接.

第二个客户端之前发的请求为什么能被立即处理？

  • 当前TCP在内核中，每个 socket 都是由缓冲区的。客户端发送的数据通过客户端代码，已经写入到该客户端的输出流（缓冲区）了，这里数据确实发送了，只不过数据在服务器的接收缓冲区中。
  • 一旦第一个客户端退出，回到第一层循环，执行accept连接操作，后续processConnection方法里的 next 就能把之前缓冲区的内容给读出来。

解决上述问题的核心思路就是使用多线程：

  • 单个线程，无法既能给客户端提供服务，又能去快速执行到第二次 accept 方法进行连接。
  • 通过引入多线程，让主线程只负责执行 accept。每次有一个客户端连接上来，就分配一个新的线程，由新的线程负责给客户端提供服务。

由于这里不涉及多个线程修改共享变量，因此没有线程安全问题，我们只需要改动 start 方法即可。

4. 服务器引入多线程

    //多线程
    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            //监听当前绑定的端口，等待客户端连接 连接后，返回一个socket，里面保存客户端(对端)信息
            Socket clientSocket = serverSocket.accept();

            Thread t = new Thread(() -> {
                try {
                    processConnection(clientSocket);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });
            t.start();
        }
    }

通过引入多线程，这里的服务器就能支持多个客户端同时与其通信了。

上述问题，不是TCP引起的，而是代码两次循环嵌套引起的，UDP服务器，就是只有一层循环，因此不会有这个问题。

而这个多线程版本同样还有一些问题： 

  • 每有一个客户端连接，就会创建一个新的线程，每当这个客户端结束，就要销毁这个线程。
  • 如果客户端比较多，并且频繁连接、关闭，就会使服务器频繁创建和销毁线程。

前面讲过，线程池解决的就是线程频繁创建和销毁的问题，因此，这里的优化方案就是使用线程池。

5. 服务器引入线程池

    public void start() throws IOException {
        System.out.println("服务器启动！");
        ExecutorService threadPool = Executors.newCachedThreadPool();
        while (true) {
            //监听当前绑定的端口，等待客户端连接 连接后，返回一个socket，里面保存客户端(对端)信息
            Socket clientSocket = serverSocket.accept();

            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
        }
    }

线程开销问题解决了。但是，如果当前的场景使线程频繁创建，但是不销毁呢？

  • 这种情况下，如果继续使用多线程/线程池，就会导致当前服务器积累大量的线程，此时，对于服务器的负担是非常重的。

要解决这个新问题，还可以引入其他的方案：

  1. 协程：轻量级线程，本质上还是一个线程，用户态可以通过手动调度的方式让这一个线程“并发”执行多个任务。
  2. IO 多路复用：系统内核级别的机制，本质上是让一个线程同时去负责处理多个socket。

6. TCP字典客户端服务器程序 

同UDP字典客户端服务器程序：

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

//TCP字典服务器
public class TcpDictServer extends TcpEchoServer {

    Map<String, String> map;

    public TcpDictServer(int port) throws IOException {
        super(port);

        map = new HashMap<>();
        map.put("cat", "小猫");
        map.put("dog", "小狗");
        map.put("animal", "动物");
    }

    @Override
    public String process(String request) {
        return map.getOrDefault(request, "未找到该单词");
    }

    public static void main(String[] args) throws IOException {
        TcpDictServer tcpDictServer = new TcpDictServer(9090);
        tcpDictServer.start();
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1618357.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

大小端解释以及如何使用程序判断IDE的存储模式

大小端解释以及如何使用程序判断IDE的存储模式

今天让我们来了解一下大小端的概念吧 什么是大小端&#xff1f; 大端&#xff08;存储&#xff09;模式&#xff1a;指的是数据的低位保存在内存的高地址处&#xff0c;而数据的高位则保存在内存的低地址处。 小端&#xff08;存储&#xff09;模式&#xff1a;指的是数据的低位…
阅读更多...
使用表格法插入公式和编号

使用表格法插入公式和编号

如何将公式和编号优雅地插入到论文当中呢&#xff1f; 首先插入一个1行2列的表格 调整一下 输入公式方法一&#xff1a;感觉墨迹公式挺好用的&#xff0c;word自带的 输入公式方法二&#xff1a;图片转LATEX代码 这个方法更快 分享一个公式识别网站 图片识别得到LATEX代码&…
阅读更多...
免费PNG素材网站推荐：设计效率倍增！

免费PNG素材网站推荐：设计效率倍增！

一、即时设计 新一代协同设计工具即时设计&#xff0c;内置丰富社区资源&#xff0c;可以在此获得设计前线的各类PNG图像&#xff0c;以及矢量图标&#xff0c;包括毛玻璃、3D混搭、全息投影、单色、平面化等&#xff0c;都是符合目前市场的主流风格。通过最近更新、作品、资源…
阅读更多...
【ks爬虫软件】把快手评论API接口封装成GUI采集工具

【ks爬虫软件】把快手评论API接口封装成GUI采集工具

用Python开发爬虫采集软件&#xff0c;可自动抓取快手评论数据&#xff0c;且包含二级评论。 快手的评论接口URL&#xff1a; # 请求地址 url https://www.kuaishou.com/graphql开发者模式分析过程&#xff1a; 进而封装成GUI界面软件&#xff0c;如下&#xff1a; 软件效…
阅读更多...
【Linux】开关机命令和服务管理类命令

【Linux】开关机命令和服务管理类命令

一般Linux是不会经常进行关机的,关机的正确流程是: sync->shutdown->reboot->poweroff sync: 将内存中的数据同步到硬盘中poweroff: 关闭系统,等同于shutdown -h nowreboot: 重启系统,等同于 shutdown -r nowshutdown[选项] [时间] shutdown命令常见用法: shutdown:…
阅读更多...
[vite] ts写配置根目录别名

[vite] ts写配置根目录别名

参考:配置 Vite | Vite 写对象的形式吧 import { defineConfig } from vite import vue from vitejs/plugin-vue import path from path// https://vitejs.dev/config/ export default defineConfig({plugins: [vue()],resolve: {alias: {"": path.resolve(__dirname…
阅读更多...
电磁仿真--基本操作-CST-(2)

电磁仿真--基本操作-CST-(2)

目录 1. 回顾基操 2. 操作流程 2.1 创建工程 2.2 修改单位 2.3 创建 Shape 2.4 使用拉伸 Extrude 2.5 修改形状 Modify Locally 2.6 导入材料 2.7 材料解释 2.8 材料分配 2.9 查看已分配的材料 2.10 设置频率、背景和边界 2.11 选择 Edge&#xff0c;设置端口 2.…
阅读更多...
Linux-进程间通信：System V消息队列

Linux-进程间通信：System V消息队列

目录 System V IPC概述标识符与IPC Key System V消息队列创建或打开一个消息队列发送消息接收消息控制消息队列1、IPC_STAT2、IPC_SET3、IPC_RMID 查看系统当前的消息队列代码示例 System V IPC&#xff08;Inter-Process Communication&#xff09;是一组用于在 Unix-like 操作…
阅读更多...
五款最受欢迎的上网行为管理软件

五款最受欢迎的上网行为管理软件

五款最受欢迎的上网行为管理软件 员工上网看视频怎么办&#xff1f;员工偷偷刷抖音怎么办&#xff1f;员工天天上招聘网&#xff0c;是不是有离职打算&#xff1f; 解决上述困扰的最好办法是使用监控软件了解员工一言一行。以下是几款推荐的上网行为管理和监控软件&#xff1a;…
阅读更多...
基于Linux系统命令行安装KingbaseES数据库

基于Linux系统命令行安装KingbaseES数据库

人大金仓通用性数据库&#xff08;Kingbase&#xff09;下载网址&#xff1a;人大金仓-成为世界卓越的数据库产品与服务提供商 选择“软件版本-数据库”&#xff0c;筛选条件Linux、完整版。找到需要的版本&#xff0c;点击下载。我下载的是KingbaseES_V008R006C008B0014_Lin6…
阅读更多...
机器学习理论基础—神经网络算法公式学习

机器学习理论基础—神经网络算法公式学习

机器学习理论基础—神经网络公式学习 M-P神经元 M-P神经元&#xff08;一个用来模拟生物行为的数学模型&#xff09;&#xff1a;接收n个输入(通常是来自其他神经 元)&#xff0c;并给各个输入赋予权重计算加权和&#xff0c;然后和自身特有的阈值进行比较 (作减法&#xff0…
阅读更多...
【大语言模型基础】Transformer模型Torch代码详解和训练实战

【大语言模型基础】Transformer模型Torch代码详解和训练实战

一、Transformer概述 Transformer是由谷歌在17年提出并应用于神经机器翻译的seq2seq模型&#xff0c;其结构完全通过自注意力机制完成对源语言序列和目标语言序列的全局依赖建模。 Transformer由编码器和解码器构成。下图展示了它的结构&#xff0c;其左侧和右侧分别对应着编…
阅读更多...
奇妙的探索——偶然发现的bug

奇妙的探索——偶然发现的bug

今天想在腾讯招聘官网找几个前端的岗位投一下&#xff0c;最近自己也在找工作&#xff0c;结果简历还没有投出去&#xff0c;就发现了腾旭招聘官网的3个前端bug。 1.有时候鼠标hover还没有滑倒下拉选框的菜单上&#xff0c;就消失了&#xff0c;消失的太快了&#xff0c;根本点…
阅读更多...
方便快捷！使用Roboflow进行数据增强（附详细操作）

方便快捷！使用Roboflow进行数据增强（附详细操作）

最近使用自定义数据集训练yolov8模型的时候突然发现一件很令人头疼的事情。那就是&#xff0c;数据集中图片太少了。于是想通过数据增强的方法扩大数据集。 通过查阅资料发现&#xff0c;大部分人都是用python中的imgaug库进行图像处理&#xff1b;这种方法最大的不便就是需要转…
阅读更多...
【数据结构】stack queue —— 栈和队列

【数据结构】stack queue —— 栈和队列

前言 这阵子一直在学数据结构&#xff0c;知识点消化地有点慢导致博客一直没写&#xff0c;现在总算是有时间歇下来补补前面落下的博客了。从现在起恢复周更&#xff0c;努努力一周两篇也不是梦……闲话少说&#xff0c;今天就让我们一起来认识栈和队列 1. 栈的介绍和使用 栈…
阅读更多...
40-50W 1.5KVDC 隔离 宽电压输入 DC/DC 电源模块——TP40(50)DC 系列

40-50W 1.5KVDC 隔离 宽电压输入 DC/DC 电源模块——TP40(50)DC 系列

TP40(50)DC系列电源模块额定输出功率为40-50W、应用于2:1、4&#xff1a;1电压输入范围 9V-18V、18V-36V、36V-75V、9V-36V、18V-75V的输入电压环境&#xff0c;输出电压精度可达1%&#xff0c;可广泛应用于通信、铁路、自动化以及仪器仪表等行业。
阅读更多...
dremio支持设置

dremio支持设置

Dremio 支持提供可用于诊断目的的设置。这些设置通过 Dremio UI&#xff1a;设置>支持启用&#xff08;或禁用&#xff09; 使用 Client Tools 可以配置当用户查看数据集中的数据时&#xff0c;Dremio 项目的工具栏上显示哪些客户端应用程序按钮。用户可以通过单击相应的工具…
阅读更多...
验证 python解释器是否安装成功

验证 python解释器是否安装成功

一. 简介 前一篇文章学习了下载并安装 python解释器&#xff0c;文章如下&#xff1a; windows系统下python解释器安装-CSDN博客 本文验证 python解释器是否安装成功。 二. 验证 python解释器是否安装成功 1. 首先&#xff0c;打开 Windows系统的 "cmd" 界面。…
阅读更多...
javascript（第三篇）原型、原型链、继承问题，使用 es5、es6实现继承，一网打尽所有面试题

javascript（第三篇）原型、原型链、继承问题，使用 es5、es6实现继承，一网打尽所有面试题

没错这是一道【去哪儿】的面试题目&#xff0c;手写一个 es5 的继承&#xff0c;我又没有回答上来&#xff0c;很惭愧&#xff0c;我就只知道 es5 中可以使用原型链实现继承&#xff0c;但是代码一行也写不出来。 关于 js 的继承&#xff0c;是在面试中除了【 this 指针、命名提…
阅读更多...
机器人模型匹配控制（MPC）MATLAB实现

机器人模型匹配控制（MPC）MATLAB实现

模型匹配控制&#xff08;Model matching control&#xff09;是指设计一个控制器使闭环系统的传递函数tf(s)与td(s)相一致&#xff01; mpcDesigner 可以分为&#xff1a; 2时域精确模型匹配控制3频域精确模型匹配控制 机械臂控制中应用模型匹配控制&#xff08;Model Matc…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023