java socket通信I/O阻塞>多线程实现非阻塞通信

最新推荐文章于 2025-03-27 09:30:00 发布
最新推荐文章于 2025-03-27 09:30:00 发布
阅读量2.7k 收藏 3
点赞数 1
CC 4.0 BY-SA版权
分类专栏： java 文章标签： java socket 通信 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/heroboyluck/article/details/78416782
简单的java socket通信，多个客户端同时连接，功能可在此基础上进行扩展。效果如图：

客户机发送，服务端接收！

server：

package com.lb.LB_Socket;

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

public class myServer {
    private ServerSocket server;
    private Socket socket;
    private BufferedReader brin;
    private PrintWriter pw;
    private BufferedReader in ;
    private Boolean bool=true;

    public static void main(String args[]){
        myServer ms = new myServer();
        try {
            ms.onServer();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public void onServer() throws IOException{
        try{
            try{
                server = new ServerSocket(4440);
                System.out.println("服务器已启动!");
            }catch(Exception e){
                System.out.println("服务器未启动："+e);
            }
            while(true){
                try{
                    socket = server.accept();
                    System.out.println("客户端接入--");
                    bool=true;
                }catch(Exception e){
                    System.out.println("出错了 ："+e);
                }
                while(bool){
                    brin = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                    pw= new PrintWriter(socket.getOutputStream());
                    in= new BufferedReader(new InputStreamReader(System.in));


                        String content = brin.readLine();
                        System.out.println("客户端："+content);

                        if(content.equals("exit")){
                            pw.println("欢迎下次再来！");
                            pw.flush();

                            System.out.println("客户端退出！");
                            bool=false;
                        }


                    /*
                    String replay = in.readLine();
                    pw.println(replay);
                    pw.flush();
                    */

                }


            }   
        }catch(Exception e){
            System.out.println("Error:"+e);
        }finally{
            if(pw!=null){
                pw.close();
            }
            if(brin!=null){
                brin.close();
            }
            if(in!=null){
                in.close();
            }
            if(socket!=null){
                socket.close();
            }
            if(server!=null){
                server.close();
            }
        }
    }

}

服务器端(ServerSocket)：使用while（）死循环一直等待客户端的连接，在使用while（bool）循环接收客户端发送来的数据，如果客户端退出则等待下一个客户机的连接，

客户端：


package com.lb.LB_Socket;

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

public class myClient implements Runnable{
    private Socket socket;
    private BufferedReader brin;
    private PrintWriter pw;
    private BufferedReader in ;
    private Boolean bool = true;
    public static void main(String args[]) throws IOException{
        new Thread(new myClient()).start();

    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        try{
            socket = new Socket("192.168.30.36",4440);
            System.out.println("客户端启动成功！");
            try{
                while(bool){
                    in = new BufferedReader(new InputStreamReader(System.in));
                    pw = new PrintWriter(socket.getOutputStream());
                    brin = new BufferedReader(new InputStreamReader(socket.getInputStream()));


                        String readline;
                        readline = in.readLine();
                        //System.out.println(readline);

                        pw.println(readline);
                        pw.flush();

                        if(readline.equals("exit")){
                            in.close();
                            pw.close();
                            brin.close();
                            socket.close();

                            bool = false;
                        }



                        //System.out.println("服务器："+brin.readLine());  //服务器回复

                }

            }catch(SocketException e){
                if(socket==null){
                    System.out.println("断开连接！");
                }
            }catch(Exception e){
                e.printStackTrace();
                System.out.println("未开启服务器");
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

客户端（Socket）：发送数据，使用while（）循环当客户机在线时连续发送消息，发送exit时，销毁对象，退出连接。

想实现无阻塞通信，双端随时发送消息，但基本的socket通信就是你发一句我发一句，我发了你不发，我这边就处于等待接收状态，也就是阻塞。
  1. 就是利用线程，接收和发送是两个线程，互不干扰，随发随收；待实践。
  2. 非阻塞的通信机制。服务器程序接收客户连接、客户程序建立与服务器的连接，以及服务器程序和客户程序收发数据的操作都可以按非阻塞的方式进行。服务器程序只需要创建一个线程，就能完成同时与多个客户通信的任务。非阻塞的通信机制主要由java.nio包（新I/O包）中的类实现，主要的类包括ServerSocketChannel、SocketChannel、Selector、SelectionKey和ByteBuffer等。
初步实现利用线程解决非阻塞通信

看下效果：这里写图片描述

基本的想法就是把发送消息和接收打印消息作为单独的线程启动。直接贴代码了

sendMsg:

package com.lb.LB_Socket;

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

public class sendMsg implements Runnable {
    private DataOutputStream dos = null;
    //private DataInputStream dis = null;
    private Socket socket = null;
    private BufferedReader br =null ;
    private String name;
    private String content;
    boolean bool = true;

    public sendMsg(Socket socket,String name){
        //super();

        this.socket = socket;
        this.name = name;
    }
        @Override
        public void run() {
            // TODO Auto-generated method stub
            while(bool){
                try {
                    dos = new DataOutputStream(socket.getOutputStream());
                    br = new BufferedReader(new InputStreamReader(System.in));

                    content = br.readLine();
                    dos.writeUTF(name+"说:"+content);
                    if(content.equals("exit")){
                        dos.close();
                        br.close();
                        socket.close();
                        bool = false;
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                    bool=false;
                }

            }
        }
}

printMsg:

package com.lb.LB_Socket;

import java.io.DataInputStream;

import java.io.IOException;

import java.net.Socket;


public class printMsg implements Runnable {
    //private DataOutputStream dos = null;
    private DataInputStream dis = null;
    private Socket socket = null;
    private String content;
    boolean bool = true;

    //private String name;

    public printMsg(Socket socket){
        //super();

        this.socket = socket;
        //this.name = name;
    }
        @Override
        public void run() {
            // TODO Auto-generated method stub
            while(bool){
                try {
                    dis = new DataInputStream(socket.getInputStream());
                    content = dis.readUTF();
                    System.out.println(content);
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    bool=false;
                    e.printStackTrace();
                    //System.exit(1);
                }catch(Exception e){
                    bool = false;
                    e.printStackTrace();
                }
            }
        }       
}

server:

package com.lb.LB_Socket;

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

public class myServer implements Runnable{
    private boolean bool=true;

    Socket socket = null;
    ServerSocket server= null;

    public static void main(String args[]){
        new Thread(new myServer()).start();
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        try{
            try{
                server = new ServerSocket(4440);
                System.out.println("服务器已启动!");
            }catch(Exception e){
                System.out.println("服务器未启动："+e);
            }
            while(true){
                try{
                    socket = server.accept();
                    System.out.println("客户端接入--");
                    bool=true;
                }catch(Exception e){
                    System.out.println("出错了 ："+e);
                }
                sendMsg send = new sendMsg(socket,"服务器");
                printMsg print  = new printMsg(socket);
                Thread s= new Thread(send);
                Thread p = new Thread(print);

                if(send.bool == false || print.bool==false){
                    s.interrupt();
                    p.interrupt();
                }else{
                    s.start();
                    p.start();
                }

            }   
        }catch(Exception e){
            System.out.println("Error:"+e);
        }finally{
            try{
                if(socket!=null){
                    socket.close();
                }
                if(server!=null){
                    server.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }

        }

    }
}

client:

package com.lb.LB_Socket;

import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
public class myClient{

    public static void main(String args[]){
        try {
            Socket socket = new Socket("192.168.30.36",4440);
            System.out.println("客户端启动成功！");

            sendMsg send = new sendMsg(socket,"客户");
            printMsg print  = new printMsg(socket);
            Thread s= new Thread(send);
            Thread p = new Thread(print);

            if(send.bool == false || print.bool==false){
                p.interrupt();
                s.interrupt();
            }else{
                s.start();
                p.start();
            }
            //System.out.println(socket.isConnected());
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }   
    }
}

问题是线程的控制，当成功连接以后，互发消息，当某一方断掉后，线程就会打印错误。
1. 断掉客户端，服务端起的发送、接收流线程无法判定关闭，导致下次客户端连接后，会出现短暂的接收不到消息及错误信息打印。之后恢复正常。
2. 断掉服务器，客户端的发送、接收流线程无法判定关闭退出，打印连接错误信息。

如何控制socket的连接，监听socket连接的状态以供事件处理、关闭流。

还需多多学习，东西真的太多了。

Java中的异步非阻塞I/O操作
微赚开发者技术分享博客
07-28 390
异步非阻塞I/O（Asynchronous Non-Blocking I/O）是指在执行I/O操作时，不会阻塞线程。传统的阻塞I/O操作会让线程等待I/O操作完成，而异步非阻塞I/O则允许线程在等待I/O操作完成期间继续执行其他任务。NIO提供了强大的工具来处理高效的I/O操作，尤其是在高并发环境下，能够显著提升系统的性能和响应能力。此外，Java 7引入了NIO.2（Asynchronous I/O）的增强，进一步提升了异步I/O操作的能力。今天我们来探讨一下Java中的异步非阻塞I/O操作。
Java中的网络编程：如何高效实现多线程的Socket通信
微赚淘客系统开发者博客
08-14 1074
Socket允许程序在不同计算机之间通过网络进行通信。多线程Socket通信的基本思路是：服务器端在接受到客户端连接请求后，创建一个新的线程来处理该客户端的通信，从而使得服务器可以同时处理多个客户端连接。在本文中，我们将深入探讨如何在Java中实现多线程的Socket通信，并通过代码示例展示这种方法的实际应用。以下是一个简单的多线程Socket通信示例，演示如何使用Java实现一个支持多个客户端连接的服务器。当启动服务器并连接多个客户端时，服务器能够同时处理多个客户端的请求，并回显客户端发送的消息。
用Java实现非阻塞通信
热门推荐
lowZoom
05-30 1万+
用ServerSocket和Socket来编写服务器程序和客户程序，是Java网络编程的最基本的方式。这些服务器程序或客户程序在运行过程中常常会阻塞。例如当一个线程执行ServerSocket的accept()方法时，假如没有客户连接，该线程就会一直等到有了客户连接才从accept()方法返回。再例如当线程执行Socket的read()方法时，如果输入流中没有数据，该线程就会一直等到读入了足够的数
Windows Socket 非阻塞模式开发
系统运维
12-09 743
非阻塞套接字 非阻塞模式是指：套接字在执行操作时，调用的函数不管操作是否完成都会立即返回的工作模式。 非阻塞套接字在处理同时建立的多个连接等方面具有明显的优势。但是使用过程中有一定的难度。由于函数在操作没有完成后也仍然会返回，为了实现某些功能必须循环调用，直到完成功能为止。因此非阻塞模式会使程序效率非常低。 把套接字设置为非阻塞模式，即告诉系统：在调用WindowssocketAPI时...
Java网络编程——第十章 非阻塞I/O
WYCPhoenix的博客
06-10 890
使用非阻塞IO方式实现chargen收发协议 客户端 import java.io.IOException; import java.net.InetSocketAddress; import java.net.SocketAddress; import java.nio.ByteBuffer; import java.nio.channels.Channels; imp
java 非阻塞i o,使用Java（NIO API）中的非阻塞I / O发送消息
weixin_39849888的博客
02-25 76
I'm writing a server/client program that clients send text message to server.I have used non-blocking I/O (NIO API) but messages on the server do not display correctly.this is my code on server:privat...
Java Socket学习---nio实现阻塞多线程通信
06-01
本篇文章将深入探讨如何使用Java NIO（非阻塞I/O）来实现阻塞多线程通信，这对于高性能服务器端应用尤其重要。我们将会分析`EchoServer.java`、`EchoClient.java`和`SocketUtils.java`这三个文件中的关键知识点。 ...
读书笔记：C#网络编程与JAVA网络通信。TCP, UDP的Socket编程多线程阻塞非阻塞等。.zip
07-19
读书笔记：C#网络编程与JAVA网络通信。TCP, UDP的Socket编程多线程阻塞非阻塞等。
同步I/O、异步I/O、阻塞I/0、非阻塞I/O、五种I/O模型、高性能网络模型
loytuls的博客
03-19 1855
面试最常问问题之二：五种I/O模型及区别 ​
java Socket通信实现
06-06
- Java NIO（New I/O）库提供了非阻塞的Socket通信方式，提高了高并发场景下的性能。 - `java.nio.channels.SocketChannel`和`java.nio.channels.ServerSocketChannel`是NIO中的Socket实现。 9. **SSL/TLS安全套...
java scoket Blocking 阻塞IO socket通信一
weixin_34252090的博客
10-13 101
package bhz.bio; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; public class Server { final static int PROT = 8765; public static void ...
Java非阻塞I/O（NIO）详解
最新发布
03-27 842
非阻塞I/O（NIO）是Java中处理高并发网络编程的重要技术，它允许程序在等待I/O操作完成时继续执行其他任务。下面详细介绍Java非阻塞流的使用方法。
java scoket Blocking 阻塞IO socket通信四
weixin_33851429的博客
10-13 127
记住NIO在jdk1.7版本之前是同步非阻塞的，以前的inputsream是同步阻塞的，上面学习完成了Buffer现在我们来学习channel channel书双向的，以前阻塞的io的inputstream都是单向的 channel有四种连接状态 connect accept read write ，nio的核心基础就是selector package bhz.n...
Java简单实现Socket非阻塞通信
weixin_30423977的博客
03-01 1139
用java实现socket C/S通信很简单，很多教科书上都有。但是这些通信模型大都是阻塞式的，其弊端也很明显：一方必须要接收的到对方的消息后，才能编辑自己的消息发出。同样对方也要一直等待这条消息收到后才能发送新的消息。用网络通信的知识讲，大概就是半双工通信吧。这就好比聊天的时候，两个人只能一人一句的聊天。不能一个人连着发送多句话。 而要实现非阻塞通信呢，...
java 阻塞 socket_java socket非阻塞I/O
weixin_29689845的博客
02-12 446
1 非阻塞(Nonblocking)体系结构在这一部分，我将从理论的角度来解释非阻塞体系的结构及其工作原理。这部“喜剧”(当然，如果你喜欢的话也可以称做戏剧)的“人物”如下：●服务器端：接收请求的应用程序。●客户端：向服务器端发出请求的应用程序。●套接字通道：客户端与服务器端之间的通信通道。它能识别服务器端的ＩＰ地址和端口号。数据以Buffer中元素的形式通过套接字通道传送。●选择器：所...
深入理解Java NIO：非阻塞I/O的高效实现
weixin_34094559的博客
07-28 138
深入理解Java NIO：非阻塞I/O的高效实现 大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天，我们将深入探讨Java NIO（New I/O），了解其非阻塞I/O的高效实现及其应用。 一、Java NIO概述 Java NIO（New I/O）是Java 1.4中引入的一套新的I/O...
java socket 被阻塞了,java Socket 多线程阻塞server和client
weixin_39701735的博客
03-13 320
最近正在学习网络通信，简单的写了个TCP/IP的Socket连接。不多说直接上代码。server端：主函数​package com.yeban207.mainThread;​import java.io.IOException;import java.net.ServerSocket;import java.net.Socket;importcom.yeban207.userThread.Clie...
JAVA SOCKET编程 阻塞式IO 与 非阻塞式IO
smithdoudou88的专栏
08-05 1231
通常的，对一个文件描述符指定的文件或设备, 有两种工作方式: 阻塞 与非阻塞 。所谓阻塞方式的意思是指, 当试图对该文件描述符进行读写时, 如果当时没有东西可读,或者暂时不可写, 程序就进入等待 状态, 直到有东西可读或者可写为止。而对于非阻塞状态, 如果没有东西可读, 或者不可写, 读写函数马上返回, 而不会等待 。
Java 网络编程 —— 实现非阻塞式的服务器
低吟不作语的博客
05-20 1240
负责接收数据和发送数据的线程按照非阻塞模式工作，只有在读就绪或写就绪事件发生时，才执行相应的接收数据和发送数据操作。假如有许多客户请求连接，可以把接收客户连接的操作单独由一个线程完成，把接收数据和发送数据的操作由另一个线程完成，这可以提高服务器的并发性能。Accept 线程无法向 Selector 注册事件，而主线程没有任何事件可以监控，所以这两个线程将永远阻塞下去。都被设置为非阻塞模式，这使得接收连接、接收数据和发送数据的操作都采用非阻塞模式，注册了事件，并且该事件发生后，主线程才会从。
Java实现的单线程与多线程socket通信解析
在Java中，实现多线程socket通信可以采用继承Thread类、实现Runnable接口、使用线程池或利用并发包中提供的高级特性。需要注意的是，在多线程环境下，一定要处理好线程同步问题，确保数据的一致性和线程的安全。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

heroboyluck

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值