您好,登录后才能下订单哦!
密码登录
登录注册
点击 登录注册 即表示同意《亿速云用户服务条款》
在Java网络编程中,处理并发是一个关键问题,因为服务器通常需要同时处理多个客户端的请求。以下是一些常见的并发处理策略:
最简单的方法是为每个客户端连接创建一个新的线程。这种方法简单直观,但在高并发场景下可能会导致资源耗尽。
import java.io.*;
import java.net.*;
public class SimpleServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8080);
while (true) {
Socket clientSocket = serverSocket.accept();
new Thread(new ClientHandler(clientSocket)).start();
}
}
}
class ClientHandler implements Runnable {
private Socket clientSocket;
public ClientHandler(Socket socket) {
this.clientSocket = socket;
}
@Override
public void run() {
try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
String inputLine;
while ((inputLine = in.readLine()) != null) {
out.println("Echo: " + inputLine);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
使用线程池可以更有效地管理线程资源,避免频繁创建和销毁线程的开销。
import java.io.*;
import java.net.*;
import java.util.concurrent.*;
public class ThreadPoolServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8080);
ExecutorService executorService = Executors.newFixedThreadPool(10);
while (true) {
Socket clientSocket = serverSocket.accept();
executorService.submit(new ClientHandler(clientSocket));
}
}
}
class ClientHandler implements Runnable {
private Socket clientSocket;
public ClientHandler(Socket socket) {
this.clientSocket = socket;
}
@Override
public void run() {
try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
String inputLine;
while ((inputLine = in.readLine()) != null) {
out.println("Echo: " + inputLine);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
NIO提供了更高效的I/O操作方式,通过选择器(Selector)可以管理多个通道(Channel),从而实现单线程处理多个客户端连接。
import java.io.*;
import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.*;
public class NIOServer {
public static void main(String[] args) throws IOException {
Selector selector = Selector.open();
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.bind(new InetSocketAddress(8080));
serverSocketChannel.configureBlocking(false);
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
selector.select();
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> iter = selectedKeys.iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
if (key.isAcceptable()) {
handleAccept(key, selector);
} else if (key.isReadable()) {
handleRead(key);
}
iter.remove();
}
}
}
private static void handleAccept(SelectionKey key, Selector selector) throws IOException {
ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
SocketChannel clientChannel = serverSocketChannel.accept();
clientChannel.configureBlocking(false);
clientChannel.register(selector, SelectionKey.OP_READ);
}
private static void handleRead(SelectionKey key) throws IOException {
SocketChannel clientChannel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = clientChannel.read(buffer);
if (bytesRead > 0) {
buffer.flip();
byte[] data = new byte[buffer.remaining()];
buffer.get(data);
String request = new String(data).trim();
System.out.println("Received: " + request);
ByteBuffer responseBuffer = ByteBuffer.wrap(("Echo: " + request).getBytes());
clientChannel.write(responseBuffer);
} else if (bytesRead == -1) {
clientChannel.close();
}
}
}
Reactor模式是一种事件驱动的设计模式,通过一个或多个线程来处理事件,适用于高并发场景。
import java.io.*;
import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.*;
import java.util.concurrent.*;
public class ReactorServer {
private Selector selector;
private ExecutorService executorService;
public ReactorServer(int port) throws IOException {
selector = Selector.open();
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.bind(new InetSocketAddress(port));
serverSocketChannel.configureBlocking(false);
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
executorService = Executors.newFixedThreadPool(10);
}
public void start() {
while (true) {
try {
selector.select();
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> iter = selectedKeys.iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
if (key.isAcceptable()) {
handleAccept(key);
} else if (key.isReadable()) {
key.interestOps(key.interestOps() & ~SelectionKey.OP_READ);
executorService.submit(() -> handleRead(key));
}
iter.remove();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
private void handleAccept(SelectionKey key) throws IOException {
ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
SocketChannel clientChannel = serverSocketChannel.accept();
clientChannel.configureBlocking(false);
clientChannel.register(selector, SelectionKey.OP_READ);
}
private void handleRead(SelectionKey key) {
SocketChannel clientChannel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
try {
int bytesRead = clientChannel.read(buffer);
if (bytesRead > 0) {
buffer.flip();
byte[] data = new byte[buffer.remaining()];
buffer.get(data);
String request = new String(data).trim();
System.out.println("Received: " + request);
ByteBuffer responseBuffer = ByteBuffer.wrap(("Echo: " + request).getBytes());
clientChannel.write(responseBuffer);
} else if (bytesRead == -1) {
clientChannel.close();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
key.interestOps(key.interestOps() | SelectionKey.OP_READ);
key.selector().wakeup();
}
}
public static void main(String[] args) throws IOException {
ReactorServer server = new ReactorServer(8080);
server.start();
}
}
选择哪种并发处理策略取决于具体的应用场景和需求。对于简单的应用,多线程模型可能已经足够;而对于高并发场景,NIO或Reactor模式可能更为合适。
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。