JAVA多进程服务器与客户机实现收发异步

最新推荐文章于 2021-02-27 15:03:31 发布
最新推荐文章于 2021-02-27 15:03:31 发布
阅读量525 收藏
点赞数
分类专栏： java 文章标签： java 服务器 buffer 异步 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011491972/article/details/52652639
版权

核心： 非阻塞NIO的使用，发送和接收使用不同的Buffer
icesongqiang

  • java

客户端类

/** 
*************************************************************
* 1. 客户端采用阻塞模式接入服务器                                                            
* 2. 接入后使用NIO事件机制一直查询可以读或者写的事件---主进程                                                 
* 3. 写入的数据 = 要传数据，也跟随主线程一直运行，但是写的内容可以由用户自己决定:                                    
* *3.1.  使用send_data(String data)将用户数据写入sendBuffer中                                                    
* *3.2.  在主线程检测可以写的时候，调用send(SelectionKey key)函数
*  把sendBuffer中的内容写入该key关联的SocketChannel中
* 4. 读数据 ： 跟随主线程一直运行，可以读就直接读                                                                 
*******************参考java网络编程精解 例程4-4 ***************
************************************** -- [icesongqiang]
*****
*/
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
import java.net.*;
import java.util.*;                // for Set

class EchoClient{
    /**
     * Selector类, 只要ServerSocketChannel及SocketChannel向
     * Selector 注册了特定的事件，Selector类就会监控这些事件是否发生   
     * register()方法，返回SelectionKey对象
     */
    private Selector selector = null;
    private SocketChannel socketChannel = null;
    private int s_port = 8000;
    private String s_IP = "192.168.100.141";
    private Charset charset = Charset.forName("GBK");
    private ByteBuffer sendBuffer = ByteBuffer.allocate(1024);
    private ByteBuffer receiveBuffer = ByteBuffer.allocate(1024);

    public EchoClient(String s_IP, int s_port) throws IOException{
        this.s_IP = s_IP;
        this.s_port = s_port;
        socketChannel = SocketChannel.open();
        //InetAddress ia = InetAddress.getLocalHost();
        InetSocketAddress isa = new InetSocketAddress(this.s_IP, this.s_port);
        // 采用阻塞模式连接服务器
        socketChannel.connect(isa);
        // 设置为非阻塞模式
        socketChannel.configureBlocking(false);
        System.out.println("与服务器的连接建立成功");
        selector = Selector.open();
    }

    /*// 接收用户从控制台输入的数据，把它放到sendBuffer中
    public void receiveFromUser(){
        try{
          BufferedReader localReader=new BufferedReader(new InputStreamReader(System.in));
          String msg=null;
          while((msg=localReader.readLine())!=null){
            synchronized(sendBuffer){
                sendBuffer.put(encode(msg + "\r\n"));
             }
            if(msg.equals("bye"))
              break;
          }
        }catch(IOException e){
           e.printStackTrace();
        }
    }*/


    // 接收指定的数据，把它放到sendBuffer中
    public void send_data(String msg){      
        if(msg!= null){
            synchronized(sendBuffer){
                System.out.println("write to sendBuffer...");
                sendBuffer.clear();                        // 把极限设为容量，再把位置设为0
                sendBuffer.put(encode(msg+"\n"));
            }           
        }                       
    }

    // 接收和发送数据
    public void talk() throws IOException{
        System.out.println(socketChannel.toString());
        socketChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
        while(selector.select()>0){
            Set<SelectionKey> readyKeys = selector.selectedKeys();
            Iterator<SelectionKey> it = readyKeys.iterator();
            while(it.hasNext()){
                SelectionKey key = null;
                try{
                    key = it.next();
                    it.remove();

                    if(key.isReadable()){receive(key);}
                    if(key.isWritable()){send(key);}

                }catch(IOException e){
                    e.printStackTrace();
                    try{
                        if(key!=null){
                            key.cancel();
                            key.channel().close();
                        }
                    }catch(IOException ex){ex.printStackTrace();}
                }
            }
        }
    }


    private void send(SelectionKey key)throws IOException{
        // 发送sendBuffer中的数据
        //System.out.println("sending to server...");
        SocketChannel socketChannel = (SocketChannel) key.channel();
        synchronized(sendBuffer){
            sendBuffer.flip();                    // 把极限设为位置，再把位置设为0
            socketChannel.write(sendBuffer);
            sendBuffer.compact();                 // 删除已经发送的数据
        }
    }

    private void receive(SelectionKey key)throws IOException{
        // 接收EchoServer发送的数据，把它放到receiveBuffer中
        // 如果receiveBuffer中有一行数据，就打印这行数据，然后把它从recviveBuffer中删除      
        SocketChannel socketChannel = (SocketChannel) key.channel();
        socketChannel.read(receiveBuffer);
        receiveBuffer.flip();
        String receiveData = decode(receiveBuffer);
        if(receiveData.indexOf("\n")==-1) return;

        String outputData = receiveData.substring(0, receiveData.indexOf("\n")+1);
        System.out.print(outputData);

        if(outputData.equals("echo:bye\r\n")){
            key.cancel();
            socketChannel.close();
            System.out.println("关闭与服务器的连接");
            selector.close();
            System.exit(0);
        }

        ByteBuffer temp = encode(outputData);
        receiveBuffer.position(temp.limit());
        receiveBuffer.compact();                    // 删除已经打印的数据
    }

     /**解码*/
    private String decode(ByteBuffer buffer){
        CharBuffer charbuff = charset.decode(buffer);
        return charbuff.toString();
    }

    /**编码*/
    private ByteBuffer encode(String str){
        return charset.encode(str);
    }

    /*public void main(String[] argv)throws IOException{
        try {
            echoclient = new EchoClient(m_ServerIP, m_ServerPort);
            Thread c_talk = new Thread(){
            public void run(){
            try {
                echoclient.talk();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
              }
            }
            };
            c_talk.start();
        } catch (IOException e) {
            // TODO Auto-generated catch block
        e.printStackTrace();
    }
    }*/


}

服务器

服务器类

/**
* 1. 参考EchoClient类的实现，只是现在服务器为了接收多个客户端，
* 2. 继承了Thread类，其run()方法就是负责阻塞的accept()SocketChannel,
* 3. 然后根据accept到的每个SocketChannel的不同，建立doEchoServer的类，
*    专门用于处理其中的一个连接，每一个连接就和CLient是相同的用法
* ************************************* --[icesongqiang]
*/

import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
import java.net.*;
import java.util.*;                // for Set


class EchoServer extends Thread{
    /**
     * Selector类, 只要ServerSocketChannel及SocketChannel向
     * Selector 注册了特定的事件，Selector类就会监控这些事件是否发生   
     * register()方法，返回SelectionKey对象
     */

    private ServerSocketChannel serverSocketChannel = null;
    private int port = 8000;
    private int count =0;
    private List<DoEchoServer> list_DoEchoServer = new ArrayList<DoEchoServer>();

    public EchoServer() throws IOException{
        // 静态方法：返回一个ServerSocketChannel对象, 没有与任何端口绑定，并且处于阻塞模式
        serverSocketChannel = ServerSocketChannel.open(); 
        serverSocketChannel.socket().setReuseAddress(true);                  // 复用端口
        serverSocketChannel.configureBlocking(true);                         // 等待接入。默认阻塞模式，false 非阻塞
        serverSocketChannel.socket().bind(new InetSocketAddress(port));      // 绑定端口
        System.out.println("服务器启动");
    }

    public void run(){
        for(;;){
            try{
                SocketChannel socketChannel = serverSocketChannel.accept();
                System.out.println("接收到客户连接，来自:" +
                                   socketChannel.socket().getInetAddress() +
                                   ":" + socketChannel.socket().getPort());  
                // 连接了一个SocketChannel, 开启一个相应的进程
                ++ count;
                DoEchoServer doEchoServer = new DoEchoServer(socketChannel);
                list_DoEchoServer.add(doEchoServer);
                Thread s_talk = new Thread(){
                    public void run(){
                        try {
                            doEchoServer.talk();
                        } catch (IOException ex) {
                            // TODO Auto-generated catch block
                            ex.printStackTrace();
                        }
                    }
                };
                s_talk.start();

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

                Iterator<DoEchoServer> it = list_DoEchoServer.iterator();
                while(it.hasNext()){
                    DoEchoServer ds = it.next();
                    if(ds.get_iswork()){ds.send_data("welcome to connect, now " + count + " clients");}
                    else{
                        it.remove();
                        --count;
                    }
                }

          }catch(IOException e){e.printStackTrace();}
      }
    }

    public void broadcast(){
        while(true){
            try {
                Thread.sleep(1000*10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            Iterator<DoEchoServer> it = list_DoEchoServer.iterator();
            while(it.hasNext()){
                DoEchoServer ds = it.next();
                if(ds.get_iswork()){ds.send_data("BroadCast: now " + count + " clients");}
                else{
                    it.remove();
                    --count;
                }
            }
        }
    }

}

服务器分支进程

/**
 * 客户相应的执行方法, 主线程利用为每个用户都开了这样的一个进程*/
class DoEchoServer {
    private SocketChannel socketChannel = null;
    private String clientIP= null;
    private Selector selector = null;
    private Charset charset = Charset.forName("GBK");
    private ByteBuffer sendBuffer = ByteBuffer.allocate(1024);
    private ByteBuffer receiveBuffer = ByteBuffer.allocate(1024);
    private boolean iswork = true;                                 // 监测当前连接是否正常工作（发送&&接收）

    public DoEchoServer(SocketChannel socketChannel) throws IOException {       
        // TODO Auto-generated constructor stub
        this.socketChannel = socketChannel;
        clientIP = socketChannel.socket().getInetAddress().toString();
        clientIP = clientIP.substring(1);
        //System.out.println("DoEchoServer: " + socketChannel.toString());
        // 为SocketChannel监控接收连接就绪事件
        selector = Selector.open();
        socketChannel.configureBlocking(false);
        socketChannel.register(selector, SelectionKey.OP_READ |SelectionKey.OP_WRITE);
    }

    public SocketChannel get_SocketChannel(){ return this.socketChannel;}

    public boolean get_iswork(){return iswork;}

    // 发送和接收数据
    public void talk() throws IOException{      
        while(selector.select()>0){
            Set<SelectionKey> readyKeys = selector.selectedKeys();
            Iterator<SelectionKey> it = readyKeys.iterator();
            while(it.hasNext()){
                SelectionKey key = null;
                try{
                    key = it.next();
                    it.remove();
                    if(key.isWritable()){send(key);}
                    if(key.isReadable()){receive(key);}                                     
                }catch(IOException e){
                    iswork = false;      // 出现异常，表示该SocketChannel已经断开
                    e.printStackTrace();
                    try{
                        if(key!=null){
                            key.cancel();
                            key.channel().close();
                        }
                    }catch(IOException ex){ex.printStackTrace();}
                }
            }
        }
    }

    // 接收指定的数据，把它放到sendBuffer中
    public void send_data(String msg){      
        if(msg!= null){
            synchronized(sendBuffer){
                sendBuffer.clear();                        // 把极限设为容量，再把位置设为0
                sendBuffer.put(encode(msg+"\r\n"));
            }           
        }                       
    }

    // 将sendBuffer中的内容发送到与key绑定的信道上
    private void send(SelectionKey key)throws IOException{
        // 发送sendBuffer中的数据
        //System.out.println("sending to server...");
        SocketChannel socketChannel = (SocketChannel) key.channel();
        synchronized(sendBuffer){
            sendBuffer.flip();                    // 把极限设为位置，再把位置设为0
            socketChannel.write(sendBuffer);
            sendBuffer.compact();                 // 删除已经发送的数据
        }
    }       

    private void receive(SelectionKey key)throws IOException{
        // 接收EchoClient发送的数据，把它放到receiveBuffer中
        // 如果receiveBuffer中有一行数据，就打印这行数据，然后把它从recviveBuffer中删除      
        SocketChannel socketChannel = (SocketChannel) key.channel();
        //System.out.println(socketChannel.toString());
        socketChannel.read(receiveBuffer);
        receiveBuffer.flip();
        String receiveData = decode(receiveBuffer);
        if(receiveData.indexOf("\n")==-1) return;
        String outputData = receiveData.substring(0, receiveData.indexOf("\n")+1);      
        dosomething(outputData);      
       /*       
        if(outputData.equals("echo:bye\r\n")){
            key.cancel();
            socketChannel.close();
            System.out.println("关闭与客户端的连接");
            selector.close();
            System.exit(0);
        }*/

        ByteBuffer temp = encode(outputData);
        receiveBuffer.position(temp.limit());
        receiveBuffer.compact();                    // 删除已经打印的数据
    }

    /**解码*/
    private String decode(ByteBuffer buffer){
        CharBuffer charbuff = charset.decode(buffer);
        return charbuff.toString();
    }

    /**编码*/
    private ByteBuffer encode(String str){
        return charset.encode(str);
    }

    /**wrete your own code there */ 
    private void dosomething(String str){
        // wrete your own code there
        // 这里还可以配合进程处理进行其他进程的开关，具体可以参考[java 多进程]
    }

}

服务器启动

import java.io.IOException;

public class MyServer {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            EchoServer echoServer = new EchoServer();
            Thread s_accept = new Thread(){
                public void run(){                  
                    echoServer.run();                   
                }
            };
            s_accept.start();

            echoServer.broadcast();

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }  

    }
}
icesongqiang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程（二）：多线程交互(案例)
Jodness' Blogs
03-06 534
目录 线程状态 线程间交互 线程间的排队：join() wait()、notify()、notifyAll() 死锁 信号量 Semaphore CountDownLatch 线程状态 在jdk1.8中，线程可以处于以下状态之一： NEW ：尚未启动的线程处于此状态。 RUNNABLE ：在Java虚拟机中执行的线程处于此状态。 BLOCKED ：被阻塞等待监视器锁定...
Java模拟异步消息的发送与回调
kt8668
06-19 378
    本文的目的并不是介绍使用的什么技术，而是重点阐述其实现原理。   一、 异步和同步 讲通俗点，异步就是不需要等当前执行的动作完成，就可以继续执行后面的动作。   通常一个程序执行的顺序是：从上到下，依次执行。后面的动作必须等前面动作执行完成以后方可执行。这就是和异步相对的一个概念——同步。   案例： A、张三打电话给李四，让李四帮忙写份材料。 B、李四接到电话的时候，手上有自己的工作要处...
Java与外部进程交互从精通到陌生
热门推荐
qq_40495860的博客
10-24 1万+
1.什么是进程 现代操作系统运行一个程序的时候，会为其创建一个进程，例如启动一个IDEA，操作系统就还创建一个IDEA进程 2.如何与进程交互 Process 创建方式 1.使用Runtime Runtime runtime = Runtime.getRuntime(); try { Process exec = runtime.exec(cmdStr); } catch (IOException e) {
java 收发信息的实例
阿土工作室
10-25 712
package net;import java.io.IOException; import java.net.DatagramPacket; import java.net.InetAddress; import java.net.MulticastSocket; import java.net.UnknownHostException; public class socket {   
linux下用socket实现客户端与服务端
12-28
在Linux操作系统中，使用套接字（socket）是实现客户端与服务端通信的常用方法。套接字是一种网络编程接口，允许应用程序通过网络发送和接收数据。本篇将详细讲解如何在Linux环境下利用socket实现客户端和服务端之间...
JAVA上百实例源码以及开源项目
01-03
　Tcp服务端与客户端的JAVA实例源代码，一个简单的Java TCP服务器端程序，别外还有一个客户端的程序，两者互相配合可以开发出超多的网络程序，这是最基础的部分。 递归遍历矩阵 1个目标文件，简单！ 多人聊天室 3...
JAVA上百实例源码以及开源项目源代码
12-11
2个目标文件 摘要:Java源码,文件操作,TCP,服务器 Tcp服务端与客户端的JAVA实例源代码，一个简单的Java TCP服务器端程序，别外还有一个客户端的程序，两者互相配合可以开发出超多的网络程序，这是最基础的部分。...
QT_TCP.rar_C/S服务器_QT TCP_linux 网络_tcp linux QT_tcp s/c
07-14
QT_TCP.rar 文件包含了一个基于Linux平台的C/S（客户机/服务器）架构的TCP网络通信程序，使用了QT库来实现TCP套接字的交互。QT是一个跨平台的应用开发框架，特别适合于创建图形用户界面应用程序，同时也支持非GUI...
java 多进程
weixin_34023863的博客
11-12 951
2019独角兽企业重金招聘Python工程师标准>>> ...
利用多进程/多线程实现多个客户端同时访问同一服务器
weixin_45595778的博客
05-09 2220
        如果实现一客户端与服务器的交互比较容易(直接用TCP的编程流程就可以实现，只是这样写出的程序只能是一个客户端交互释放连接后其他客户端才可以与服务器交互 )，但是要实现多个客户端同时与同一服务器的交互就相对复杂一点。 我们先给出服务器处理同一客户端的...
java的进程管理_永不挂掉的进程！服务器进程管理神器Supervisor
weixin_30641597的博客
02-27 644
简单介绍Supervisor是一个客户端/服务器系统，允许用户在类UNIX操作系统上控制许多进程。它是基于python语言开发一个进程管理工具。Supervisor的服务器端称为supervisord，主要负责在启动自身时启动管理的子进程，响应客户端的命令，重启崩溃或退出的子进程，记录子进程stdout和stderr输出，生成和处理子进程生命周期中的事件。可以在一个配置文件中配置相关参数，包括Su...
java网络编程(二)复用Socket连接以及使用多线程完成多个客户端的连接
不能说的秘密的博客
01-26 6394
java网络编程(二)复用Socket连接以及使用多线程完成多个客户端的连接
java如何实现异步_教你如何用 Java 实现异步调用
weixin_42511769的博客
02-12 1339
本教程教你如何使用Java实现异步调用。一、创建线程@Testpublicvoidtest0()throwsException{System.out.println("main函数开始执行");Threadthread=newThread(newRunnable(){@Overridepublicvoidrun(){System.out.println("===tasks...
java多进程与多线程的区别
dlrb_beautiful的博客
06-18 816
操作系统中的多任务：在同一时刻运行多个程序的能力。操作系统将CPU的时间片分配给每一个进程，给人并行处理的感觉。 多线程程序在较低的层次上扩展了多任务的概念：一个程序同时执行多个任务。通常，每一个任务称为一个线程。可以同时运行一个以上线程的程序称为是多线程程序。 多进程与多线程的区别：本质的区别在于每个进程拥有自己的一整套变量，而线程则共享数据。共享变量使线程之间的通信比进程之间的通信更有效、更容...
三面美团Java岗，HR现场直接发offer，他是横着走出来的！
weixin_47066028的博客
09-29 926
前情提要 这是一个发生在我朋友身上的真实事情： 这里就叫他程序员Y吧。 程序员Y工作不到两年，周末在朋友圈发了个喜报，准备入职美团。 之后，我就带着祝福跟Y聊了许久，聊天的内容就是具体了解一下他面试的过程，心路历程和未来的打算。 之所以今天才发文章，是因为我一直在等他整理面试问的内容。今天正好就一并分享出来。 严格来讲是三面，但是Y笑着说其实只有二面… 美团一面（80min） （为保证内容纯正，下面的语言是由程序员Y自己整理的，霸哥没有任何改动） 面试主要是从一个系统设计出发，考察基础跟项目架构经验。美团
并发服务器模板：多进程与多线程实现
该资源主要讨论了多进程并发服务器模板以及多进程和多线程程序开发的相关知识。通过示例代码展示了如何构建一个基于多进程的并发服务器，并介绍了服务器的分类，包括面向连接和无连接的服务器，以及迭代服务器和并发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值