java Socket网络通信 BIO NIO AIO

最新推荐文章于 2021-06-16 09:06:57 发布
最新推荐文章于 2021-06-16 09:06:57 发布
阅读量317 收藏
点赞数 1
分类专栏： Java Java 后台开发 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dopamy_BusyMonkey/article/details/79760108
版权

目录

1、BIO

2、NIO

3、AIO

 

1、BIO

同步阻塞IO，一个线程处理一个连接，发起和处理IO请求都是同步的

package com.busy.server;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class BioServer {

    public static void main(String[] args) throws IOException {  
        ServerSocket serverSocket = new ServerSocket(10101);  
        System.out.println("服务器启动!");  
        while (true){  
            Socket socket = serverSocket.accept();  
            System.out.println("来了一个新客户端！");  
            //业务处理  
            handler(socket); // 若客户端不主动断开socket，就会阻塞在handler->while
        }
    }  
  
    /** 
     * 读取数据 
     * @param socket 
     */  
    private static void handler(Socket socket){  
    	String clientCode = null;
        try{  
            byte[] bytes = new byte[1]; 
            byte[] headByte = new byte[3];
            InputStream inputStream = socket.getInputStream();
            int infoHead = inputStream.read(headByte);
            clientCode = new String(headByte,0,infoHead);
            while (true) {
                //读取数据 阻塞  
                int read = 0;
                try {
                	read = inputStream.read(bytes);                  	
                } catch (IOException e) {
                	inputStream.close();
                	inputStream = null;
                	System.out.println("客户端主"+clientCode+"动断开socket");
                	break;
                }
                if(read != -1 && read != 0){  
                    System.out.println("客户端"+clientCode+"发来消息"+new String(bytes,0,read));
                    Thread.sleep(2000);
                }else{  
                    break;  
                }  
            }  
        }catch (Exception ex){  
        	
        }finally {  
            try{  
                System.out.println("客户端"+clientCode+"socket关闭");  
                socket.close();
            }catch (Exception ex){  
                ex.printStackTrace();  
            }  
        }  
    }  
}

package com.busy.server;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class BioClientA {
	public static void main(String[] args) {
		send("[A]12345678");
	}
	
    //默认的端口号  
    private static int DEFAULT_SERVER_PORT = 10101;  
    private static String DEFAULT_SERVER_IP = "127.0.0.1";  
    public static void send(String expression){  
        send(DEFAULT_SERVER_PORT,expression);  
    }  
    public static void send(int port,String expression){   
        Socket socket = null;  
        BufferedReader in = null;  
        PrintWriter out = null;  
        try{  
            socket = new Socket(DEFAULT_SERVER_IP,port);  
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
            out = new PrintWriter(socket.getOutputStream(),true);  
            out.println(expression);
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            //一下必要的清理工作  
            if(in != null){  
                try {  
                    in.close();  
                } catch (IOException e) {
                    e.printStackTrace();  
                }  
                in = null;  
            }  
            if(out != null){  
                out.close();  
                out = null;  
            }  
            if(socket != null){  
                try {  
                    socket.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
                socket = null;  
            }  
        }  
    }
}

服务端异步接收socket请求（改main为下）【相当于同步非阻塞，同NIO对比，只是每次要开线程，CPU开销大】：

    public static void main(String[] args) throws IOException { 
    	ExecutorService newCashedThreadPool = Executors.newCachedThreadPool();
        ServerSocket serverSocket = new ServerSocket(10101);  
        System.out.println("服务器启动!");  
        while (true){  
            final Socket socket = serverSocket.accept();  
            System.out.println("来了一个新客户端！");  
            //业务处理  
            //handler(socket); // 若客户端不主动断开socket，就会阻塞在handler->while
            newCashedThreadPool.execute(new Runnable() {  
                @Override  
                public void run() {  
                    //业务处理  
                    handler(socket);  
                }  
            });
        }
    }

2、NIO

同步非阻塞IO，一个线程处理多个链接，发起IO请求是非阻塞的，处理IO请求是同步的（轮询）

package com.busy.server;

import java.io.IOException;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class NIOServer {
	private Selector selector; // 创建一个选择器
	private final static int port = 8686;
	private final static int BUF_SIZE = 1;

	private void initServer() throws IOException {
		// 创建通道管理器对象selector
		this.selector = Selector.open();
		// 创建一个通道对象channel
		ServerSocketChannel channel = ServerSocketChannel.open();
		channel.configureBlocking(false); // 将通道设置为非阻塞
		// channel.configureBlocking(true); // 将通道设置为阻塞
		channel.socket().bind(new InetSocketAddress(port)); // 将通道绑定在8686端口
		// 将上述的通道管理器和通道绑定，并为该通道注册OP_ACCEPT事件
		// 注册事件后，当该事件到达时，selector.select()会返回（一个key），如果该事件没到达selector.select()会一直阻塞
		SelectionKey selectionKey = channel.register(selector, SelectionKey.OP_ACCEPT); // 阻塞通道不能注册

		while (true) { // 轮询
			//handler(channel.socket().accept()); // 阻塞通道接收
			selector.select(); // 这是一个阻塞方法，一直等待直到有数据可读，返回值是key的数量（可以有多个）
			Set keys = selector.selectedKeys(); // 如果channel有数据了，将生成的key访入keys集合中
			Iterator iterator = keys.iterator(); // 得到这个keys集合的迭代器
			while (iterator.hasNext()) { // 使用迭代器遍历集合
				SelectionKey key = (SelectionKey) iterator.next(); // 得到集合中的一个key实例
				iterator.remove(); // 拿到当前key实例之后记得在迭代器中将这个元素删除，非常重要，否则会出错
				if (key.isAcceptable()) { // 判断当前key所代表的channel是否在Acceptable状态，如果是就进行接收
					doAccept(key);
				} else if (key.isReadable()) {
					doRead(key);
				} else if (key.isWritable() && key.isValid()) {
					doWrite(key);
				} else if (key.isConnectable()) {
					System.out.println("连接成功！");
				}
			}
		}
	}

	public void doAccept(SelectionKey key) throws IOException {
		ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
		System.out.println("ServerSocketChannel正在循环监听");
		SocketChannel clientChannel = serverChannel.accept();
		clientChannel.configureBlocking(false);
		clientChannel.register(key.selector(), SelectionKey.OP_READ);
	}

	public void doRead(SelectionKey key) throws IOException {
		try {
			SocketChannel clientChannel = (SocketChannel) key.channel();
			ByteBuffer byteBuffer = ByteBuffer.allocate(BUF_SIZE);
			long bytesRead = clientChannel.read(byteBuffer);
			while (bytesRead > 0) {
				byteBuffer.flip();
				byte[] data = byteBuffer.array();
				String info = new String(data).trim();
				System.out.println("从客户端发送过来的消息是：" + info);
				Thread.sleep(2000);
				byteBuffer.clear();
				bytesRead = clientChannel.read(byteBuffer);
			}
			if (bytesRead == -1) {
				clientChannel.close();
			}
		} catch (Exception ex) {

		}
	}

	public void doWrite(SelectionKey key) throws IOException {
		ByteBuffer byteBuffer = ByteBuffer.allocate(BUF_SIZE);
		byteBuffer.flip();
		SocketChannel clientChannel = (SocketChannel) key.channel();
		while (byteBuffer.hasRemaining()) {
			clientChannel.write(byteBuffer);
		}
		byteBuffer.compact();
	}

	/**
	 * 读取数据
	 * 
	 * @param socket
	 */
	private static void handler(Socket socket) {
		String clientCode = null;
		try {
			byte[] bytes = new byte[1];
			InputStream inputStream = socket.getInputStream();
			while (true) {
				// 读取数据 阻塞
				int read = 0;
				try {
					read = inputStream.read(bytes);
				} catch (IOException e) {
					inputStream.close();
					inputStream = null;
					System.out.println("客户端主" + clientCode + "动断开socket");
					break;
				}
				if (read != -1 && read != 0) {
					System.out.println("客户端" + clientCode + "发来消息" + new String(bytes, 0, read));
					Thread.sleep(2000);
				} else {
					break;
				}
			}
		} catch (Exception ex) {

		} finally {
			try {
				System.out.println("客户端" + clientCode + "socket关闭");
				socket.close();
			} catch (Exception ex) {
				ex.printStackTrace();
			}
		}
	}

	public static void main(String[] args) throws IOException {
		NIOServer myNioServer = new NIOServer();
		myNioServer.initServer();
	}
}

package com.busy.server;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class NIOClientA {
    private Selector selector;          //创建一个选择器
    private final static int port = 8686;
    private final static int BUF_SIZE = 10240;
    private static ByteBuffer byteBuffer = ByteBuffer.allocate(BUF_SIZE);

    private void  initClient() throws IOException {
        this.selector = Selector.open();
        SocketChannel clientChannel = SocketChannel.open();
        clientChannel.configureBlocking(false);
        clientChannel.connect(new InetSocketAddress(port));
        clientChannel.register(selector, SelectionKey.OP_CONNECT);
        while (true){
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                iterator.remove();
                if (key.isConnectable()){
                    doConnect(key);
                }else if (key.isReadable()){
                    doRead(key);
                }
            }
        }
    }

    public void doConnect(SelectionKey key) throws IOException {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        if (clientChannel.isConnectionPending()){
            clientChannel.finishConnect();
        }
        clientChannel.configureBlocking(false);
        String info = "12345678";
        byteBuffer.clear();
        byteBuffer.put(info.getBytes("UTF-8"));
        byteBuffer.flip();
        clientChannel.write(byteBuffer);
        //clientChannel.register(key.selector(),SelectionKey.OP_READ);
        clientChannel.close();
    }

    public void doRead(SelectionKey key) throws IOException {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        clientChannel.read(byteBuffer);
        byte[] data = byteBuffer.array();
        String msg = new String(data).trim();
        System.out.println("服务端发送消息："+msg);
        clientChannel.close();
        key.selector().close();
    }

    public static void main(String[] args) throws IOException {
        NIOClientA myNioClient = new NIOClientA();
        myNioClient.initClient();
    }
}

在单线程BIO中，如果前一个请求正在接收执行中，第二个请求将不会接收到；

在单线程NIO中，如果前一个请求正在接收执行中，之后的请求将会按顺序接收；

channel.configureBlocking(false); 如果设置为阻塞，则channel不能被注册，同样可以跟BIO一样来处理请求

用：handler(channel.socket().accept()); // 阻塞通道接收

3、AIO

异步非阻塞IO，一个有效请求一个线程，发起和处理IO请求都是异步的。

package com.busy.server;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class AIOServer {
	public final static int PORT = 8001;
	public final static String IP = "127.0.0.1";
	private int countMsg = 0;

	private AsynchronousServerSocketChannel server = null;

	public AIOServer() {
		try {
			// 同样是利用工厂方法产生一个通道，异步通道 AsynchronousServerSocketChannel
			server = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(IP, PORT));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 使用这个通道(server)来进行客户端的接收和处理
	public void start() {
		System.out.println("Server listen on " + PORT);
		// 注册事件和事件完成后的处理器，这个CompletionHandler就是事件完成后的处理器
		server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
			
			@Override
			public void completed(AsynchronousSocketChannel result, Object attachment) {
				ByteBuffer buffer = ByteBuffer.allocate(1024);
				//System.out.println(Thread.currentThread().getName());
				Future<Integer> writeResult = null;
				try {
					buffer.clear();
					result.read(buffer).get(10000, TimeUnit.SECONDS);
					countMsg ++;
					System.out.println("msg:"+countMsg +", In server: " +  new String(buffer.array()) );
					Thread.sleep(100);
					// 将数据写回客户端
					buffer.flip();
					writeResult = result.write(buffer);
				} catch (InterruptedException | ExecutionException | TimeoutException e) {
					e.printStackTrace();
				} finally {
					server.accept(null, this);
					try {
						writeResult.get();
						result.close();
					} catch (IOException e) {
						e.printStackTrace();
					} catch (InterruptedException | ExecutionException e) {
						e.printStackTrace();
					}
				}
			}

			@Override
			public void failed(Throwable exc, Object attachment) {
				System.out.println("failed:" + exc);
			}
		});
	}

	public static void main(String[] args) {
		new AIOServer().start();
		while (true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

package com.busy.server;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class AIOSimpleServer {
	static final int PORT = 8001;

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

		// ①创建AsynchronousServerSocketChannel对象。
		AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open();

		// ②指定在指定地址、端口监听。
		serverChannel.bind(new InetSocketAddress(PORT));
		int countMsg = 0;
		while (true) {
			ByteBuffer buffer = ByteBuffer.allocate(1024);
			buffer.clear();
			// ③采用循环接受来自客户端的连接
			Future<AsynchronousSocketChannel> future = serverChannel.accept();
			// 获取连接完成后返回的AsynchronousSocketChannel
			AsynchronousSocketChannel socketChannel = future.get();
			socketChannel.read(buffer).get(100, TimeUnit.SECONDS);
			countMsg++;
			System.out.println("msg:" + countMsg + ", In server: " + new String(buffer.array()));
			Thread.sleep(200);
			// 执行输出。
			socketChannel.write(ByteBuffer.wrap("欢迎你来自AIO的世界！".getBytes("UTF-8"))).get();
		}
	}
}

package com.busy.server;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

public class AIOClientA {
	
	static private int count = 0;  
	private InetSocketAddress serverAddress = null;
	private AsynchronousSocketChannel client = null;
	
	public AIOClientA() {
		try {
			serverAddress = new InetSocketAddress("127.0.0.1", 8001);
			client = AsynchronousSocketChannel.open();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public void sendMsg() {
		count ++;
		client.write(ByteBuffer.wrap(("100【"+count).getBytes()));
	}
	
	public void connServer() {
		CompletionHandler<Void, ? super Object> handler = new CompletionHandler<Void, Object>() {

			@Override
			public void completed(Void result, Object attachment) {
				sendMsg();
			}

			@Override
			public void failed(Throwable exc, Object attachment) {
			}
			
		};
		client.connect(serverAddress, null, handler);
	}

	public static void main(String[] args) throws IOException {
		
		int i = 100;
		while (i -- > 0) {
			System.out.println(i);
			new AIOClientA().connServer();
			try {
				Thread.sleep(20);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		while (true) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

对与服务端延迟接收，会出现丢包，客户端已经全部发送了？？？？why

BusyMonkey
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
final Socket socket = serverSocket.accept()；
滕青山博客
01-29 793
Tomcat与Java Web开发技术详解中 try { final Socket socket = serverSocket.accept(); } 这里socket已经用了final表示不可变了，为什么还可以连接多个客户端？ 原因： 块作用域，其实加不加不影响，作者加上可能是为了表示一次只能处理一个请求。 ...
Java网络编程精解之ServerSocket用法详解一
轻轻草原
10-25 1766
第3章 ServerSocket用法详解 第10章 Java语言的反射机制 第13章 基于MVC和RMI的分布 ServerSocket用法详解一 Java语言的反射机制一 基于MVC和RMI的分布式应用一 ServerSocket用法详解二 Java语言的反射机制二 基于M...
Java中BIO、NIO、AIO详解
JSai的博客
08-07 3637
一、Java中IO模型简介 在Java中，主要有三种IO模型，分别是： 同步阻塞IO（BIO） 同步非阻塞IO（NIO） 异步IO（AIO） 两个概念： 同步与异步 同步：同步就是发起一个调用后，被调用者未处理完请求之前，调用不返回。 异步： 异步就是发起一个调用后，立刻得到被调用者的回应表示已接收到请求，但是被调用者并没有返回结果，此时我们可以处理其他的请求，被调用者通常依靠事件，回调等机...
详解Java中的BIO、NIO、AIO
Java鱼仔的博客
06-16 4078
IO流是Java中比较难理解的一个知识点，但是IO流在实际的开发场景中经常会使用到，比如Dubbo底层就是NIO进行通讯
java BIO/NIO/AIO 学习
weixin_34088598的博客
05-08 387
一、了解Unix网络编程5种I/O模型 1.1、阻塞式I/O模型 阻塞I/O(blocking I/O）模型，进程调用recvfrom，其系统调用直到数据报到达且被拷贝到应用进程的缓冲区中或者发生错误才返回。进程从调用recvfrom开始到它返回的整段时间内是被阻塞的。 1.2、非阻塞式I/O模型 当一个应用进程像这样对一个非阻塞描述字循环调用recvfrom时，我们称之为轮询（polling...
一站式学习Java网络编程 全面理解BIO:NIO:AIO1
08-08
Socket 是网络通信的端点，提供了进程间通信的基础。Socket 可以分为 TCP Socket 和 UDP Socket 两种，前者提供了可靠的连接，后者提供了不可靠的连接。 Unix 中的 Socket 是一种特殊的文件描述符，提供了进程间...
java BIO NIO AIO
07-18
连接成功后，双方通过网络套接字（Socket）进行通信。在 BIO 模式下，客户端和服务端是完全同步的，完全藕合的。 Java NIO Java NIO（Non-Blocking I/O）是一种同步非阻塞式的 I/O 模式，服务器实现模式为一个线程...
基于java的BIO、NIO、AIO通讯模型代码实现
03-24
Java作为一门广泛使用的开发语言，提供了多种I/O（Input/Output）通信模型，包括传统的阻塞I/O（BIO）、非阻塞I/O（NIO）以及异步I/O（AIO）。这些通信模型在不同的场景下有着各自的优势，理解和掌握它们对于优化...
SocketIO-BIO-NIO-AIO.zip
07-16
Socket是Java进行网络通信的基础，通过Socket，我们可以建立客户端与服务器之间的连接，进行数据交换。 总结来说，这个压缩包提供了一个学习和理解Java中不同I/O模型的起点，尤其是对于希望提升服务器性能或处理高...
详解Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）
08-28
Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码） Java 网络IO编程是 Java 编程语言中最重要的知识点之一，涉及到网络编程的各种技术和模型。本篇文章主要介绍了 Java 网络IO编程总结，包括 BIO、NIO 和 AIO ...
Java中网络IO的实现方式（BIO、NIO、AIO）介绍
08-31
"Java中网络IO的实现方式（BIO、NIO、AIO）介绍" Java中网络IO的实现方式是指在Java语言中实现网络输入/输出操作的方法。根据不同的实现方式，可以分为三种：BIO（Blocking I/O）、NIO（Non-Blocking I/O）和AIO...
aio_bio_nio.rar
08-22
Java网络通信中，AIO（Asynchronous Input/Output）、BIO（Blocking I/O）和NIO（Non-blocking I/O）是三种不同的I/O模型，它们各自有着不同的特性和适用场景。下面将详细介绍这三个概念以及它们在Java中的实现。 *...
java网络编程源码-java-IO:java网络编程BIO，NIO,AIO源码示例
05-20
Java网络编程是Java开发中的重要组成部分，主要用于实现应用程序之间的通信。在Java中，有三种主要的I/O模型：BIO（Blocking I/O），NIO（Non-blocking I/O）和AIO（Asynchronous I/O）。这些模型各有特点，适用于...
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析
最新发布
01-04
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析 IO模型在计算机编程中扮演着至关重要的角色，特别是在网络通信中。Java提供了三种主要的IO模型：BIO（Blocking IO），NIO（Non-blocking IO），...
Java_IO:你不知道的那些Java网络IO（BIO、NIO、AIO）
05-18
本文将深入探讨Java中的三种网络IO模型：同步阻塞IO（BIO）、同步非阻塞IO（NIO）和异步非阻塞IO（AIO），以及它们在实际应用中的差异和应用场景。 1. **同步阻塞IO（BIO）** BIO是Java最初提供的IO模型，它基于...
java aio事件模型_Java三种IO模型原理实例详解
weixin_30794381的博客
02-13 1198
Java中IO的模型分为三种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。BIO【同步阻塞】在JDK1.4出来之前，我们建立网络连接的时候采用BIO模式，需要先在服务端启动一个ServerSocket，然后在客户端启动Socket来对服务端进行通信，默认情况下服务端需要对每个请求建立一堆线程等待请求，而客户端发送请求后，先咨询服务端是否有线程相应，如果没有则会一直等待或者遭到拒绝请求...
java的BIO,NIO,AIO的区别和用法
jaryle的专栏
07-06 3371
java网络io编程，从传统的BIO（同步阻塞）到NIO（同步非阻塞）再到AIO（异步非阻塞）. 场景：客户端想服务端发送请求，服务端会为每个客户端建立一个线程来响应，问题来了，如果客户端出现了延时等异常，多是网络异常，这样的话，服务端的为它建立的线程，一直处于等待状态，这样这个线程就会占用很长时间（因为数据的准备和读取都在这个线程上完成），更糟糕的情况是，如果此时有大量的并发访问，服务
同步、异步、阻塞、非阻塞 I/O 及 异步I/O实现
Quentin的专栏
10-11 2620
<br />同步、异步、阻塞、非阻塞 I/O<br /> <br />第一部分来自：<br />http://blog.csdn.net/historyasamirror/archive/2010/07/31/5778378.aspx<br /> <br />Stevens在文章中一共比较了五种IO Model：<br />    blocking IO<br />    nonblocking IO<br />    IO multiplexing<br />    signal driven IO<br
ServerSocket 用法详解
Mr. David 专栏
11-19 2830
<br />在客户/服务器通信模式中，服务器端需要创建监听特定端口的ServerSocket，ServerSocket负责接收客户连接请求。本章首先介绍ServerSocket类的各个构造方法，以及成员方法的用法，接着介绍服务器如何用多线程来处理与多个客户的通信任务。<br />本章提供线程池的一种实现方式。线程池包括一个工作队列和若干工作线程。服务器程序向工作队列中加入与客户通信的任务，工作线程不断从工作队列中取出任务并执行它。本章还介绍了java.util.concurrent包中的线程池类的用法，在服
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值