服务器端编程，经常需要构造高性能的网络应用，需要选用高性能的 IO 模型，这也是通关大公司面试必备的知识。
首先，解释一下这里的阻塞与非阻塞： 阻塞 IO，指的是需要内核 IO 操作彻底完成后，才返回到用户空间执行用户的操作。阻塞指的是用户空间程序的执行状态。传统的 IO 模型都是同步阻塞 IO。在 Java 中，默认创建的 socket 都是阻塞的。 其次，解释一下同步与异步： 同步 IO，是一种用户空间与内核空间的 IO 发起方式。同步 IO 是指用户空间的线程是主动发起 IO 请求的一方，内核空间是被动接受方。异步 IO 则反过来，是指系统内核是主动发起 IO 请求的一方，用户空间的线程是被动接受方。
阿里面试题
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* FileInputStream在使用完以后，不关闭流，想二次使用可以怎么操作？
* @author dhb
*/
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, NoSuchFieldException {
String parentPath = "";
String text1Path = parentPath + "text1.txt";
String text2Path = parentPath + "text2.txt";
String text3Path = parentPath + "text3.txt";
FileInputStream text1InputStream = new FileInputStream(text1Path);
FileOutputStream text2OutputStream = new FileOutputStream(text2Path);
FileOutputStream text3OutputStream = new FileOutputStream(text3Path);
int len;
byte[] bytes = new byte[1024];
while ((len = text1InputStream.read(bytes)) != -1) {
text2OutputStream.write(bytes, 0, len);
}
Class<? extends FileInputStream> inputStreamClass = text1InputStream.getClass();
Field fd = inputStreamClass.getDeclaredField("fd");
fd.setAccessible(true);
Object o = fd.get(text1InputStream);
System.out.println(o.hashCode());
if (text1InputStream.read() == -1) {
Method open0 = inputStreamClass.getDeclaredMethod("open0", String.class);
open0.setAccessible(true);
open0.invoke(text1InputStream, text1Path);
}
Object o1 = fd.get(text1InputStream);
System.out.println(o1.hashCode());
while ((len = text1InputStream.read(bytes)) != -1) {
text3OutputStream.write(bytes, 0, len);
}
text2OutputStream.flush();
text2OutputStream.close();
text3OutputStream.flush();
text3OutputStream.close();
}
}
select版本比阻塞版本的性能起码高了3倍+
# select版本
dhb@dev:~/下载/webbench-1.5$ webbench -c 1000 -t 30 http://127.0.0.1:1500/t
Webbench - Simple Web Benchmark 1.5
Copyright (c) Radim Kolar 1997-2004, GPL Open Source Software.
Benchmarking: GET http://127.0.0.1:1500/t
1000 clients, running 30 sec.
Speed=735248 pages/min, 269580 bytes/sec.
Requests: 367610 susceed, 14 failed.
# 阻塞版本
dhb@dev:~/下载/webbench-1.5$ webbench -c 1000 -t 30 http://127.0.0.1:1500/t
Webbench - Simple Web Benchmark 1.5
Copyright (c) Radim Kolar 1997-2004, GPL Open Source Software.
Benchmarking: GET http://127.0.0.1:1500/t
1000 clients, running 30 sec.
Speed=261244 pages/min, 95729 bytes/sec.
Requests: 130540 susceed, 82 failed.
linux socket创建tcp连接例子
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
using namespace std;
int main() {
int client;
/*
* socket函数的方法签名
* int socket (int __family, int __type, int __protocol)
* __family 定义协议族
* __type 定义数据传输方式/套接字类型
* __protocol 定义传输协议
*
* 返回值是文件描述符
*
* */
client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (client < 0) {
cout << "=> 连接失败" << endl;
}
/*
* 位于netinet/in.h
* 将套接字和IP、端口判断
*
* */
struct sockaddr_in server_addr{};
// 使用IPv4
server_addr.sin_family = AF_INET;
// 端口
server_addr.sin_port = htons(1500);
// IP地址
server_addr.sin_addr.s_addr = htons(INADDR_ANY);
/*
* struct sockaddr* 位于socket.h
* bind()签名
* int bind (int, const struct sockaddr *__my_addr, socklen_t __addrlen);
* 第一个参数：socket文件描述符
* 第二个参数：struct sockaddr*
* 第三个参数：struct sockaddr* 长度
* */
if (bind(client, (struct sockaddr *) &server_addr, sizeof(server_addr)) < 0) {
cout << "=> 绑定socket异常" << endl;
exit(1);
}
// 设置监听
listen(client, SOMAXCONN);
struct sockaddr_in client_addr{};
socklen_t client_addr_len = sizeof(client_addr);
int server;
while (true) {
server = accept(client, (struct sockaddr *) &client_addr, &client_addr_len);
if (server < 0) {
cout << "=> accept 错误" << endl;
exit(1);
}
// todo 写怎么接收数据
}
}