Socket與NIO方式的區別

Socket是最基礎的網絡編程技術，HttpURLConnection和HttpClient都是基於Socket的。下面來看一個從服務器端下載文件到客戶端的例子。

服務器端：

Java代碼

package org.huodong.action;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class FilmServer {
public static void main(String[] args) {
FilmServer ms = new FilmServer();
try {
ms.server();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 服務器端響應請求
標籤:
*
* @throws Exception
*/
public void server() throws Exception {
// 0.建立服務器端的server的socket
ServerSocket ss = new ServerSocket(8089);
while (true) {
// 1.打開socket連接
// 等待客戶端的請求
final Socket server = ss.accept(); //阻塞，一直等待直到有客戶端的請求過來，如果客戶端是兩個線程的話，那麼一定是一個線程的客戶端的連接關閉了才能接到另一個線程的客戶端的請求。
System.out.println("服務-----------請求開始start");
// 2.打開socket的流信息，準備下面的操作
final InputStream is = server.getInputStream();
byte b[] = new byte[1024];
int readCount = is.read(b);
String str = new String(b);
str = str.trim();
final String serverFileName = str;
// 3.對流信息進行讀寫操作
System.out.println("客戶端傳過來的信息是：" + str);
System.out.println("線程" + Thread.currentThread().getName() + "啓動");
try {
FileInputStream fileInputStream = new FileInputStream(
serverFileName);
OutputStream os = server.getOutputStream(); // 往客戶端寫文件
byte[] bfile = new byte[1024];
while (fileInputStream.read(bfile) > 0) {
os.write(bfile);
}
fileInputStream.close();
os.close();
// 4.關閉socket
// 先關閉輸入流
is.close();
// 最後關閉socket
server.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("服務-----------請求結束over");
}
}
}

package org.huodong.action;
import java.io.FileInputStream; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.net.ServerSocket; 
import java.net.Socket; 
public class FilmServer {
	
	public static void main(String[] args) {
		FilmServer ms = new FilmServer();
		try {
		ms.server();
		} catch (Exception e) {
		e.printStackTrace();
		}
		}

		/**
		* 服務器端響應請求 

		標籤: 

* 
* @throws Exception
*/
public void server() throws Exception {

// 0.建立服務器端的server的socket
ServerSocket ss = new ServerSocket(8089);

while (true) {

// 1.打開socket連接
// 等待客戶端的請求
final Socket server = ss.accept(); //阻塞，一直等待直到有客戶端的請求過來，如果客戶端是兩個線程的話，那麼一定是一個線程的客戶端的連接關閉了才能接到另一個線程的客戶端的請求。

System.out.println("服務-----------請求開始start");

// 2.打開socket的流信息，準備下面的操作
final InputStream is = server.getInputStream();
byte b[] = new byte[1024];

int readCount = is.read(b);

String str = new String(b);

str = str.trim();

final String serverFileName = str;

// 3.對流信息進行讀寫操作
System.out.println("客戶端傳過來的信息是：" + str);

System.out.println("線程" + Thread.currentThread().getName() + "啓動");

try {

FileInputStream fileInputStream = new FileInputStream(
serverFileName);


OutputStream os = server.getOutputStream();   // 往客戶端寫文件

byte[] bfile = new byte[1024];


while (fileInputStream.read(bfile) > 0) {
os.write(bfile);
}

fileInputStream.close();

os.close();

// 4.關閉socket
// 先關閉輸入流
is.close();

// 最後關閉socket
server.close();

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

System.out.println("服務-----------請求結束over");
}

}

}

客戶端：

Java代碼

package org.huodong.action;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Date;
public class FilmClient{
public static void main(String[] args) {
for (int i = 1; i <= 2; i++) {
Client client = new Client();
client.i = i;
client.start();
}
}
}
class Client extends Thread {
int i;
@Override
public void run() {
Date date = new Date();
// 1.建立scoket連接
Socket client;
try {
client = new Socket("127.0.0.1", 8089);
// 2.打開socket的流信息，準備下面的操作
OutputStream os = client.getOutputStream();
// 3.寫信息
os.write(("d://film//音樂.rar").getBytes()); //這個是服務器端的文件地址
String filmName = "e://io"+i+".rar"; //這是要下載到客戶端的地址及文件名,這裏相當於下載了兩遍2.rmvb，只不過保存在客戶端的時候起了兩個不同的文件名，方便比較
FileOutputStream fileOutputStream = new FileOutputStream(filmName);
System.out.println("Time="+date.getTime());
InputStream is = client.getInputStream();// 接收服務器端的文件並寫到客戶端,這裏會一直等服務器端發消息過來，如果服務器sleep10秒才發送過來，客戶端也會一直等，
// 這就導致整個線程都會阻塞在這裏
byte b[] = new byte[1024];
while(is.read(b)>0){
fileOutputStream.write(b);
}
// 4.關閉socket
// 先關閉輸出流
os.close();
// 最後關閉socket
client.close();
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("Time1="+date.getTime());
}
}

package org.huodong.action;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Date;
public class FilmClient{


	public static void main(String[] args) {
	for (int i = 1; i <= 2; i++) {
	Client client = new Client();
	client.i = i;
	client.start();
	}
	}
	}

	class Client extends Thread {

	int i;

	@Override
	public void run() {
	
		Date date = new Date();
	
	// 1.建立scoket連接
	Socket client;
	try {
	client = new Socket("127.0.0.1", 8089);

	// 2.打開socket的流信息，準備下面的操作
	OutputStream os = client.getOutputStream();

	// 3.寫信息
	os.write(("d://film//音樂.rar").getBytes());   //這個是服務器端的文件地址

	String filmName = "e://io"+i+".rar";  //這是要下載到客戶端的地址及文件名,這裏相當於下載了兩遍2.rmvb，只不過保存在客戶端的時候起了兩個不同的文件名，方便比較

	FileOutputStream fileOutputStream = new FileOutputStream(filmName);


	System.out.println("Time="+date.getTime());
	InputStream is = client.getInputStream();// 接收服務器端的文件並寫到客戶端,這裏會一直等服務器端發消息過來，如果服務器sleep10秒才發送過來，客戶端也會一直等，
                                             // 這就導致整個線程都會阻塞在這裏
	byte b[] = new byte[1024];

	while(is.read(b)>0){
	fileOutputStream.write(b);
	}

	// 4.關閉socket
	// 先關閉輸出流
	os.close();

	// 最後關閉socket
	client.close();
	} catch (UnknownHostException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
	} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
	}
	System.out.println("Time1="+date.getTime());
	}

	}

客戶端啓動了2個線程進行下載電影的工作，先啓動服務端，再運行客戶端，會看筆者本地的硬盤C分區到有如下效果。

可以看到線程2的下載任務一直是0字節，等第一個線程下載完成後呢，線程2的下載任務才能進行。

服務端的代碼造成的問題就是使用傳統的sokect網絡通訊，那麼另一個客戶端的線程請求到server端的時候就發生了阻塞的情況，也就是說，服務端相當一個廁所，廁所就有隻有一個坑位，來了一個人，相當於客戶端請求，那這個人相當於就把坑位給佔了，write操作和read操作會阻塞，這個人還沒解決完問題呢，下個人就來了，沒辦法，哥們兒先在門外等等啊，等前一個客戶爽完了再給您提供服務好吧。那麼如何解決這個佔着坑位不讓別人用的情況呢？

3. 阻塞的多線程
爲了解決以上問題，那麼之後很多Server肯定不可能像以上程序那麼做，不過以前很多Server都是基於單線程服務改造一下，做成多線程的Server的通訊，修改一下上面的Server代碼，如下

Java代碼

package org.huodong.action;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 以上的Server就是在原始的socket基礎上加了線程，每一個Client請求過來後，整個Server主線程不必處於阻塞狀態，
* 接收請求後直接另起一個新的線程來處理和客戶端的交互，就是往客戶端發送二進制包。這個在新線程中雖然阻塞，
* 但是對於服務主線程沒有阻塞的影響，主線程依然通過死循環監聽着客戶端的一舉一動。
* 另一個客戶端的線程發起請求後就再起一個新的線程對象去爲客戶端服務。
*/
public class FilmServerNewThread {
public static void main(String[] args) {
FilmServerNewThread ms = new FilmServerNewThread();
try {
ms.server();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 服務器端響應請求
*
* @throws Exception
*/
public void server() throws Exception {
// 0.建立服務器端的server的socket
ServerSocket ss = new ServerSocket(8089);
while (true) {
// 1.打開socket連接
// 等待客戶端的請求
final Socket server = ss.accept();
System.out.println("服務-----------請求開始start");
// 2.打開socket的流信息，準備下面的操作
final InputStream is = server.getInputStream();
byte b[] = new byte[1024];
int readCount = is.read(b);
String str = new String(b);
str = str.trim();
final String serverFileName = str;
// 3.對流信息進行讀寫操作
System.out.println("客戶端傳過來的信息是：" + str);
if (readCount > 0) {
new Thread() {
@Override
public void run() {
System.out.println("線程"
+ Thread.currentThread().getName() + "啓動");
try {
FileInputStream fileInputStream = new FileInputStream(
serverFileName);
// 3.1 服務器回覆客戶端信息(response)
OutputStream os = server.getOutputStream();
byte[] bfile = new byte[1024];
// 往客戶端寫
while (fileInputStream.read(bfile) > 0) {
os.write(bfile);
}
fileInputStream.close();
os.close();
// 4.關閉socket
// 先關閉輸入流
is.close();
// 最後關閉socket
server.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}.start();
}
System.out.println("服務-----------請求結束over");
}
}
}

package org.huodong.action;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
* 以上的Server就是在原始的socket基礎上加了線程，每一個Client請求過來後，整個Server主線程不必處於阻塞狀態，
* 接收請求後直接另起一個新的線程來處理和客戶端的交互，就是往客戶端發送二進制包。這個在新線程中雖然阻塞，
* 但是對於服務主線程沒有阻塞的影響，主線程依然通過死循環監聽着客戶端的一舉一動。
* 另一個客戶端的線程發起請求後就再起一個新的線程對象去爲客戶端服務。
*/
public class FilmServerNewThread {

public static void main(String[] args) {
FilmServerNewThread ms = new FilmServerNewThread();
try {
ms.server();
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 服務器端響應請求
* 
* @throws Exception
*/
public void server() throws Exception {

// 0.建立服務器端的server的socket
ServerSocket ss = new ServerSocket(8089);

while (true) {

// 1.打開socket連接
// 等待客戶端的請求
final Socket server = ss.accept();

System.out.println("服務-----------請求開始start");

// 2.打開socket的流信息，準備下面的操作
final InputStream is = server.getInputStream();
byte b[] = new byte[1024]; 
int readCount = is.read(b);

String str = new String(b);

str = str.trim();

final String serverFileName = str;

// 3.對流信息進行讀寫操作
System.out.println("客戶端傳過來的信息是：" + str);

if (readCount > 0) {
new Thread() {

@Override
public void run() {

System.out.println("線程"
+ Thread.currentThread().getName() + "啓動");

try {

FileInputStream fileInputStream = new FileInputStream(
serverFileName);

// 3.1 服務器回覆客戶端信息(response)
OutputStream os = server.getOutputStream();

byte[] bfile = new byte[1024];

// 往客戶端寫
while (fileInputStream.read(bfile) > 0) {
os.write(bfile);
}

fileInputStream.close();

os.close();

// 4.關閉socket
// 先關閉輸入流
is.close();

// 最後關閉socket
server.close(); 
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}.start();
}

System.out.println("服務-----------請求結束over");
}

}
}

執行效果如下

2個線程互不影響，各自下載各自的。當然從非常嚴格的意義來講，str變量在十分高併發的情況下有線程安全問題，這個咱暫且忽略，就着眼於低併發的情況。這個問題是什麼呢，就是如果客戶端請求比較多了，那麼爲每一個客戶端開闢一個新的線程對象來處理網絡傳輸的請求，需要創建個線程對象，而且這個線程對象從時間上來講還是處於長連接，這個就比較消費系統資源，這個打開進程管理器就可以看到。而且每一個線程內部都是阻塞的，也沒有說完全利用好這個新創建的線程。還拿剛纔上廁所舉例子，好比現在不止一個坑位了，來了一個用戶我這邊就按照工程師的廁所坑位圖建立一個新的坑位，客戶來了，不用等待老坑位，用新創建的坑位就行了。等那個老坑位用完了，自然有垃圾回收器去消滅那個一次性的坑位的，騰出資源位置爲了建立新的坑位。長時間連接的意思，相當於這個人上廁所的時間非常長，便祕？？需要拉一天才能爽完……老的坑位一時半會兒回收不了，新的坑位需要有空間爲其建造茅房以便滿足客戶端的“急切方便”需要。久而久之，線程數目一多，系統就掛了的概率就增多了（誰也別想上，全玩完了）。

NIO方式與BIO（Socket)的方式的最大區別就是NIO是一請求一線程，而BIO是一連接一線程，後者就導致如果服務器未來得及響應客戶端就要一直等一直等，該連接就一直佔用着這個線程。如果是NIO的話則可以複用連接，也就是無須等待服務器端的響應就可以繼續給服務器端發送消息，發送和接收是異步響應的。

Socket與NIO方式的區別

985 碩士程序員，空窗 4 個月沒有 Offer！

一文搞懂 Spring 循環依賴

賽博鬥地主——使用大語言模型扮演Agent智能體玩牌類遊戲。

VScode右鍵打開(添加到右鍵)

記一次 .NET某工控視覺自動化系統卡死分析

MyEclipse下配置Websphere6

存儲過程

下載

ORACLE存儲過程簡明教程

test

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結