Comment gérer les connexions simultanées dans la programmation réseau Java ?

Il existe deux manières de gérer les connexions simultanées dans la programmation réseau Java : Pool de threads : créez un pool de threads pré-créé et géré et obtenez des threads du pool de threads pour gérer la connexion lorsque le client se connecte. Sélecteur NIO : traite plusieurs connexions dans un seul thread lorsque le client se connecte ou que les données sont lisibles, l'événement est déclenché puis traité.

Gestion des connexions simultanées dans la programmation réseau Java

Dans la programmation réseau Java, la gestion des connexions simultanées est cruciale. Les connexions simultanées se produisent lorsqu'une application gère plusieurs clients qui y accèdent en même temps.

Thread Pool

Une méthode courante de traitement simultané consiste à utiliser un pool de threads. Un pool de threads est un groupe de threads pré-créé et géré. Lorsqu'un client se connecte, un thread peut être obtenu à partir du pool de threads pour gérer la connexion. Cela empêche la création de nouveaux threads pour chaque connexion, économisant ainsi des ressources.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class ThreadPoolServer {

    public static void main(String[] args) {
        // 创建一个线程池，指定线程数
        ExecutorService threadPool = Executors.newFixedThreadPool(10);

        // 创建ServerSocket监听端口
        ServerSocket serverSocket = new ServerSocket(8080);

        while (true) {
            // 等待客户端连接
            Socket clientSocket = serverSocket.accept();

            // 从线程池中获取一个线程处理客户端连接
            threadPool.execute(new ClientHandler(clientSocket));
        }
    }

    private static class ClientHandler implements Runnable {

        private Socket clientSocket;

        public ClientHandler(Socket clientSocket) {
            this.clientSocket = clientSocket;
        }

        @Override
        public void run() {
            // 处理客户端连接
            try {
                // 获取客户端输入
                BufferedReader reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                String line = reader.readLine();
                
                // 向客户端发送响应
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()));
                writer.write("HTTP/1.1 200 OK\n");
                writer.flush();
                
                // 关闭连接
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

NioSelector

Une autre option pour gérer les connexions simultanées consiste à utiliser NIO Selector. NIO Selector permet de gérer plusieurs connexions dans un seul thread. Le sélecteur déclenche des événements lorsque le client se connecte ou que les données sont lisibles.

import java.io.IOException;
import java.net.InetSocketAddress;
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;

class NioServer {

    public static void main(String[] args) throws IOException {
        // 创建ServerSocketChannel监听端口
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(8080));

        // 设置ServerSocketChannel为非阻塞模式
        serverSocketChannel.configureBlocking(false);

        // 创建Selector
        Selector selector = Selector.open();

        // 将ServerSocketChannel注册到Selector的ACCEPT事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            // 阻塞等待事件发生
            selector.select();

            // 获取发生的事件
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = keys.iterator();

            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();

                // 处理ACCEPT事件
                if (key.isAcceptable()) {
                    SocketChannel socketChannel = serverSocketChannel.accept();

                    // 设置SocketChannel为非阻塞模式
                    socketChannel.configureBlocking(false);

                    // 将SocketChannel注册到Selector的READ事件
                    socketChannel.register(selector, SelectionKey.OP_READ);
                } 

                // 处理READ事件
                else if (key.isReadable()) {
                    // 处理客户端连接
                    handleClientConnection(key);
                }
            }
        }
    }

    private static void handleClientConnection(SelectionKey key) throws IOException {
        SocketChannel socketChannel = (SocketChannel) key.channel();

        // 获取客户端输入
        BufferedReader reader = new BufferedReader(new InputStreamReader(socketChannel.socket().getInputStream()));
        String line = reader.readLine();

        // 向客户端发送响应
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socketChannel.socket().getOutputStream()));
        writer.write("HTTP/1.1 200 OK\n");
        writer.flush();

        // 取消注册Selector的事件
        key.cancel();

        // 关闭连接
        socketChannel.close();
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!