一步一步实现bio聊天室

最新推荐文章于 2024-08-20 11:45:05 发布
最新推荐文章于 2024-08-20 11:45:05 发布
阅读量10w+ 收藏 2
点赞数
分类专栏： 高性能编程 IO BIO 文章标签： 网络编程 BIO IO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hu10131013/article/details/107842308
版权

BIO概念

Java BIO (blocking I/O)： 同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销

使用场景

BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解。 

 

 聊天室

  •  需要一个服务端
  • 一个或多个客户端

  服务端

  • 当前服务端可以接收客户端数据
  • 同时能够向客户端写入数据
package com.milla.study.netbase.expert.netty.io.bio;

import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Description: <服务端>
 * @Author: milla
 * @CreateDate: 2020/08/06 15:47
 * @UpdateUser: milla
 * @UpdateDate: 2020/08/06 15:47
 * @UpdateRemark: <>
 * @Version: 1.0
 */
@Slf4j
public class Server {
    public static void main(String[] args) throws IOException {
        server();
    }

    private static void server() throws IOException {
        //启动服务指定端口
        ServerSocket server = new ServerSocket(10010);
        //接收进来一个客户端
        Socket client = server.accept();
        //获取客户端的输入流-获取客户端数据
        BufferedReader reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
        //获取客户端输出流-将数据写向客户端
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
        String requestLine;
        while ((requestLine = reader.readLine()) != null) {
            log.info("客户端:{} ,数据：{}", client, requestLine);
            writer.write(requestLine);
            //刷新流数据
            writer.flush();
        }
        //关闭资源
        reader.close();
        server.close();
    }
}

客户端

 

package com.milla.study.netbase.expert.netty.io.bio;

import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.UUID;

/**
 * @Description: <客户端>
 * @Author: milla
 * @CreateDate: 2020/08/06 15:52
 * @UpdateUser: milla
 * @UpdateDate: 2020/08/06 15:52
 * @UpdateRemark: <>
 * @Version: 1.0
 */
@Slf4j
public class Client {
    public static void main(String[] args) throws IOException {
        client();
    }

    private static void client() throws IOException {
        //创建一个客户端
        Socket client = new Socket();
        //连接指定的的服务地址及端口
        client.connect(new InetSocketAddress("localhost", 10010));
        //获取一个输出流-向服务写入数据
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
        //随机的uuid数据
        writer.write(UUID.randomUUID().toString());
        //刷新数据并关闭资源
        writer.flush();
        //接收信息
        getMessage(client);
        writer.close();
        client.close();
    }

    private static void getMessage(Socket client) {
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(client.getInputStream()));

            String line;
            while (!client.isClosed() && (line = reader.readLine()) != null) {
                log.info("接收到的数据为：{}", line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

#  启动之后服务端是可以收到数据的

16:23:36.534 [main] INFO com.milla.study.netbase.expert.netty.io.bio.Server - 服务启动中.......
16:23:46.970 [main] INFO com.milla.study.netbase.expert.netty.io.bio.Server - 服务接收到一个连接： Socket[addr=/127.0.0.1,port=49600,localport=10010]
# 此时会有个问题，就是当客户端关闭的时候，服务端也会自动关闭，所以需要对服务端进行改进

改进后代码

package com.milla.study.netbase.expert.netty.io.bio;

import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Description: <服务端>
 * @Author: milla
 * @CreateDate: 2020/08/06 15:47
 * @UpdateUser: milla
 * @UpdateDate: 2020/08/06 15:47
 * @UpdateRemark: <>
 * @Version: 1.0
 */
@Slf4j
public class Server {
    public static void main(String[] args) throws IOException {
        server();
    }

    private static void server() throws IOException {
        log.info("服务启动中.......");
        //启动服务指定端口
        ServerSocket server = new ServerSocket(10010);
        //只要服务端不关闭，那么就一直执行
        while (!server.isClosed()) {
            BufferedReader reader = null;
            try {
                //接收进来一个客户端
                Socket client = server.accept();
                log.info("服务接收到一个连接： {}", client);

                //获取客户端的输入流-获取客户端数据
                reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
                //获取客户端输出流-将数据写向客户端
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
                String requestLine;
                while (!client.isInputShutdown() && (requestLine = reader.readLine()) != null) {
                    log.info("客户端:{} ,数据：{}", client, requestLine);
                    writer.write(requestLine);
                    writer.newLine();
                    //刷新流数据
                    writer.flush();
                }
            } catch (IOException e) {
                log.error("Exception");
            } finally {
                //关闭资源
                if (reader != null) {
                    reader.close();
                }
            }
        }
        server.close();
    }
}

# 此时发现客户端只能发送数据，实际并不能接收数据
# 原因是因为bio中获取输入流和输出流都是阻塞的，所以，使用两个线程进行读写，解决该问题
package com.milla.study.netbase.expert.netty.io.bio;

import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.UUID;

/**
 * @Description: <客户端>
 * @Author: milla
 * @CreateDate: 2020/08/06 15:52
 * @UpdateUser: milla
 * @UpdateDate: 2020/08/06 15:52
 * @UpdateRemark: <>
 * @Version: 1.0
 */
@Slf4j
public class Client {
    public static void main(String[] args) throws IOException {
        client();
    }

    private static void client() throws IOException {
        //创建一个客户端
        Socket client = new Socket();
        //连接指定的的服务地址及端口
        client.connect(new InetSocketAddress("localhost", 10010));
        //异步发送信息
        new Thread(() -> sendMessage(client), "send").start();
        //接收信息
        getMessage(client);
        client.close();
    }

    private static void sendMessage(Socket client) {
        try {
            //获取输出流-写向服务端
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
            //写一个随机字符串
            writer.write(UUID.randomUUID().toString());
            writer.newLine();
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void getMessage(Socket client) {
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(client.getInputStream()));

            String line;
            while (!client.isClosed() && (line = reader.readLine()) != null) {
                log.info("接收到的数据为：{}", line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

# 数据不能是随机的数据，需要用户自定义的数据，那就是用Scanner输入流进行模拟吧
package com.milla.study.netbase.expert.netty.io.bio;

import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.Scanner;

/**
 * @Description: <客户端>
 * @Author: milla
 * @CreateDate: 2020/08/06 15:52
 * @UpdateUser: milla
 * @UpdateDate: 2020/08/06 15:52
 * @UpdateRemark: <>
 * @Version: 1.0
 */
@Slf4j
public class Client {
    public static void main(String[] args) throws IOException {
        client();
    }

    private static void client() throws IOException {
        //创建一个客户端
        Socket client = new Socket();
        //连接指定的的服务地址及端口
        client.connect(new InetSocketAddress("localhost", 10010));
        //异步发送信息
        new Thread(() -> sendMessage(client), "send").start();
        //接收信息
        getMessage(client);
        client.close();
    }

    private static void sendMessage(Socket client) {
        try {
            //获取输出流-写向服务端
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
            Scanner scanner = new Scanner(System.in);
            String requestLine = null;
            //当输出quit的时候，代表客户端要下线，不再进行通信了
            while (!"quit".equals(requestLine)) {
                System.out.println("输入<》：");
                //获取一行数据
                requestLine = scanner.nextLine();
                writer.write(requestLine);
                writer.newLine();
                writer.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void getMessage(Socket client) {
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(client.getInputStream()));

            String line;
            while (!client.isClosed() && (line = reader.readLine()) != null) {
                log.info("接收到的数据为：{}", line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

# 那么此时就可以考虑多客户端问题了，但是将client复制以后会发现，实际上server并不能识别

# 原因很简单，client.getOutputStream()是阻塞的，没有处理完不会退出

# 所以采用线程池来解决这个问题

 

package com.milla.study.netbase.expert.netty.io.bio;

import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Description: <服务端>
 * @Author: milla
 * @CreateDate: 2020/08/06 15:47
 * @UpdateUser: milla
 * @UpdateDate: 2020/08/06 15:47
 * @UpdateRemark: <>
 * @Version: 1.0
 */
@Slf4j
public class Server {
    public static void main(String[] args) throws IOException {
        server();
    }

    private static void server() throws IOException {
        //创建一个线程池，-最多能处理33个连接
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 30, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(3), (a, b) -> System.out.println("自定义"));
        log.info("服务启动中.......");
        //启动服务指定端口
        ServerSocket server = new ServerSocket(10010);
        //只要服务端不关闭，那么就一直执行
        while (!server.isClosed()) {

            Socket client = server.accept();
            pool.submit(() -> getClient(client));
        }
        server.close();
    }

    private static void getClient(Socket client) {
        BufferedReader reader = null;
        try {
            //接收进来一个客户端
            log.info("服务接收到一个连接： {}", client);

            //获取客户端的输入流-获取客户端数据
            reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
            //获取客户端输出流-将数据写向客户端
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
            String requestLine;
            while (!client.isInputShutdown() && (requestLine = reader.readLine()) != null) {
                log.info("客户端:{} ,数据：{}", client, requestLine);
                writer.write(requestLine);
                writer.newLine();
                //刷新流数据
                writer.flush();
            }
        } catch (IOException e) {
            log.error("Exception");
        } finally {
            //关闭资源
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

# 此时已经可以处理多个连接
17:01:58.246 [pool-1-thread-1] INFO com.milla.study.netbase.expert.netty.io.bio.Server - 服务接收到一个连接： Socket[addr=/127.0.0.1,port=50837,localport=10010]
17:02:11.825 [pool-1-thread-2] INFO com.milla.study.netbase.expert.netty.io.bio.Server - 服务接收到一个连接： Socket[addr=/127.0.0.1,port=50850,localport=10010]
# 优化服务端保存连接信息
package com.milla.study.netbase.expert.netty.io.bio;

import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Description: <服务端>
 * @Author: milla
 * @CreateDate: 2020/08/06 15:47
 * @UpdateUser: milla
 * @UpdateDate: 2020/08/06 15:47
 * @UpdateRemark: <>
 * @Version: 1.0
 */
@Slf4j
public class Server {
    /**
     * 存储客户端信息
     */
    private static final Map<Socket, Object> clients = new ConcurrentHashMap<>(100);

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

        server();
    }

    private static void server() throws IOException {
        //创建一个线程池，-最多能处理33个连接
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 30, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(3), (a, b) -> System.out.println("自定义"));
        log.info("服务启动中.......");
        //启动服务指定端口
        ServerSocket server = new ServerSocket(10010);
        //只要服务端不关闭，那么就一直执行
        while (!server.isClosed()) {

            Socket client = server.accept();
            // value可以是以后需要统计信息，这里暂时使用client对象
            clients.putIfAbsent(client, client);
            pool.submit(() -> getClient(client));
        }
        server.close();
    }

    private static void getClient(Socket client) {
        BufferedReader reader = null;
        try {
            //接收进来一个客户端
            log.info("服务接收到一个连接： {}", client);

            //获取客户端的输入流-获取客户端数据
            reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
            //获取客户端输出流-将数据写向客户端
            String requestLine;
            while (!client.isInputShutdown() && (requestLine = reader.readLine()) != null) {
                if ("quit".equals(requestLine)) {
                    log.info("客户端： {}，退出连接", client);
                    clients.remove(client);
                    break;
                }
                senderMessages2Clients(requestLine, client);
                log.info("客户端：{} 数据为：{}", client, requestLine);
            }
        } catch (IOException e) {
            log.error("Exception");
        } finally {
            //关闭资源
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static void senderMessages2Clients(String line, Socket socket) {
        if (clients.isEmpty()) {
            return;
        }
        Set<Map.Entry<Socket, Object>> entries = clients.entrySet();

        entries.stream().filter(item -> !item.getKey().isClosed()).forEach((item -> {
            Socket client = item.getKey();
            try {
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
                writer.write(socket.getPort() + " - " + line);
                writer.newLine();
                writer.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }));
    }
}

# 至此，开多个客户端，客户端就可以进行通信了
package com.milla.study.netbase.expert.netty.io.bio;

import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Description: <服务端>
 * @Author: milla
 * @CreateDate: 2020/08/06 15:47
 * @UpdateUser: milla
 * @UpdateDate: 2020/08/06 15:47
 * @UpdateRemark: <>
 * @Version: 1.0
 */
@Slf4j
public class Server {
    /**
     * 存储客户端信息
     */
    private static final Map<Socket, Object> clients = new ConcurrentHashMap<>(100);

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

        server();
    }

    private static void server() throws IOException {
        //创建一个线程池，-最多能处理33个连接
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 30, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(3), (a, b) -> System.out.println("自定义"));
        log.info("服务启动中.......");
        //启动服务指定端口
        ServerSocket server = new ServerSocket(10010);
        //只要服务端不关闭，那么就一直执行
        while (!server.isClosed()) {

            Socket client = server.accept();
            // value可以是以后需要统计信息，这里暂时使用client对象
            clients.putIfAbsent(client, client);
            pool.submit(() -> getClient(client));
        }
        server.close();
    }

    private static void getClient(Socket client) {
        BufferedReader reader = null;
        try {
            //接收进来一个客户端
            log.info("服务接收到一个连接： {}", client);

            //获取客户端的输入流-获取客户端数据
            reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
            //获取客户端输出流-将数据写向客户端
            String requestLine;
            while (!client.isInputShutdown() && (requestLine = reader.readLine()) != null) {
                if ("quit".equals(requestLine)) {
                    log.info("客户端： {}，退出连接", client);
                    clients.remove(client);
                    break;
                }
                senderMessages2Clients(requestLine, client);
                log.info("客户端：{} 数据为：{}", client, requestLine);
            }
        } catch (IOException e) {
            log.error("Exception");
        } finally {
            //关闭资源
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static void senderMessages2Clients(String line, Socket socket) {
        if (clients.isEmpty()) {
            return;
        }
        Set<Map.Entry<Socket, Object>> entries = clients.entrySet();

        entries.stream().filter(item -> !item.getKey().isClosed()).forEach((item -> {
            Socket client = item.getKey();
            try {
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
                writer.write(socket.getPort() + " - " + line);
                writer.newLine();
                writer.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }));
    }
}

效果图

  

完整代码 

服务端

 

package com.milla.study.netbase.expert.netty.io.bio;

import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Description: <服务端>
 * @Author: milla
 * @CreateDate: 2020/08/06 15:47
 * @UpdateUser: milla
 * @UpdateDate: 2020/08/06 15:47
 * @UpdateRemark: <>
 * @Version: 1.0
 */
@Slf4j
public class Server {
    /**
     * 存储客户端信息
     */
    private static final Map<Socket, Object> clients = new ConcurrentHashMap<>(100);

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

        server();
    }

    private static void server() throws IOException {
        //创建一个线程池，-最多能处理33个连接
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 30, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(3), (a, b) -> System.out.println("自定义"));
        log.info("服务启动中.......");
        //启动服务指定端口
        ServerSocket server = new ServerSocket(10010);
        //只要服务端不关闭，那么就一直执行
        while (!server.isClosed()) {

            Socket client = server.accept();
            // value可以是以后需要统计信息，这里暂时使用client对象
            clients.putIfAbsent(client, client);
            pool.submit(() -> getClient(client));
        }
        server.close();
    }

    private static void getClient(Socket client) {
        BufferedReader reader = null;
        try {
            //接收进来一个客户端
            log.info("服务接收到一个连接： {}", client);

            //获取客户端的输入流-获取客户端数据
            reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
            //获取客户端输出流-将数据写向客户端
            String requestLine;
            while (!client.isInputShutdown() && (requestLine = reader.readLine()) != null) {
                if ("quit".equals(requestLine)) {
                    log.info("客户端： {}，退出连接", client);
                    clients.remove(client);
                    client.shutdownInput();
                    client.shutdownOutput();
                    break;
                }
                senderMessages2Clients(requestLine, client);
                log.info("客户端：{} 数据为：{}", client, requestLine);
            }
        } catch (IOException e) {
            log.error("Exception");
        } finally {
            //关闭资源
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static void senderMessages2Clients(String line, Socket socket) {
        if (clients.isEmpty()) {
            return;
        }
        Set<Map.Entry<Socket, Object>> entries = clients.entrySet();

        entries.stream().filter(item -> !item.getKey().isClosed()).forEach((item -> {
            Socket client = item.getKey();
            try {
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
                writer.write(socket.getPort() + " - " + line);
                writer.newLine();
                writer.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }));
    }
}

客户端

package com.milla.study.netbase.expert.netty.io.bio;

import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.Scanner;

/**
 * @Description: <客户端>
 * @Author: milla
 * @CreateDate: 2020/08/06 15:52
 * @UpdateUser: milla
 * @UpdateDate: 2020/08/06 15:52
 * @UpdateRemark: <>
 * @Version: 1.0
 */
@Slf4j
public class Client {
    public static void main(String[] args) throws IOException {
        client();
    }

    private static void client() throws IOException {
        //创建一个客户端
        Socket client = new Socket();
        //连接指定的的服务地址及端口
        client.connect(new InetSocketAddress("localhost", 10010));
        //异步发送信息
        new Thread(() -> sendMessage(client), "send").start();
        //接收信息
        getMessage(client);
        client.close();
    }

    private static void sendMessage(Socket client) {
        try {
            //获取输出流-写向服务端
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
            Scanner scanner = new Scanner(System.in);
            String requestLine = null;
            //当输出quit的时候，代表客户端要下线，不再进行通信了
            while (!"quit".equals(requestLine)) {
                System.out.println("输入<》：");
                //获取一行数据
                requestLine = scanner.nextLine();
                writer.write(requestLine);
                writer.newLine();
                writer.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void getMessage(Socket client) {
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(client.getInputStream()));

            String line;
            while (!client.isClosed() && (line = reader.readLine()) != null) {
                log.info("聊天数据：{}", line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

Netty 框架的源码与使用
AI天才研究院
07-29 1104
Netty是一个开源的、高性能、异步通信框架。它提供了许多强大的功能，使开发人员能够快速开发出健壮、高吞吐量的网络应用。在Java领域，Netty是最流行、最知名的网络库之一，被多款知名公司如Twitter、Facebook、阿里巴巴等使用，并因此而广受关注。本文将从基础知识入手，带您了解 Netty 的工作机制、优点、缺点、架构及使用方法。为了更好地理解 Netty 的工作原理，本文先简要回顾一下 TCP/IP协议族的相关知识。
BIO实现简易的聊天室
sjtu_big_pig的博客
12-14 258
代码主要分为4个部分： 1 服务器端 ChartServer 2 客户端 ChartClient 3 当客户端给服务器端发送请求时，服务器端要给每一个提出请求的客户端分配一个线程ChartHandle 3 客户端需要有两个线程，主线程负责读取键盘输入，第二个线程负责读取其他客户端发过来的信息UserInputHandle，就像微信聊天时，一个线程是接受你的输入，同时别人说的话你也可以收到，互不影响...
基于BIO的的多人聊天室，
06-16
基于BIO的多人聊天室，使用了多线程技术，比如 CountDownLatch 和线程池等技术， 以udp为辅，tcp为主, 对于tcp服务器端：客户端的消息读写是双通道的，互不影响
BIO聊天室【仅做笔记参考】
L12131415L的博客
02-17 210
Client: package socket; import java.io.*; import java.net.Socket; import java.nio.charset.StandardCharsets; import java.util.Scanner; /** * 聊天室客户端 */ public class Client { /** * java.net.Socket 套接字 * Socket封装了TCP协议的通讯细节，我们使用他可以与远端计算机建立TCP
IO-BIO实现聊天室
尹忠政的博客
01-12 934
IO-BIO实现聊天室(Socket全双工) 概述 本次实现的是一个聊天室，使用的是TCP/IP协议，使用自定义传输协议。多个客户端连接上服务端，客户端发送消息到服务端，服务端将客户端加入到客户端队列，通过loop队列，向所有的客户端转发消息。此处转发为同步转发，意味着先加入的客户端将优先收到消息。当客户端离线的时候，服务端将从队列中移除，并且终止针对该客户端的轮询。 流程图 服务端 获取客...
BIO多人聊天室
weixin_48829840的博客
09-22 113
本篇文字，我主要讲解BIO的多人聊天室 BIO编程模型 服务器端设计：首先有一个accept做一个接收的工作，用主线程来接收。（创建服务端和客户端的连接）在服务器中创建线程负责与客户端进行读写服务，也就是handler线程。为了让服务器可以接收多个客户端发送过来的请求，并且和多个客户端进行交流，我们的主线程为每一个客户端创建一个与之对应的handler线程，一对一的关系。因为这是一个多人聊天室，所以，我们需要存储目前在线的用户集合 客户端设计：可以和服务器建立连接进行数据交换，接收客户文本输入（阻塞）是一个
BIO聊天室(群聊+私聊)
mazouri的博客
05-10 383
功能:群聊+私发+上线提醒+下线提醒+查询在线用户 文件UtilsFinalValueMessageServerClientReceiveSend Utils FinalValue Message Server Client Receive Send package moremorechat_bio; import java.io.Closeable; public class Utils { /** * 关闭流 * @param targets */ pu
手动搭建I/O网络通信框架4：AIO编程模型，聊天室终极改造
耶low的博客
04-17 354
第一章：手动搭建I/O网络通信框架1：Socket和ServerSocket入门实战，实现单聊 第二章：手动搭建I/O网络通信框架2：BIO编程模型实现群聊 第三章：手动搭建I/O网络通信框架3：NIO编程模型，升级改造聊天室 　　上一章讲到的NIO编程模型比较主流，非常著名的Netty就是基于NIO编程模型的。这一章说的是AIO编程模型，是异步非阻塞的。虽然同样实现的是聊天室功能，但是...
BIO、NI、AI、O、多路复用，一文读懂IO知识
lt_xiaodou的博客
10-05 1390
在前面咱们详细叙述了 Linux 五种 IO 模型以及 Java 所提供的三种 IO 模型支持，对于 Java-IO 这块内容，阻塞、非阻塞、同步、异步等这些区别就不再聊了，认真看下来本文后自然会有答案，最后是需要重点表明一点：NIO、AIO 都是单线程处理多个连接，但并不代表着说永远只有一条线程对网络连接进行处理，这里所谓的单线程处理多个连接，其实本质上是指单条线程接收客户端连接。Java-BIO ：当客户端到来连接请求时，就会分配一条线程处理。
从理论到实践网络编程模型：（BIO、NIO、AIO）同步与异步模型的原理与应用 （六）
最新发布
Solidao的博客
08-20 1199
万变不离其宗，io服务器和客户端的交互,做一个小型的客服是足够的，实际生产中是需求产生代码，学习的时候想法驱动代码，加油。：当前的服务器代码是单线程的，这意味着只能同时处理一个客户端的请求。为了实现一个可与多个客户端并发交互的聊天室，我们需要为每个连接创建一个新的线程。：在等待输入时，服务器会被阻塞，无法响应其他客户端的请求，这导致了潜在的性能瓶颈。：随着连接的增加，服务器的响应时间可能会显著增加，不能满足高并发请求的需求。来处理多个用户的聊天信息。接口，每当有新的客户端连接时，主线程会创建一个新的。
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（六）
好想去看海
09-30 682
文章目录1. NIO模型分析2.聊天室项目代码重点知识2.1 服务器端2.1.1 字段2.1.2 主方法2.1.3 处理方法2.1.4 转发消息方法2.1.5 接收消息方法2.2 客户端2.2.1 字段2.2.2 主方法2.2.3 处理方法2.2.4 接收方法2.2.5 发送方法3. 测试结果4. 完整代码4.1 服务器端4.2 客户端4.3 客户端监听用户输入进程 1. NIO模型分析 在服务器端创建一个Selector，将ServerSocketChannel注册到Selector上，被Selec
BIO实现一个聊天室
一年半
01-29 363
BIO实现一个聊天室 需要实现一个客户端的消息可以发送给所有客户端去接受。(群聊的实现）（B站黑马程序员里的代码） 客户端代码 package BIO_instantmassging.client; import BIO_instantmassging.util.Constants; import javax.swing.*; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener;
java-chat-room 聊天室基于Bio
weiyang的博客
10-25 379
Client import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.Socket; public class ClientBio { //相当于自定义协议格式，与客户端协商好 private static Strin...
Java网络编程-Socket编程初涉二（基于BIO模型的简易多人聊天室）
kaven
02-03 1149
Java网络编程-Socket编程初涉二（基于BIO模型的简易多人聊天室） 要求 我们要实现一个基于BIO模型的简易多人聊天室，不能像上一个版本一样（Java网络编程-Socket编程初涉一（简易客户端-服务器）），当服务器与某个客户端连接成功后，它们在进行数据交互过程中，其他客户端的连接请求，服务器是不会响应的，我们这里要使用BIO模式来改善这一点。 所谓多人聊天室，就是某个用户发送的消息，其他...
创建BIO多人聊天室
迷路人的博客
06-16 248
创建多人聊天室： 使用的是 阻塞式模型，这里只涉及多人聊天，不涉及 一对一聊天，使用了多线程. 接收数据时：要将换行符丢弃。 2台以上设备如何交互数据？ 1.约定一个基础的数据格式：使用回车换行符作为信息的截断。 2. 客户端 - 服务器 - 转发到 客户端 【三者及以上，用户1 发送信息到服务器，服务器遍历其他的客户端，将该消息通知到其他客户端上】 1.客户端： 首先使用 UDP 广播，获取 tcp 服务器的端口号和IP地址， 然后进行 tcp 的...
javaBIO之实现一个聊天室（2）
Fujie1997的博客
03-09 304
上篇简单实现了回音壁，但是这也太不够意思了，如果可以多人发言那就稍微有点意思了。 这里先来说说java BIO 编程模型。 BIO也就是我们经常说的java IO,在这种传统的模式下，如果要实现服务端服务， 1.首先他要等待客户端连接吧？ 执行serverSocket.accept();会一直阻塞在这句话这里，直到有客户端连接才会做其他的事情。 2.那么如何做到服务多个客户端呢？ 我们采用新开一个...
IO-BIO聊天室升级版
尹忠政的博客
01-13 260
IO-BIOl聊天室升级版 存在的问题 当处理线程池达到最大线程的时候，那么后面的客户端将无法发送消息，这个是致命的。 新思路 该架构的优点 解决了之前版本在线程池达到最大线程数的时候，服务端将不能在处理新加入的客户端，除非客户端掉线，线程才有机会去处理。 该版本支持大规模的客户端在线服务。 通过接管了客户端input监听，能更好控制线程数，维持机器的良好新能，可控。 项目架构 Serve...
从BIO到实现简单多人聊天室功能--IO模型
m0_52410356的博客
07-21 534
从BIO到实现简单多人聊天室功能
【移动开发】WIFI热点通信（二）
weixin_34150503的博客
08-10 220
相信大家在上一篇中已经了解了Android中WIFI热点通信的相关操作知识（http://smallwoniu.blog.51cto.com/3911954/1536126），今天我们将在上一篇代码基础之上进行Socket编程，实现一个简单的多人聊天室功能，以达到热点网络上的通信目的。首先，我们先来看一张最终效果图：<=======>(说明：由...
多线程支撑的多人BIO聊天室技术解析
在介绍基于BIO的多人聊天室的相关知识点之前，首先需要对BIO（Blocking I/O，阻塞I/O）模型有所了解。BIO模型是一种传统的I/O模型，在这种模型中，客户端发送请求后，服务端会阻塞等待I/O操作完成，直到数据准备好...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值