BIO学习笔记

NLP实践——利用自己的语料进行Mask Language Model预训练 #!/usr/bin/env python # coding: utf-8 # In[1]: import os import json import copy from tqdm.notebook import tqdm import torch from torch.optim import AdamW from torch.utils.data import DataLoader, Dataset from transformers import BertForMaskedLM, BertTo 阅读详情

视频地址:https://www.bilibili.com/video/BV1gz4y1C7RK?from=search&seid=15021234423448500976

2. JAVA BIO深入剖析

Java BIO 就是传统的 java io 编程,其相关的类和接口在 java.io。
BIO(blocking I/O) : 同步阻塞,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,可以通过线程池机制改善(实现多个客户连接服务器)。

img

对 BIO 编程流程的梳理

  1. 服务器端启动一个 ServerSocket,注册端口,调用accpet方法监听客户端的Socket连接。
  2. 客户端启动 Socket对服务器进行通信,默认情况下服务器端需要对每个客户 建立一个线程与之通讯。

传统的BIO编程实例回顾

网络编程的基本模型是Client/Server模型,也就是两个进程之间进行相互通信,其中服务端提供位置信(绑定IP地址和端口),客户端通过连接操作向服务端监听的端口地址发起连接请求,基于TCP协议下进行三次握手连接,连接成功后,双方通过网络套接字(Socket)进行通信。

传统的同步阻塞模型开发中,服务端ServerSocket负责绑定IP地址,启动监听端口;客户端Socket负责发起连接操作。连接成功后,双方通过输入和输出流进行同步阻塞式通信。
基于BIO模式下的通信,客户端 - 服务端是完全同步,完全耦合的。

BIO模式下多发和多收消息

客户端案例如下

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
/**
    目标: Socket网络编程。

    Java提供了一个包:java.net下的类都是用于网络通信。
    Java提供了基于套接字(端口)Socket的网络通信模式,我们基于这种模式就可以直接实现TCP通信。
    只要用Socket通信,那么就是基于TCP可靠传输通信。

    功能1:客户端发送一个消息,服务端接口一个消息,通信结束!!

    创建客户端对象:
        (1)创建一个Socket的通信管道,请求与服务端的端口连接。
        (2)从Socket管道中得到一个字节输出流。
        (3)把字节流改装成自己需要的流进行数据的发送
    创建服务端对象:
        (1)注册端口
        (2)开始等待接收客户端的连接,得到一个端到端的Socket管道
        (3)从Socket管道中得到一个字节输入流。
        (4)把字节输入流包装成自己需要的流进行数据的读取。

    Socket的使用:
        构造器:public Socket(String host, int port)
        方法:  public OutputStream getOutputStream():获取字节输出流
               public InputStream getInputStream() :获取字节输入流

    ServerSocket的使用:
        构造器:public ServerSocket(int port)

    小结:
        通信是很严格的,对方怎么发你就怎么收,对方发多少你就只能收多少!!

 */
public class ClientDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("==客户端的启动==");
        // (1)创建一个Socket的通信管道,请求与服务端的端口连接。
        Socket socket = new Socket("127.0.0.1",8888);
        // (2)从Socket通信管道中得到一个字节输出流。
        OutputStream os = socket.getOutputStream();
        // (3)把字节流改装成自己需要的流进行数据的发送
        PrintStream ps = new PrintStream(os);
        // (4)开始发送消息
        ps.print("客户端");  //此时客户端发送的数据并不是按行进行发送的
        //ps.println("客户端");  //此时客户端发送的数据是按行进行发送的
        ps.flush();
    }
}

服务端案例如下

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 服务端
 */
public class ServerDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("==服务器的启动==");
        // (1)注册端口
        ServerSocket serverSocket = new ServerSocket(8888);
        //(2)开始在这里暂停等待接收客户端的连接,得到一个端到端的Socket管道
        Socket socket = serverSocket.accept();
        //(3)从Socket管道中得到一个字节输入流。
        InputStream is = socket.getInputStream();
        //(4)把字节输入流包装成自己需要的流进行数据的读取。
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        //(5)读取数据
        String line ;
        //while表示一直等待客户端发送的数据,并且数据是按行进行读取
        while((line = br.readLine())!=null){
            System.out.println("服务端收到:"+line);
        }
        /*
        //if表示只读取一次客户端发送的数据,并且数据是按行进行读取
        if((line = br.readLine())!=null){
            System.out.println("服务端收到:"+line);
        }
        */
    }
}

小结
在以上通信中,服务端会等待客户端的消息,如果客户端没有进行消息的发送,服务端将一直进入阻塞状态。
同时服务端是按照行获取消息的,这意味着客户端也必须按照行进行消息的发送,否则服务端将进入等待消息的阻塞状态!

BIO模式下多发和多收消息

在前面的案例中,只能实现客户端发送消息,服务端接收消息,并不能实现反复的收消息和反复的发消息,我们只需要在客户端案例中,加上反复按照行发送消息的逻辑即可!案例代码如下:

客户端代码如下

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/**
    目标: Socket网络编程。

    功能1:客户端可以反复发消息,服务端可以反复收消息

    小结:
        通信是很严格的,对方怎么发你就怎么收,对方发多少你就只能收多少!!

 */
public class ClientDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("==客户端的启动==");
        // (1)创建一个Socket的通信管道,请求与服务端的端口连接。
        Socket socket = new Socket("127.0.0.1",8888);
        // (2)从Socket通信管道中得到一个字节输出流。
        OutputStream os = socket.getOutputStream();
        // (3)把字节流改装成自己需要的流进行数据的发送
        PrintStream ps = new PrintStream(os);
        // (4)开始发送消息
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.print("请说:");
            String msg = sc.nextLine();
            ps.println(msg);
            ps.flush();
        }
    }
}

服务端代码如下

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 服务端
 */
public class ServerDemo {
    public static void main(String[] args) throws Exception {
        String s = "886";
        System.out.println("886".equals(s));
        System.out.println("==服务器的启动==");
        //(1)注册端口
        ServerSocket serverSocket = new ServerSocket(8888);
        //(2)开始在这里暂停等待接收客户端的连接,得到一个端到端的Socket管道
        Socket socket = serverSocket.accept();
        //(3)从Socket管道中得到一个字节输入流。
        InputStream is = socket.getInputStream();
        //(4)把字节输入流包装成  自己需要的流进行数据的读取。
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        //(5)读取数据
        String line ;
        while((line = br.readLine())!=null){
            System.out.println("服务端收到:"+line);
        }
    }
}

本案例中确实可以实现客户端多发多收
但是服务端只能处理一个客户端的请求,因为服务端是单线程的。一次只能与一个客户端进行消息通信。

BIO模式下接收多个客户端

在上述的案例中,一个服务端只能接收一个客户端的通信请求,那么如果服务端需要处理很多个客户端的消息通信请求应该如何处理呢,此时我们就需要在服务端引入线程了,也就是说客户端每发起一个请求,服务端就创建一个新的线程来处理这个客户端的请求,这样就实现了一个客户端一个线程的模型,图解模式如下:

在这里插å¥å›¾ç‰‡æè¿°

客户端案例代码如下

/**
    目标: Socket网络编程。

    功能1:客户端可以反复发,一个服务端可以接收无数个客户端的消息!!

    小结:
         服务器如果想要接收多个客户端,那么必须引入线程,一个客户端一个线程处理!!

 */
public class ClientDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("==客户端的启动==");
        // (1)创建一个Socket的通信管道,请求与服务端的端口连接。
        Socket socket = new Socket("127.0.0.1",7777);
        // (2)从Socket通信管道中得到一个字节输出流。
        OutputStream os = socket.getOutputStream();
        // (3)把字节流改装成自己需要的流进行数据的发送
        PrintStream ps = new PrintStream(os);
        // (4)开始发送消息
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.print("请说:");
            String msg = sc.nextLine();
            ps.println(msg);
            ps.flush();
        }
    }
}

服务端案例代码如下

/**
    服务端
 */
public class ServerDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("==服务器的启动==");
        // (1)注册端口
        ServerSocket serverSocket = new ServerSocket(7777);
        while(true){
            //(2)开始在这里暂停等待接收客户端的连接,得到一个端到端的Socket管道
            Socket socket = serverSocket.accept();
            // 创建一个独立的线程对socket进行处理
            new ServerReadThread(socket).start();
            System.out.println(socket.getRemoteSocketAddress()+"上线了!");
        }
    }
}

class ServerReadThread extends Thread{
    private Socket socket;

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

    @Override
    public void run() {
        try{
            //(3)从Socket管道中得到一个字节输入流。
            InputStream is = socket.getInputStream();
            //(4)把字节输入流包装成自己需要的流进行数据的读取。
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            //(5)读取数据
            String line ;
            while((line = br.readLine())!=null){
                System.out.println("服务端收到:"+socket.getRemoteSocketAddress()+":"+line);
            }
        }catch (Exception e){
            System.out.println(socket.getRemoteSocketAddress()+"下线了!");
        }
    }
}

缺点:

  • 每个Socket接收到,都会创建一个线程,线程的竞争、切换上下文影响性能;
  • 每个线程都会占用栈空间和CPU资源;
  • 并不是每个socket都进行IO操作,无意义的线程处理(等待);
  • 客户端的并发访问增加时。服务端将呈现1:1的线程开销,访问量越大,系统将发生线程栈溢出,线程创建失败,最终导致进程宕机或者僵死,从而不能对外提供服务。

伪异步I/O编程

在上述案例中:客户端的并发访问增加时。服务端将呈现1:1的线程开销,访问量越大,系统将发生线程栈溢出,线程创建失败,最终导致进程宕机或者僵死,从而不能对外提供服务。

接下来我们采用一个伪异步I/O的通信框架,采用线程池和任务队列实现,当客户端接入时,将客户端的Socket封装成一个Task(该任务实现java.lang.Runnable线程任务接口)交给后端的线程池中进行处理。JDK的线程池维护一个消息队列和N个活跃的线程,对消息队列中Socket任务进行处理,由于线程池可以设置消息队列的大小和最大线程数,因此,它的资源占用是可控的,无论多少个客户端并发访问,都不会导致资源的耗尽和宕机。

在这里插å¥å›¾ç‰‡æè¿°

客户端源码分析

public class Client {
   public static void main(String[] args) {
      try {
         // 1.简历一个与服务端的Socket对象:套接字
         Socket socket = new Socket("127.0.0.1", 9999);
         // 2.从socket管道中获取一个输出流,写数据给服务端 
         OutputStream os = socket.getOutputStream() ;
         // 3.把输出流包装成一个打印流 
         PrintWriter pw = new PrintWriter(os);
         // 4.反复接收用户的输入 
         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
         String line = null ;
         while((line = br.readLine()) != null){
            pw.println(line);
            pw.flush();
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

线程池处理类

// 线程池处理类
public class HandlerSocketThreadPool {
   
   // 线程池 
   private ExecutorService executor;
   
   public HandlerSocketThreadPool(int maxPoolSize, int queueSize){
      
      this.executor = new ThreadPoolExecutor(
            3, // 8
            maxPoolSize,  
            120L, 
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<Runnable>(queueSize) );
   }
   //提交一个任务
   public void execute(Runnable task){
      this.executor.execute(task);
   }
}

服务端源码分析

public class Server {
   public static void main(String[] args) {
      try {
         System.out.println("----------服务端启动成功------------");
         ServerSocket ss = new ServerSocket(9999);

         // 一个服务端只需要对应一个线程池
         HandlerSocketThreadPool handlerSocketThreadPool =
               new HandlerSocketThreadPool(3, 1000);

         // 客户端可能有很多个
         while(true){
            Socket socket = ss.accept() ; // 阻塞式的!
            System.out.println("有人上线了!!");
            // 每次收到一个客户端的socket请求,都需要为这个客户端分配一个
            // 独立的线程 专门负责对这个客户端的通信!!
            handlerSocketThreadPool.execute(new ReaderClientRunnable(socket));
         }

      } catch (Exception e) {
         e.printStackTrace();
      }
   }

}
class ReaderClientRunnable implements Runnable{

   private Socket socket ;

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

   @Override
   public void run() {
      try {
         // 读取一行数据
         InputStream is = socket.getInputStream() ;
         // 转成一个缓冲字符流
         Reader fr = new InputStreamReader(is);
         BufferedReader br = new BufferedReader(fr);
         // 一行一行的读取数据
         String line = null ;
         while((line = br.readLine())!=null){ // 阻塞式的!!
            System.out.println("服务端收到了数据:"+line);
         }
      } catch (Exception e) {
         System.out.println("有人下线了");
      }

   }
}
  • 伪异步io采用了线程池实现,因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题,但由于底层依然是采用的同步阻塞模型,因此无法从根本上解决问题。
  • 如果单个消息处理的缓慢,或者服务器线程池中的全部线程都被阻塞,那么后续socket的i/o消息都将在队列中排队。新的Socket请求将被拒绝,客户端会发生大量连接超时。

BIO文件传输

import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.Socket;

/**
    目标:实现客户端上传任意类型的文件数据给服务端保存起来。

 */
public class Client {
    public static void main(String[] args) {
        try(
                InputStream is = new FileInputStream("C:\\Users\\dlei\\Desktop\\BIO,NIO,AIO\\文件\\java.png");
        ){
            //  1、请求与服务端的Socket链接
            Socket socket = new Socket("127.0.0.1" , 8888);
            //  2、把字节输出流包装成一个数据输出流
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            //  3、先发送上传文件的后缀给服务端
            dos.writeUTF(".png");
            //  4、把文件数据发送给服务端进行接收
            byte[] buffer = new byte[1024];
            int len;
            while((len = is.read(buffer)) > 0 ){
                dos.write(buffer , 0 , len);
            }
            dos.flush();
            Thread.sleep(10000);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

服务端开发

import java.net.ServerSocket;
import java.net.Socket;

/**
    目标:服务端开发,可以实现接收客户端的任意类型文件,并保存到服务端磁盘。
 */
public class Server {
    public static void main(String[] args) {
        try{
            ServerSocket ss = new ServerSocket(8888);
            while (true){
                Socket socket = ss.accept();
                // 交给一个独立的线程来处理与这个客户端的文件通信需求。
                new ServerReaderThread(socket).start();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
import java.io.DataInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.UUID;

public class ServerReaderThread extends Thread {
    private Socket socket;
    public ServerReaderThread(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try{
            // 1、得到一个数据输入流读取客户端发送过来的数据
            DataInputStream dis = new DataInputStream(socket.getInputStream());
            // 2、读取客户端发送过来的文件类型
            String suffix = dis.readUTF();
            System.out.println("服务端已经成功接收到了文件类型:" + suffix);
            // 3、定义一个字节输出管道负责把客户端发来的文件数据写出去
            OutputStream os = new FileOutputStream("C:\\Users\\dlei\\Desktop\\BIO,NIO,AIO\\文件\\server\\"+
                    UUID.randomUUID().toString()+suffix);
            // 4、从数据输入流中读取文件数据,写出到字节输出流中去
            byte[] buffer = new byte[1024];
            int len;
            while((len = dis.read(buffer)) > 0){
                os.write(buffer,0, len);
            }
            os.close();
            System.out.println("服务端接收文件保存成功!");

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
DCNv4+YOLOv8:2024最新可变形卷积赋能目标检测,从原理到实战的科研级优化指南 从理解DCNv4“自适应变形卷积核”的核心思想,到亲手将其嵌入YOLOv8并验证在复杂场景的检测效果,再到基于此探索属于自己的科研与工程方向——这个过程能让你深刻理解目标检测中“特征自适应提取”的核心价值。现在就开始行动,相信你会在目标检测的“自适应特征提取”之路上,走出一条属于自己的技术路径。实验通常会证明:嵌入DCNv4后,YOLOv8在复杂场景下的检测精度提升3-5个百分点,尤其是小目标和遮挡目标的AP提升更为明显,而推理速度仅下降5%-10%(可通过模型量化进一步优化)。2024年最新推出的。 阅读详情

相关推荐

Setup&Hold互卡问题和Useful Skew的影响

setup和hold互卡问题分析

godping的博客 5100

客户端多线程接收服务器信息,【原创】多线程实现:服务器发送消息时,所有客户端可收到。客户端发送信息时,只服务器可收到...

多线程实现需求:1、实现服务器与客户端的通信,服务器可接收多个客户端。2、服务器发送消息时,所有客户端都可收到。3、客户端发送信息时,只有服务器可收到。4、服务器发送“bye”时,包括服务器程序及所有客户端程序都结束,客户端发送“bye”时,本客户端结束(当然,服务器对应的线程也会结束)。5、服务器要在输出客户端消息时,要连同对应客户端的IP一起输出。对于上述需求,对应序号的解决方法如下:1. 选...

weixin_29380121的博客 897

中国全国地面站点数据(1981-2010)、月平均气象、月平均降水、月平均相对湿度、月最大降水、月最高温度最低温度、月最高温平均值最低温平均值、高低温站点基础数据,气候数据

中国全国地面站点数据(1981-2010)、月平均气象、月平均降水、月平均相对湿度、月最大降水、月最高温度最低温度、月最高温平均值最低温平均值、高低温站点基础数据 b_china_mon_avg_data_pressure月平均气象 b_china_mon_avg_data_rain月平均降水 b_china_mon_avg_data_rhu月平均相对湿度 b_china_mon_max_data_rain月最大降水 b_china_mon_max_min_data_tem月最高温度最低温度 b_china

无极低码 2万+

I/O 模型学习笔记【全面理解BIO/NIO/AIO】

I/O 模型概念,全面理解BIO/NIO/AIO ,面试相关。NIO概念,聊天室代码示例,零拷贝等概念。

qq_33129875的博客 1115

从传统扫描到SSN:Tessent数据包技术如何减少90%测试时间

本文深入探讨了Tessent流式扫描网络(SSN)如何通过其核心的数据包技术,彻底改变芯片测试范式。该技术将测试数据封装成标准化数据包,在共享总线上进行智能路由与分发,实现了动态带宽分配与核心独立测试,从而将复杂SoC(如AI芯片)的总体测试时间大幅削减90%,并显著提升测试灵活性与可扩展性。

meat5的博客 493

海康VisionMaster使用学习笔记7-Group模块

光标需放在[]中选择循环索引,循环索引用于实现依次检测10个匹配框的顶点,若不订阅,模块会循环检测同一个匹配框。可以看到绿色是它的边缘点.为方便查看顶点,将边缘点设置为不可见。循环使能打开,开始值设为0,循环结束值设为快速匹配的匹配个数。回到上一层,点击Group工具的设置图标,圆拟合的点设置为Group工具输出的点集。图像输入源选择Group的图像输入源。区域选择Group的快速匹配的匹配框。添加订阅到Group内部的顶点检测。对匹配框区域进行顶点检测。用于定位匹配框中的顶点。添加快速匹配的匹配框。

风凌的博客 4185

BIO,NIO,AIO实践学习笔记(便于理解理论)

文章目录BIONIOAIO BIO package com.monkey.bio; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; public class SocketServer { public static void main(String[] args) throws IOException{ //cmd命令: telnet localhost 9000

小猴子的博客 961

Windows11上CUDA 12.3配PyTorch踩坑记:一条官网命令救了我的GPU加速

本文详细介绍了在Windows 11上配置CUDA 12.3与PyTorch的完整指南,包括环境准备、安装要点、兼容性解决方案和性能验证。通过官方推荐的conda命令和实用技巧,帮助开发者解决常见问题,实现高效的GPU加速,提升深度学习开发效率。

weixin_42528974的博客 109

学习记录BIO、NIO、AIO

Java BIO 就是传统的 java io编程,相关的类和接口在java.ioBIO(blocking I/O) : 同步阻塞,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销Java NIO(New IO)NIO与原来的IO有同样的作用和目的,但是使用的方式完全不同,NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。

qq_44980517的博客 199

手把手教你学pcie--内存管理和保护机制(一):MPU与其他内存管理和保护机制详解

MPU(Memory Protection Unit)是一种专门用于 ​。,这些机制通常协同工作,形成多层防御体系,兼顾安全性、性能和灵活性。

MHD0815的博客 280

【python爬虫--爬取电商商品及对其销量、好差评等数据进行分析】Python爬虫爬取电商商品及大数据分析-实战

选择目标电商网站:这里选择爬取两个不同电商网站(比如京东、淘宝)上的商品数据,包括商品名称、价格、销量和评价信息。编写爬虫:通过爬虫获取商品信息并保存数据。数据清洗与对齐:将两个电商网站抓取到的数据进行统一清洗和对齐。数据分析:进行销量分析、好评与差评分析等。

Dreams°的博客 4013

BIO与NIO学习

想必大家一定发现bio的明显的弊端了吧,随着接入的客户端越来越多服务器创建的线程数也就越多,在提供服务时在不同线程间的切换(需要保护当前现场,恢复下个线程运行的环境)也会越频繁,这会造成cpu利用的极大浪费,且这种模式的接入量存在明显的上限。但是需要thread去不断轮询clients,当clients非常大的时候循环的事件开销就会很大,并且对于客户链来说需要执行读写操作的时间和数量只占很小的一部分,所以对于轮询操作不仅耗时而且大部分操作是无效的。所以根本问题就在阻塞上,阻塞导致原线程无法提供服务。

release_lonely的博客 927

无人驾驶Autoware导读

认知有限,望大家多多包涵,有什么问题也希望能够与大家多交流,共同成长!本文先对无人驾驶Autoware介绍做个简单的介绍,具体内容后续再更,其他模块可以参考去我其他文章提示:以下是本篇文章正文内容。

qq_35635374的博客 2399

Netty学习笔记 3.2 NIO和BIO比较及原理示意图

Netty学习笔记 3.2 NIO和BIO比较及原理示意图 NIO 和 BIO 的比较 BIO 以流的方式处理数据,而 NIO 以块的方式处理数据,块 I/O 的效率比流 I/O 高很多 BIO 是阻塞的,NIO 则是非阻塞的 BIO基于字节流和字符流进行操作,而 NIO 基于 **Channel(通道)和 Buffer(缓冲区)**进行操作,数据总是从通道读取到缓冲区中,或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道的事件(比如:连接请求,数据到达等),因此使用单个线程就可以监听多个

zyzy123321的博客 775

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

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

TCP/IP学习笔记一:BIO的网络编程-简单实例标签(空格分隔): BIO 网络编程一、简单的BIO网络编程实例:实现简单的web服务器(简单模仿Tomcat的请求和响应) 服务器端的实现: package com.bio.socket; import java.io.BufferedReader; import java.io.InputStream; import

MoTui的博客 2318

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

BIO NIO AIO 学习笔记

网络编程1.TCP编程1.1 网络相关基础概念1.2 TCP编程案例2.UDP编程2.1UDP协议特点2.2UDP编程案例3.同步阻塞的BIO3.1什么是BIO?2.2BIO相关案例4,同步非阻塞的NIO选择 器(Selector)的应用Selector 示意图和特点说明服务端流程客户端流程4.8 NIO非阻塞式网络通信入门案例代码案例异步非阻塞的AIO 1.TCP编程 1.1 网络相关基础概念 我们在学习网络编程前先来复习一下IP地址端口号协议,套接字的相关概念。 IP地址: 用来唯一标识全球连接在互联

weixin_44991304的博客 777

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

BIO、NIO学习笔记

文章目录1.BIO (Blocking I/O)2.NIO Java 中的 BIO、NIO和 AIO 理解为是 Java 语言对操作系统的各种 IO 模型的封装。程序员在使用这些 API 的时候,不需要关心操作系统层面的知识,也不需要根据不同操作系统编写不同的代码。只需要使用Java的API就可以了。 在讲 BIO,NIO,AIO 之前先来回顾一下这样几个概念:同步与异步,阻塞与非阻塞。 同步与异步 同步:同步就是一个任务的完成需要依赖另外一个任务时,只有等待被依赖的任务完成后,依赖的任务才能算完成。

H35790的博客 175

netty学习笔记——BIO

package com.songguo.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.Executors; public class BIOServer { public stati.

无 206

BIO、NIO、Netty学习笔记

BIO是阻塞io,是面向数据流的,一个连接对应一个线程。服务端监听指定端口,socket.accept()方法阻塞等待客户端连接。 示例代码如下 package NettyLearn.bio; import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.ExecutorService;

qinian_ztc的博客 203

【学习笔记】深入浅析BIO、NIO、AIO

BIO、NIO、AIO Java的I/O演进之路 I/O模型:就是用什么样的通道或者说是通信模式和架构进行数据的传输和接收,很大程度上决定了程序通信的性能,Java共支持3种网络编程的I/O模型:BIO、NIO、AIO 实际 通行需求下,要根据不同的业务场景和性能需求决定选择不同的I/O模型 1.I/O模型 BIO 同步并阻塞(传统阻塞型),服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销 NIO 同步非阻塞,服务器实

weixin_43849468的博客 1474

BIO和NIO学习笔记及比较

BIO和NIO 1.BIO 1.1概念 BIO(blocking I/O):同步且阻塞。服务器实现模式为一个连接启动一个线程,当客户端有连接请求时服务器就为其启动一个线程去处理。 1.2单线程演示 1.编写服务器端代码,监听8080端口,同时接收客户端发来的信息,启动服务端。服务器正在等待连接。 2.编写客户端代码,绑定本机的8080端口,建立socket连接,发送数据,启动客户端。 3.这时...

qq_35777564的博客 306

BIO NIO AIO学习笔记

在学习tomcat的时候接触到了BIO,NIO,NIO2(AIO),下来自己找了资料,找到一个算是最浅显易懂的,先挂链接 知乎大佬的 从结论开始 这里只考虑两个实体(客户端、服务端),一个事件(客户端向服务端请求数据) 同步、异步描述的是:客户端在请求数据的过程中,能否做其他事情。 阻塞、非阻塞描述的是:客户端与服务端是否从头到尾始终都有一个持续连接,以至于占用了通道,不让其他客户端成功连接。 那么BIO NIO AIO就可以简单的理解为: BIO(同步阻塞):客户端在请求数据的过程中,保持一个连接,不能做

jin9xiao的博客 309

BIO、NIO、AIO、Netty 学习笔记

首先了解一下什么是IO? Java中I/O是以流为基础进行数据的输入输出的,所有数据被串行化写入输出流。串行化就是数据要按顺序进行输入输出,也就是java通过io流方式和外部设备进行交互。 比如程序从服务器上下载图片,就是通过流的方式从网络上以流的方式到程序中,再到硬盘中。 同步与异步,阻塞与非阻塞的区别 同步,一个任务的完成之前不能做其他操作,必须等待(等于在打电话)。 异步,一个任务的完成之前,可以进行其他操作(等于在聊QQ)。 阻塞,是相对于CPU来说的, 挂起当前线程,不能做其他操作只...

Whynotwu的博客 457

BIO NIO学习笔记

BIO: blocking io 一个线程处理一个客户端连接和读写事件 缺点:效率低,浪费线程资源,一个线程只能处理一个连接 伪代码: ServerSocket serverSocket = new ServerSocket(8090); while (true){ Socket clientSocket = serverSocket.accept(); //阻塞,等待客户端连接 Byte[] bytes = new Byte[1024]; int n = clientSocket.getInputS

AJUNqq的博客 278

Java IO学习笔记五:BIO到NIO

此外BIO模型还有一个非常严重的问题,因为是阻塞模型,所以客户端在和服务端建立连接后,如果迟迟不发送数据,服务端线程开销花费很多。服务端每次用两端口循环多次去和服务端建立连接,我们可以观察服务端建立连接的速度,通过服务端打印的信息可以感知到连接的速度。的时候,即有新的客户端连接进来,我们把这个client加入到列表中,然后遍历clients,去消费客户端的请求。再次运行客户端,并切换到服务端查看打印日志,速度比前面的BIO快了非常多。问题,即来了多少客户端就启动多少个线程,会导致服务端内存爆掉。

Practitioner 195

[Linux]学习笔记系列 -- [block]bio

本文介绍了Linux内核中bio.h头文件定义的BIO迭代器与数据段访问接口。该API为块设备驱动提供了高效安全的struct bio操作机制,核心功能包括:1) 通过迭代器模式访问当前数据段的物理页、偏移和长度;2) 支持遍历所有数据段;3) 精确更新处理进度;4) 提供状态查询功能。实现上采用分层设计,底层直接操作bvec_iter结构,上层封装为简洁的bio_*宏,并特殊处理无数据请求类型。所有函数均被定义为static inline以优化性能,这些接口位于I/O处理的热路径上,对块设备驱动开发至关重

wdfk-prog.space 788
上一篇: JAVA NIO学习笔记
下一篇: G1垃圾收集器简述
Guo_Chuang
博客等级 码龄6年 9粉丝 61原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值