Nio多线程CS收发信息问题（问题已经解决）

最新推荐文章于 2022-11-13 15:21:11 发布
最新推荐文章于 2022-11-13 15:21:11 发布
阅读量266 收藏
点赞数
文章标签： 多线程 Java Swing .net Access
刚开始研究Java的NIO，就碰上了个问题，现在服务器端和客户段一个发一个收没有问题，但要是客户端和服务器段同时发收就有问题（我说的是双向的意思），这是为什么呢？相不明白，大家帮看看。
服务器端代码： 

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package niocs.newpackage.service;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
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 javax.swing.JTextPane;
import niocs.NIOCSView;
import niocs.newpackage.service.If.IServerConnect;

/**
 *
 * @author Administrator
 */
public class SetUpServer implements Runnable,IServerConnect
{
    private final static int MAXACCEPT = 2048;
    private NIOCSView serverShow;
    private ByteBuffer w_Buff = ByteBuffer.allocate(MAXACCEPT);
    private final static String ENTER = "\r\n";
    private int port;
    private JTextPane messageContent;
    private StringBuilder message = new StringBuilder();
    private String fMessage = null;
    public SetUpServer(NIOCSView server)
    {
        this.serverShow = server;
        setUPServer();
    }

    private void setUPServer()
    {
        try
        {
            messageContent = this.serverShow.getContent();
            message.append("正在初始化端口");
            message.append(ENTER);
            messageContent.setText(message.toString());
            port = Integer.parseInt(this.serverShow.getPort().getModel().getValue().toString());
            message.append("初始化端口成功!");
            message.append(ENTER);
            messageContent.setText(message.toString());
        }
        catch(ClassCastException e)
        {
            port = 0;
            message.append("端口初始化失败!");
            message.append(ENTER);
            messageContent.setText(message.toString());
        }
    }

    public void run()
    {
        try
        {

            ServerSocketChannel ssc = ServerSocketChannel.open();
            ssc.configureBlocking(false);
            Selector s = Selector.open();
            ssc.socket().bind(new InetSocketAddress(port));
            showMessage("系统正在建立对" + port + "端口的监听");
            ssc.register(s,SelectionKey.OP_ACCEPT);
            showMessage("系统已经启动!");
            while(true)
            {
                int n = s.select();
                if(n == 0)
                {
                    continue;
                }
                Iterator it = s.selectedKeys().iterator();
                while(it.hasNext())
                {
                    SelectionKey key = (SelectionKey) it.next();
                     it.remove();
                    if(key.isAcceptable())
                    {
                        showMessage("有人连接到服务器.");
                        ServerSocketChannel server = (ServerSocketChannel) key.channel();
                        SocketChannel sc = server.accept();
                        showMessage("接受此连接请求");
                        sc.configureBlocking(false);

                        sc.register(s, SelectionKey.OP_READ);
                    }
                    if(key.isReadable())
                    {
                        SocketChannel sc = (SocketChannel)key.channel();
                        showMessage("正在读取数据");
                        if(!readData(sc))
                        {
                            key.cancel();
                            break;
                        }
                        sc.configureBlocking(false);

                        sc.register(s, SelectionKey.OP_WRITE);
                    }
                     if(key.isWritable())
                     {
                         SocketChannel sc = (SocketChannel)key.channel();
                         showMessage("向客户端发送数据");
                         fMessage = "123456";
                         if(!writeData(sc, fMessage))
                         {
                             key.cancel();
                             break;
                         }
                         sc.configureBlocking(false);

                         sc.register(s, SelectionKey.OP_READ);
                     }
                }
            }
        }
        catch(IOException e)
        {
            e.printStackTrace();
            showMessage("读取时出错");
            return;
        }
    }
    private void showMessage(String aMessage)
    {
        message.append(aMessage);
        message.append(ENTER);
        messageContent.setText(message.toString());
    }
    private boolean readData(SocketChannel sc) throws IOException
    {
        ByteBuffer r_Buff = ByteBuffer.allocate(MAXACCEPT);
        try
        {

            r_Buff.clear();

            while(sc.read(r_Buff) > 0)
            {
                r_Buff.flip();
                fMessage = new String(r_Buff.array()).trim();
                showMessage("收的数据是:" + fMessage);
            }
            r_Buff = null;
            return true;
        }
        catch(IOException e)
        {
            System.err.println("又报错了");
            r_Buff.clear();
            r_Buff.clear();
            return false;
        }
        catch(NullPointerException e)
        {
            System.err.println("丫的出来空指针了");
            return false;
        }
    }
    private boolean writeData(SocketChannel sc,String message)
    {
        try
        {
            w_Buff.clear();
            w_Buff.put(message.getBytes());
            w_Buff.flip();
            while(w_Buff.hasRemaining())
                sc.write(w_Buff);
            w_Buff.clear();
            return true;
        }
        catch(IOException e)
        {
            System.err.println("sever已");
            return false;
        }
        catch(NullPointerException e)
        {
            System.err.println("过去了都.");
            return false;
        }
    }

    public int getConnectPort()
    {
        return port;
    }
}

这段代码实现了，接收和发送，即：服务器段受到什么就再返还给客户端。
客户端：线程1读线程 

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package nioclien.backClass;

import java.io.IOException;
import java.net.ConnectException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
import javax.swing.JTextArea;
import nioclien.JSendMessage;
/**
 *
 * @author Administrator
 */
public class ClienReadServer implements Runnable{
    private final static int MAXSIZE = 2048;
    private final static String ENTER = "\r\n";
    private ByteBuffer w_Buff = ByteBuffer.allocate(MAXSIZE);
    private static String host;
    private int port;
    private JSendMessage sender;
    private StringBuilder message = new StringBuilder();
    private JTextArea messageReciver;

    public ClienReadServer(JSendMessage sender)
    {
        this.sender = sender;
        messageReciver = sender.getReceiveText();
        initForm();
    }
    private void initForm()
    {
        try
        {
            port = Integer.parseInt(this.sender.getPort().getText());
            host = this.sender.getIPText().getText();
        }
        catch(NumberFormatException e)
        {
            port = 0;
            message.append("初始化端口失败");
            message.append(ENTER);
            messageReciver.setText(message.toString());

        }
    }
    @SuppressWarnings({"static-access", "empty-statement"})
    public void run()
    {
        if(host.trim().startsWith("."))
        {
            this.sender.getConnectMenuItem().setEnabled(true);
            return;
        }
        try
        {
            SocketChannel channel = SocketChannel.open(new InetSocketAddress(host, port));
            channel.configureBlocking(false);

            Selector selector = Selector.open();
            SelectionKey skey = channel.register(selector, SelectionKey.OP_READ);

            showMessage("与" + host + "已经成功连接,您现在可以发送消息了.");
            boolean stop = false;
            int n = 0;
            int read = 0;
            while(!stop)
            {
                n = selector.select();
                if(n > 0)
                {
                    Set set = selector.selectedKeys();
                    Iterator it = set.iterator();
                    while(it.hasNext())
                    {
                        skey = (SelectionKey) it.next();
                        it.remove();
                        if(skey.isReadable())
                        {
                            SocketChannel sc = (SocketChannel) skey.channel();
                            readServer(sc);
                        }
                    }
                }
            }
        }
        catch(ConnectException e)
        {
            this.sender.getConnectMenuItem().setEnabled(true);
            System.err.println("连接服务器失败.");
            return;
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
    }
    @SuppressWarnings("empty-statement")
    public void readServer(SocketChannel sc) throws IOException
    {
        try
        {
            ByteBuffer r_Buff = ByteBuffer.allocate(MAXSIZE);
            r_Buff.clear();
            while(sc.read(r_Buff) > 0)
            {
                r_Buff.flip();
                showMessage("收的数据是:" + new String(r_Buff.array()).trim());
            }
        }
        catch(NullPointerException e)
        {
            System.err.println("时间上的问题.");
        }
    }

    private void showMessage(String aMessage)
    {
        message.append(aMessage);
        message.append(ENTER);
        messageReciver.setText(message.toString());
    }

}

客户端线程2：写线程，向服务器端发送信息。 

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package nioclien.backClass;

import java.io.IOException;
import java.net.ConnectException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.LinkedList;
import javax.swing.JTextArea;
import nioclien.JSendMessage;

/**
 *
 * @author Administrator
 */
public class ClienServer implements Runnable
{
    private SocketChannel sc;
    private final static int MAXSIZE = 2048;
    private final static String ENTER = "\r\n";
    private ByteBuffer w_Buff = ByteBuffer.allocate(MAXSIZE);
    private static String host;
    private int port;
    private JSendMessage sender;
    private StringBuilder message = new StringBuilder();
    private FQueue<String> fQueue = new FQueue<String>();

    public ClienServer(JSendMessage sender)
    {
        this.sender = sender;
        initForm();
    }
    private void initForm()
    {
        try
        {
            port = Integer.parseInt(this.sender.getPort().getText());
            host = this.sender.getIPText().getText();
        }
        catch(NumberFormatException e)
        {
            port = 0;
            message.append("初始化端口失败");
            message.append(ENTER);

        }
    }
    @SuppressWarnings({"static-access", "empty-statement"})
    public void run()
    {
        if(host.trim().startsWith("."))
        {
            return;
        }
        try
        {
            InetSocketAddress addr = new InetSocketAddress(host, port);
            sc = SocketChannel.open();
            sc.connect(addr);

            while(!sc.finishConnect());//等待建立连接
            while(true)
            {
                try
                {
                    synchronized(fQueue)
                    {
                        if(!fQueue.isEmpty())
                        {
                            String temp = fQueue.get();
                            System.out.println("要发送的数据是:" + temp);
                            w_Buff.clear();
                            w_Buff.put(temp.getBytes());
                            w_Buff.flip();
                            while(w_Buff.hasRemaining())
                                sc.write(w_Buff);
                            w_Buff.clear();
                        }
                    }
                }
                catch(Exception e)
                {
                    System.err.print("丫的没发送成功");

                }
                Thread.currentThread().sleep(1000);
            }
        }
        catch(ConnectException e)
        {
            this.sender.getConnectMenuItem().setEnabled(true);
            System.err.println("连接服务器失败.");
            return;
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
    }

    public void sendMessage(String aMessage)
    {
        fQueue.put(aMessage);
    }
    private class FQueue<T>
    {
        private LinkedList<T> flist = new LinkedList<T>();

        public void put(T o)
        {
            flist.addLast(o);
        }

        public T get()
        {
            return flist.removeFirst();
        }

        public boolean isEmpty()
        {
            return flist.isEmpty();
        }
    }

}

不知道为什么当写线程向服务器发出信息后，服务器又返还信息，客户端读线程好象并没有接收到。这是为什么呢？
iteye_265
关注
通俗编程——白话NIO之Channel
Floating Cat
12-16 7351
Channel简介在标准的IO当中，都是基于字节流/字符流进行操作的，而在NIO中则是是基于Channel和Buffer进行操作，其中的Channel的虽然模拟了流的概念，实则大不相同。
Muduo 多线程模型：一个 Sudoku 服务器演变
热门推荐
陈硕的Blog
06-16 5万+
陈硕 (giantchen AT gmail)blog.csdn.net/SolsticeMuduo 全系列文章列表： http://blog.csdn.net/Solstice/category/779646.aspx本文以一个 Sudoku Solver 为例，回顾了并发网络服务程序的多种设计方案，并介绍了使用 muduo 网络库编写多线程服务器的两种最常用手法。以往的例子展现了
基于事件的NIO多线程服务器的问题
wjy320的专栏
05-22 98
        最近看了很好的一篇博客:http://www.ibm.com/developerworks/cn/java/l-niosvr/          于是我按照作者给的源码做实验(源码以上传到附件中NIOServer.jar),我模拟发送1000次消息，服务器做出一千次响应。 public static void main(String args[]) { ...
java nio在多线程环境需注意的问题
孤舟蓑笠翁，独钓寒江雪
02-04 896
java nio在多线程环境需注意的问题 原帖：http://www.blogjava.net/adapterofcoms/archive/2010/03/02/314242.html 有人说java nio在多线程环境下编程简直就是个恶梦,其实你如果能把握住java nio API的要领,你就可以将之驾驭.  0. 一个 channal 对应一个SelectionKey in
43、Nio（多线程优化（问题解决））
最新发布
分享java学习路上的一些笔记，不足之处多多见谅。
11-13 368
Nio（多线程优化（问题解决））解决方式（模拟netty）：第一步：我们都让他在worker0线程中处理（初始化和注册）这样我们就能控制其先后顺序了 注意：！！！但是我们上面还被boss线程调用的（刚开始worker线程还没启动怎么去调动嘛），只有后面我们worker线程启动去运行run方法才是worker0线程运行的。所以我们要放进run里面第二步：我们用一个队列来解耦（队列，线程通信） 1、队列里面加任务，但这个任务并没有立即执行 2、我们在select后面将队列的东西取出来（queue.poll）执
NIO 多线程处理异步队列
Ant_Shen的专栏
04-22 2252
本文使用java的NIO简单实现server-client模式，处理异步队列。缓存队列类
NIO使用出现的问题总结
qq_37978623的博客
07-05 633
使用NIO实现TCP的通信，通过buffer缓冲区进行数据的读取。出现的问题：客户端向服务端发送的数据包（长度是48到52的包不等长度），buffer申请的空间是1024，用于接收数据，服务端启动，进行数据通信时，客户端在短时间内发送的数据包非常多的情况下，buffer从channel中读取的数据的长度有100到700不等。第一次分析问题的时候，对数据NIO机制也许不太清楚，所以造成了误解。误区：...
弹出消息框的使用
qq_37801118的博客
11-23 630
使用jquery弹出消息框
【Java SE】多线程
IN THE ZONE
04-07 1449
通俗地说： 进程：比如IDEA或者QQ的运行，是程序（任务）的执行过程，持有资源（共享内存、共享文件）和线程； （说明是动态性的，单个文件并不是进程，只有点击文件使程序运行后才发生进程） （进程是资源、线程的载体，脱离了线程谈进程无意义） 线程：比如QQ中的“文字聊天”“收发文件”，所有这些人物都可以理解为线程； 线程的交互：互斥与同步；比方说进程是班级，线程是学生，学生沟通就是线程，学生之间有时...
Java8新特性-NIO
u011533553的博客
08-02 670
一、Java NIO 简介 ​ Java NIO（ New IO） 是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。NIO与原来 ​ 的IO有同样的作用和目的，但是使用的方式完全不同， NIO支持面向缓冲区的、基于通道的IO操作。 NIO将以 ​ 更加高效的方式进行文件的读写操作 二、Java NIO 与 IO 的主要区别 IO NIO 面向流(Stream Oriented) 面向缓冲区(Buffer Oriented) 阻塞IO(Bloc
java nio_channel
qq_34352013的博客
11-23 95
channel概述channel的分类代码演示客户端客户端2客户端3服务器端服务器端2 概述 作用：在NIO中，承担 数据传输的作用。（相当于火车铁轨） 传输的东西：channel只能面向 buffer传输，也就是只能传Buffer，你交给他一个变量，数组，map都是不能传输的。 channel的分类 类似于传统IO，按照不同的传输场景将IO分成了多个类。 Channel也可以分为以下几种 1、 ...
java 邮件提醒_java邮件提醒实现
weixin_39945795的博客
02-12 653
【背景】最近做项目的时候,有这样一个需求,因为项目中的流程是分级流转审批的过程,所以当前人操作完成之后,需要程序的一个固定邮箱通过邮件通知下级相应人员进行处理,所以也就有了小编今天的这篇博文。【操作步骤】1.引入activation.jar、commons-email-1.1.jar、mail.jar这三个jar包,百度搜索下载或者单击此百度网盘链接(请单击此链接下载)2.将共用的信息放到配置文件...
java NIO的空轮询bug 以及Netty的解决办法
weixin_44601714的博客
08-29 1658
这个bug是指 java的NIO在linux下selector.select()时，本来如果轮询的结果为空并且不调用wakeup的方法的话，这个selector.select()应该是一直阻塞的，但是java却会打破阻塞，继续执行，导致程序无限空转，造成CPU使用率100% 这个bug只出现在linux系统下，因为linux下NIO底层使用的是epoll来实现的，而java的epoll实现存在...
java网络编程复习
AngelCG的博客
07-07 977
1、多线程的并发同步？（1）多线程的同步：线程同步就是当线程发出一个功能调用时，在没有有得到结果之前，该调用不会返回，其他线程也不能调用该方法。（2）并发：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。其中两种关系分别是同步和互斥。同步就是进城之间的关系不是相互排斥临界资源的关系，而是相互依赖的关系。金玉不说明就是：就是前一个进程的输...
android String语句显示不同的字体颜色，用StringBuilder
qq_36749859的博客
05-27 730
语句： 开始测试：TF卡检测成功:1024.0 MB StringBuilder message = new StringBuilder(); message.append("开始测试:");//正常颜色 message.append("<font color=\"#00FF00\">").append("TF卡检测成功:")).append("1024.0 ").append("MB").append("</font>");//绿色 message.append("....")/
java nio之数据读写时无限循环分析与解决
haier_jiang的专栏
08-17 6962
写这片文章是因为自己昨天刚解决了一个十个月前碰到的问题！当时苦于网上高手无人回答，也苦于自己当时没有时间去钻研为什么 ！ 问题是:通过网上实例以及java网络编程这本书写java nio简单的测试服务器时发现，都是注册读写事件后然后分别处理相应的事件 就行了，这样本没错，可对于后续对注册事件的操作，再也没有看到与之相关实例与说明。然而，就这样完事以后，服务器端要么是 无限读事件与写事件有效，要么是客户端接收的数据是重复的好几条，在高并发时甚至上百上千。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值