java 阻塞模式与非阻塞模式

最新推荐文章于 2024-07-10 19:38:59 发布
最新推荐文章于 2024-07-10 19:38:59 发布
阅读量1k 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ffghggf/article/details/83887337
版权

分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow

也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！

               

TCP/IP 阻塞模式与非阻塞模式

package concurrentTest;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;import java.net.ServerSocket;import java.net.Socket;import java.net.UnknownHostException;/** * TCP/IP的阻塞模式  */public class TCPBIO {  /**  * 客户端监听事件  * @param ipStr IP地址  * @param portNum 端口号  * */ public void clientListen(String ipStr, int portNum) {  try {   Socket socket = new Socket(ipStr, portNum);      //创建读取服务器端返回流的BufferReader   BufferedReader in = new BufferedReader(new          InputStreamReader(socket.getInputStream()));      //创建向服务器写入流的PrintWriter   PrintWriter out = new PrintWriter(socket.getOutputStream(), true);      //向服务器发送字符串信息，此处即使写失败也不会抛出异常，会一直阻塞到   //写入操作系统或者网络IO出现异常为止   out.println("hello java");      //阻塞读取服务器端的返回信息，以下代码会阻塞到服务器端返回信息或者网络IO出现异常为止   //若希望过段时间后不阻塞，则在socket创建后加入socket.setSoTimeout(time);   in.readLine();     } catch (UnknownHostException e) {   // TODO Auto-generated catch block   e.printStackTrace();  } catch (IOException e) {   // TODO Auto-generated catch block   e.printStackTrace();  }   }   /**  * 服务器端监听事件  * @param portNum 端口号  * */ public void serverListen(int portNum) {  ServerSocket ss;  try {   ss = new ServerSocket(portNum);      //通过Scoket.getInputStream和Socket.getOutputStream进行读写操作，此方法   //会一直阻塞到有客户端发送建立请求   Socket socket = ss.accept();     } catch (IOException e) {   // 网络IO异常   e.printStackTrace();  }   }  public static void main(String[] args) {  // TODO Auto-generated method stub }}


 

<PRE class=java name="code">package concurrentTest;import java.io.IOException;import java.net.InetSocketAddress;import java.net.ServerSocket;import java.nio.ByteBuffer;import java.nio.channels.*;import java.util.Set;/** * TCP/IP的 非阻塞模式  */public class TCPNIO { /**  * 客户端监听事件  * @param ipStr IP地址  * @param portNum 端口号  * */   public void clientListen(String ipStr, int portNum, int blockTime) {  try {   SocketChannel channel = SocketChannel.open();      //设置为非阻塞模式   channel.configureBlocking(false);      //对于非阻塞模式，立刻返回false，表示连接正在建立中   Selector selector = Selector.open();      //向channel注册selector和感兴趣事件   channel.register(selector, SelectionKey.OP_CONNECT);      //阻塞至有感兴趣的IO事件发生，或者到达超时时间，如果希望一直等待到有感兴趣的   //事件发生，可调用无参数的select方法，如果希望不阻塞直接返回目前是否有感兴趣的   //事件发生，可调用selectNow方法   int nKeys = selector.select(blockTime);   SelectionKey sKey = null;      //nKeys大于0，说明有感兴趣的事件发生   if(nKeys > 0)   {    Set<SelectionKey> keys = selector.selectedKeys();    for(SelectionKey key:keys)    {     //对于发生连接事件     if(key.isConnectable())     {      SocketChannel sc = (SocketChannel)key.channel();      sc.configureBlocking(false);            //注册感兴趣的IO事件，通常不直接注册写事件，在发送缓冲区未满的情况下      //一直是可写的，所以如果注册了写事件，而又不写数据，则很容易造成CPU消耗100%      sKey = sc.register(selector, SelectionKey.OP_READ);            //完成连接的建立      sc.finishConnect();     }     else if(key.isReadable())//有流可读取     {      ByteBuffer buffer = ByteBuffer.allocate(1024);      SocketChannel sc = (SocketChannel)key.channel();      int readBytes = 0;      try {       int ret = 0;       try {        //读取目前可读的流，sc.read(buffer)返回的是成功复制到bytebuffer中        //的字节数，为阻塞操作，值可能为0，若到流结尾，返回-1        while ((ret = sc.read(buffer)) > 0) {         readBytes += ret;        }       } finally {        buffer.flip();       }      } finally{       if(buffer != null)       {        buffer.clear();       }      }     }     else if(key.isWritable())//可写入流     {      //取消对OP_WRITE事件的注册      ByteBuffer buffer = ByteBuffer.allocate(1024);      key.interestOps(key.interestOps() & (~SelectionKey.OP_WRITE));      SocketChannel sc = (SocketChannel)key.channel();            //此步为阻塞操作，知道写入操作系统发送缓冲区或者网络IO出现异常      //返回的为成功写入的字节数，若缓冲区已满，返回0      int writeenedSize = sc.write(buffer);            //若未写入，继续注册感兴趣的OP_WRITE事件      if(writeenedSize == 0)      {       key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);      }     }    }        selector.selectedKeys().clear();   }   /*    * 也可以直接调用channel.write完成写    * 只有在写入未成功时才注册OP_WRITE事件   ByteBuffer buffer = ByteBuffer.allocate(1024);   int wSize = channel.write(buffer);   if(wSize == 0)   {    key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);   }*/     } catch (IOException e) {   // TODO Auto-generated catch block   e.printStackTrace();  } }   /**  * 服务器端监听事件  * @param portNum 端口号  * */ public void serverListen(int portNum, int blockTime) {  ServerSocketChannel ssc;  try {   ssc = ServerSocketChannel.open();   ServerSocket serverSocket = ssc.socket();      serverSocket.bind(new InetSocketAddress(portNum));   ssc.configureBlocking(false);   Selector selector = Selector.open();   ssc.register(selector, SelectionKey.OP_ACCEPT);      int nKeys = selector.select(blockTime);      if(nKeys > 0)   {    Set<SelectionKey> keys = selector.selectedKeys();    for(SelectionKey key:keys)    {     if(key.isAcceptable())     {      ServerSocketChannel server = (ServerSocketChannel)key.channel();      SocketChannel sc = server.accept();      if(sc == null)      {       continue;      }      sc.configureBlocking(false);            //注册感兴趣的连接建立事件      sc.register(selector, SelectionKey.OP_READ);     }    }   }     } catch (IOException e) {   // TODO Auto-generated catch block   e.printStackTrace();  }   }  public static void main(String[] args) {  // TODO Auto-generated method stub }}</PRE><BR><BR><PRE></PRE><BR>


 

UDP/IP 阻塞模式与非阻塞模式

 

package concurrentTest;import java.io.IOException;import java.net.DatagramPacket;import java.net.DatagramSocket;import java.net.InetAddress;import java.net.SocketException;/** * UDP/IP阻塞模式 * */public class UDPBIO { /**  * 服务器端和客户端类似   * @param ipStr IP地址  * @param portNum 端口号  * */   public void udpListen(String ipStr, int portNum) {  try {   //若希望是全双工模式，则启动一个监听端口，承担服务器的职责   //若不能绑定到指定端口，则抛出SocketException   DatagramSocket serverSocket = new DatagramSocket(portNum);   InetAddress server = InetAddress.getByName(ipStr);   byte[] buffer = new byte[65507];   DatagramPacket receivePacket = new DatagramPacket(buffer,buffer.length);   DatagramSocket socket = new DatagramSocket();   DatagramPacket packet = new DatagramPacket(buffer,buffer.length,server,portNum);      //阻塞发送packet到指定的服务器和端口   //网络IO异常，抛出IOExceprion   //连不上IP和端口，抛出PortUnreachableException   socket.send(packet);      //阻塞并同步读取流信息，如接收到的信息流比packet长，则删除更长的信息   serverSocket.receive(receivePacket);     } catch (SocketException e) {   // 若不能绑定到指定端口   e.printStackTrace();  } catch (IOException e) {   // TODO Auto-generated catch block   e.printStackTrace();  }   }  public static void main(String[] args) {  // TODO Auto-generated method stub }}


 

package concurrentTest;import java.io.IOException;import java.net.DatagramSocket;import java.net.InetAddress;import java.net.InetSocketAddress;import java.net.MulticastSocket;import java.net.SocketAddress;import java.net.SocketException;import java.net.UnknownHostException;import java.nio.ByteBuffer;import java.nio.channels.DatagramChannel;import java.nio.channels.SelectionKey;import java.nio.channels.Selector;/** * UDP/IP非阻塞模式 * */public class UDPNIO { /**  * 服务器端和客户端类似   * @param ipStr IP地址  * @param portNum 端口号  * */    public void udpListen(String ipStr, int portNum) {  try {   ByteBuffer buffer = ByteBuffer.allocate(1024);   DatagramChannel reveiveChannel = DatagramChannel.open();   reveiveChannel.configureBlocking(false);   DatagramSocket socket = reveiveChannel.socket();   socket.bind(new InetSocketAddress(portNum));   Selector selector = Selector.open();   reveiveChannel.register(selector, SelectionKey.OP_READ);      //之后可采取和TCP/IP NIO中对selector遍历方式进行流信息的读取   DatagramChannel sendChannel = DatagramChannel.open();   sendChannel.configureBlocking(false);   SocketAddress target = new InetSocketAddress(InetAddress.getLocalHost(), portNum);   sendChannel.connect(target);      //阻塞写入流，若发送缓冲区已满，返回0，此时可继续注册OP_WRITE事件   sendChannel.write(buffer);  } catch (SocketException e) {   // TODO Auto-generated catch block   e.printStackTrace();  } catch (IOException e) {   // TODO Auto-generated catch block   e.printStackTrace();  }   }   /**  * 组播  * */ public void multicaseListen(String ipStr, int portNum) {  try {   InetAddress groupAddress = InetAddress.getByName(ipStr);   MulticastSocket server = new MulticastSocket(portNum);      //加入组播，若地址为非组播地址，抛出IOException   //若不希望再发送数据到组播地址或者不希望再读取数据，可调用server.leaveGroup(组播地址)   server.joinGroup(groupAddress);   MulticastSocket client = new MulticastSocket();   client.joinGroup(groupAddress);      //     } catch (UnknownHostException e) {   // TODO Auto-generated catch block   e.printStackTrace();  } catch (IOException e) {   // 若地址为非组播地址   e.printStackTrace();  } }  public static void main(String[] args) {  // TODO Auto-generated method stub }}


 

 

　　服务器代码:　　import java.net.*;　　import java.nio.*;　　import java.nio.channels.*;　　import java.util.*;　　public class server　　{　　ServerSocketChannel ssc ;　　public void start()　　{　　try　　{　　Selector selector = Selector.open();　　ServerSocketChannel ssc=ServerSocketChannel.open();　　ssc.configureBlocking(false);　　ServerSocket ss=ssc.socket();　　InetSocketAddress address = new InetSocketAddress(55555);　　ss.bind(address);　　ssc.register(selector, SelectionKey.OP_ACCEPT);　　System.out.println("端口注册完毕!");　　while(true)　　{　　selector.select();　　Set<SelectionKey> selectionKeys=selector.selectedKeys();　　Iterator<SelectionKey> iter=selectionKeys.iterator();　　ByteBuffer echoBuffer=ByteBuffer.allocate(20);　　SocketChannel sc;　　while(iter.hasNext())　　{　　SelectionKey key=iter.next();　　if((key.readyOps()&SelectionKey.OP_ACCEPT)==SelectionKey.OP_ACCEPT)　　{　　ServerSocketChannel subssc=(ServerSocketChannel)key.channel();　　sc=subssc.accept();　　sc.configureBlocking(false);　　sc.register(selector, SelectionKey.OP_READ);　　iter.remove();　　System.out.println("有新连接:"+sc);　　}　　else if((key.readyOps()&SelectionKey.OP_READ)==SelectionKey.OP_READ)　　{　　sc=(SocketChannel) key.channel();　　while(true)　　{　　echoBuffer.clear();　　int a;　　try　　{　　a=sc.read(echoBuffer);　　}　　catch(Exception e)　　{　　e.printStackTrace();　　break;　　}　　if(a==-1) break;　　if(a>0)　　{　　byte[] b=echoBuffer.array();　　System.out.println("接收数据: "+new String(b));　　echoBuffer.flip();　　sc.write(echoBuffer);　　System.out.println("返回数据: "+new String(b));　　}　　}　　sc.close();　　System.out.println("连接结束");　　System.out.println("=============================");　　iter.remove();　　}　　}　　}　　}　　catch (Exception e)　　{　　e.printStackTrace();　　}　　}　　}　　客户端代码:　　import java.net.*;　　import java.nio.*;　　import java.nio.channels.*;　　public class client　　{　　public void start()　　{　　try　　{　　SocketAddress address = new InetSocketAddress("localhost",55555);　　SocketChannel client=SocketChannel.open(address);　　client.configureBlocking(false);　　String a="asdasdasdasddffasfas";　　ByteBuffer buffer=ByteBuffer.allocate(20);　　buffer.put(a.getBytes());　　buffer.clear();　　int d=client.write(buffer);　　System.out.println("发送数据: "+new String(buffer.array()));　　while(true)　　{　　buffer.flip();　　int i=client.read(buffer);　　if(i>0)　　{　　byte[] b=buffer.array();　　System.out.println("接收数据: "+new String(b));　　client.close();　　System.out.println("连接关闭!");　　break;　　}　　}　　}　　catch(Exception e)　　{　　e.printStackTrace();　　}　　}　　}

1. 服务端

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.util.Set;

public class NioUdpServer {

public static void main(String[] args) {
try {
Selector selector = Selector.open();
DatagramChannel channel = DatagramChannel.open();
channel.configureBlocking(false);
DatagramSocket socket = channel.socket();
socket.bind(new InetSocketAddress(1000));
channel.register(selector, SelectionKey.OP_READ);

ByteBuffer receiveBuffer = ByteBuffer.allocate(1024);
final int PACKAGE_SIZE = 10;
while(true){
int n = selector.select();
if(n == 0){
continue;
}
Set<SelectionKey> readyKeys = selector.selectedKeys();
for(SelectionKey key : readyKeys){
readyKeys.remove(key);

if(key.isReadable()){
DatagramChannel dc = (DatagramChannel)key.channel();
InetSocketAddress client = (InetSocketAddress)dc.receive(receiveBuffer); //接收来自任意一个Client的数据报
key.interestOps(SelectionKey.OP_READ);

System.out.println("client ----> IP: " + client.getAddress().getHostAddress() + ", port: " + client.getPort());
System.out.println("receiveBuffer.position() = " + receiveBuffer.position());
if(receiveBuffer.position() >= PACKAGE_SIZE){
receiveBuffer.flip();
DataInputStream dis = new DataInputStream(new ByteArrayInputStream(receiveBuffer.array()));
System.out.println(dis.readInt());
BufferedReader d = new BufferedReader(new InputStreamReader(dis));
System.out.println(d.readLine());

receiveBuffer.clear();
}else{
dc.register(selector, SelectionKey.OP_READ);
}
}//if
}
}//while
} catch (IOException e) {
e.printStackTrace();
}

}

}


Java NIO学习-UDP的例子

这几天需要实现一个底层基于UDP的协议，该协议底层使用UDP传输但是具有拥塞控制、超时重发、数据确认等功能又比TCP简单 （RUDP，Reliable UDP）。在实现协议底层的UDP服务时准备使用Java的NIO，在网上查资料都是以TCP为例讲的，于是自己研究了一下基于UDP的NIO。

NIO的思路是基于多路选择的，即由原来的每个连接都由一个线程来等待消息，改为每个连接都在选择器上注册，由选择器来等待。当然NIO引入了很多新的概念，如Channel，Buffer、Charset、Selector等，使得编程更简洁、更面向对象化。

下面贴出用NIO API改造成UDP示例代码，注意其中使用Charset来编码解码的过程（当然Charset还支持很多其他编码不仅局限于默认编码）以及Buffer的使用。


 package sinpo.usagedemo;   import java.net.DatagramSocket;  import java.net.InetSocketAddress;  import java.net.SocketAddress;  import java.nio.ByteBuffer;  import java.nio.CharBuffer;  import java.nio.channels.DatagramChannel;  import java.nio.channels.SelectionKey;  import java.nio.channels.Selector;  import java.nio.charset.Charset;  import java.util.Iterator;  import java.util.Set;   /**  * @author 徐辛波(sinpo.xu@hotmail.com) Oct 19, 2008  */ public class UDPServer extends Thread {  public void run() {   Selector selector = null;   try {    DatagramChannel channel = DatagramChannel.open();    DatagramSocket socket = channel.socket();    channel.configureBlocking(false);    socket.bind(new InetSocketAddress(5057));     selector = Selector.open();    channel.register(selector, SelectionKey.OP_READ);   } catch (Exception e) {    e.printStackTrace();   }    ByteBuffer byteBuffer = ByteBuffer.allocate(65536);   while (true) {    try {     int eventsCount = selector.select();     if (eventsCount > 0) {      Set selectedKeys = selector.selectedKeys();      Iterator iterator = selectedKeys.iterator();      while (iterator.hasNext()) {       SelectionKey sk = (SelectionKey) iterator.next();       iterator.remove();       if (sk.isReadable()) {        DatagramChannel datagramChannel = (DatagramChannel) sk          .channel();        SocketAddress sa = datagramChannel          .receive(byteBuffer);        byteBuffer.flip();         // 测试：通过将收到的ByteBuffer首先通过缺省的编码解码成CharBuffer 再输出        CharBuffer charBuffer = Charset.defaultCharset()          .decode(byteBuffer);        System.out.println("receive message:"          + charBuffer.toString());        byteBuffer.clear();         String echo = "This is the reply message from 服务器。";        ByteBuffer buffer = Charset.defaultCharset()          .encode(echo);        datagramChannel.write(buffer);       }      }     }    } catch (Exception e) {     e.printStackTrace();    }   }   }   public static void main(String[] args) {   new UDPServer().start();  } } 
Client: 

 package sinpo.usagedemo;  import java.net.InetSocketAddress; import java.net.SocketAddress; import java.nio.ByteBuffer; import java.nio.channels.DatagramChannel; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.charset.Charset; import java.util.Iterator; import java.util.Set;  /**  * @author 徐辛波(sinpo.xu@hotmail.com) Oct 19, 2008  */ public class UDPClient extends Thread {  public void run() {   DatagramChannel channel = null;   Selector selector = null;   try {    channel = DatagramChannel.open();    channel.configureBlocking(false);    SocketAddress sa = new InetSocketAddress("localhost", 5057);    channel.connect(sa);   } catch (Exception e) {    e.printStackTrace();   }    try {    selector = Selector.open();    channel.register(selector, SelectionKey.OP_READ);    channel.write(Charset.defaultCharset().encode("Tell me your time"));   } catch (Exception e) {    e.printStackTrace();   }    ByteBuffer byteBuffer = ByteBuffer.allocate(100);   while (true) {    try {     int eventsCount = selector.select();     if (eventsCount > 0) {      Set selectedKeys = selector.selectedKeys();      Iterator iterator = selectedKeys.iterator();      while (iterator.hasNext()) {       SelectionKey sk = (SelectionKey) iterator.next();       iterator.remove();       if (sk.isReadable()) {        DatagramChannel datagramChannel = (DatagramChannel) sk          .channel();        datagramChannel.read(byteBuffer);        byteBuffer.flip();         // TODO 将报文转化为RUDP消息并调用RUDP协议处理器来处理         System.out.println(Charset.defaultCharset()          .decode(byteBuffer).toString());        byteBuffer.clear();        datagramChannel.write(Charset.defaultCharset()          .encode("Tell me your time"));       }      }     }    } catch (Exception e) {     e.printStackTrace();    }   }   } }

Java异步socket

用异步输入输出流编写Socket进程通信程序 
在Merlin中加入了用于实现异步输入输出机制的应用程序接口 包：java.nio（新的输入输出包，定义了很多基本类型缓冲(Buffer)），java.nio.channels(通道及选择器等，用于异步输入 输出)，java.nio.charset（字符的编码解码）。通道(Channel)首先在选择器(Selector)中注册自己感兴趣的事件，当相应 的事件发生时，选择器便通过选择键(SelectionKey)通知已注册的通道。然后通道将需要处理的信息，通过缓冲（Buffer）打包，编码/解 码,完成输入输出控制。

通道介绍： 
这里主要介绍ServerSocketChannel和 SocketChannel.它们都是可选择的(selectable)通道，分别可以工作在同步和异步两种方式下（注意，这里的可选择不是指可以选择两 种工作方式，而是指可以有选择的注册自己感兴趣的事件）。可以用channel.configureBlocking(Boolean )来设置其工作方式。与以前版本的API相比较，ServerSocketChannel就相当于 ServerSocket(ServerSocketChannel封装了ServerSocket),而SocketChannel就相当于 Socket（SocketChannel封装了Socket）。当通道工作在同步方式时，编程方法与以前的基本相似，这里主要介绍异步工作方式。

所 谓异步输入输出机制，是指在进行输入输出处理时，不必等到输入输出处理完毕才返回。所以异步的同义语是非阻塞（None Blocking）。在服务器端，ServerSocketChannel通过静态函数open()返回一个实例serverChl。然后该通道调用 serverChl.socket().bind()绑定到服务器某端口，并调用register（Selector sel, SelectionKey.OP_ACCEPT）注册OP_ACCEPT事件到一个选择器中（ServerSocketChannel只可以注册 OP_ACCEPT事件）。当有客户请求连接时，选择器就会通知该通道有客户连接请求，就可以进行相应的输入输出控制了；在客户端，clientChl实 例注册自己感兴趣的事件后（可以是OP_CONNECT,OP_READ,OP_WRITE的组合），调用 clientChl.connect(InetSocketAddress )连接服务器然后进行相应处理。注意，这里的连接是异步的，即会立即返回而继续执行后面的代码。

选择器和选择键介绍： 
选择器 （Selector）的作用是：将通道感兴趣的事件放入队列中，而不是马上提交给应用程序，等已注册的通道自己来请求处理这些事件。换句话说，就是选择器 将会随时报告已经准备好了的通道，而且是按照先进先出的顺序。那么，选择器是通过什么来报告的呢？选择键(SelectionKey)。选择键的作用就是 表明哪个通道已经做好了准备，准备干什么。你也许马上会想到，那一定是已注册的通道感兴趣的事件。不错，例如对于服务器端serverChl来说，可以调 用key.isAcceptable()来通知serverChl有客户端连接请求。相应的函数还 有：SelectionKey.isReadable(),SelectionKey.isWritable()。一般的，在一个循环中轮询感兴趣的事件 （具体可参照下面的代码）。如果选择器中尚无通道已注册事件发生，调用Selector.select()将阻塞，直到有事件发生为止。另外，可以调用 selectNow()或者select(long timeout)。前者立即返回，没有事件时返回0值；后者等待timeout时间后返回。一个选择器最多可以同时被63个通道一起注册使用。
应用实例： 
下面是用异步输入输出机制实现的客户/服务器实例程序――程序清单1（限于篇幅，只给出了服务器端实现，读者可以参照着实现客户端代码）： 

程序类图 

import java.io.IOException; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.Socket; import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.channels.SelectableChannel; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.nio.charset.CharacterCodingException; import java.nio.charset.Charset; import java.nio.charset.CharsetDecoder; import java.util.HashMap; import java.util.Iterator; import java.util.Set;  public class NBlockingServer {  int port = 8000;  int BUFFERSIZE = 1024;  Selector selector = null;  ServerSocketChannel serverChannel = null;  HashMap clientChannelMap = null;// 用来存放每一个客户连接对应的套接字和通道   public NBlockingServer(int port) {   this.clientChannelMap = new HashMap();   this.port = port;  }   public void initialize() throws IOException {   // 初始化，分别实例化一个选择器，一个服务器端可选择通道   this.selector = Selector.open();   this.serverChannel = ServerSocketChannel.open();   this.serverChannel.configureBlocking(false);   InetAddress localhost = InetAddress.getLocalHost();   InetSocketAddress isa = new InetSocketAddress(localhost, this.port);   this.serverChannel.socket().bind(isa);// 将该套接字绑定到服务器某一可用端口  }   // 结束时释放资源  public void finalize() throws IOException {   this.serverChannel.close();   this.selector.close();  }   // 将读入字节缓冲的信息解码  public String decode(ByteBuffer byteBuffer) throws CharacterCodingException {   Charset charset = Charset.forName("ISO-8859-1");   CharsetDecoder decoder = charset.newDecoder();   CharBuffer charBuffer = decoder.decode(byteBuffer);   String result = charBuffer.toString();   return result;  }   // 监听端口，当通道准备好时进行相应操作  public void portListening() throws IOException, InterruptedException {   // 服务器端通道注册OP_ACCEPT事件   SelectionKey acceptKey = this.serverChannel.register(this.selector,     SelectionKey.OP_ACCEPT);   // 当有已注册的事件发生时,select()返回值将大于0   while (acceptKey.selector().select() > 0) {    System.out.println("event happened");    // 取得所有已经准备好的所有选择键    Set readyKeys = this.selector.selectedKeys();    // 使用迭代器对选择键进行轮询    Iterator iter = readyKeys.iterator();    while (iter.hasNext()) {     SelectionKey key = (SelectionKey) iter.next();     iter.remove();     if (key.isReadable()) {// 如果是通道读准备好事件      System.out.println("Readable");      // 取得选择键对应的通道和套接字      SelectableChannel nextReady = (SelectableChannel) key        .channel();      Socket socket = (Socket) key.attachment();      // 处理该事件，处理方法已封装在类ClientChInstance中      this.readFromChannel(socket.getChannel(),        (ClientChInstance) this.clientChannelMap          .get(socket));     } else if (key.isWritable()) {// 如果是通道写准备好事件      System.out.println("writeable");      // 取得套接字后处理，方法同上      Socket socket = (Socket) key.attachment();      SocketChannel channel = (SocketChannel) socket.getChannel();      this.writeToChannel(channel, "This is from server!");     }    }   }  }   // 对通道的写操作  public void writeToChannel(SocketChannel channel, String message)    throws IOException {   ByteBuffer buf = ByteBuffer.wrap(message.getBytes());   int nbytes = channel.write(buf);  }   // 对通道的读操作  public void readFromChannel(SocketChannel channel,    ClientChInstance clientInstance) throws IOException,    InterruptedException {   ByteBuffer byteBuffer = ByteBuffer.allocate(BUFFERSIZE);   int nbytes = channel.read(byteBuffer);   byteBuffer.flip();   String result = this.decode(byteBuffer);   // 当客户端发出”@exit”退出命令时，关闭其通道   if (result.indexOf("@exit") >= 0) {    channel.close();   } else {    clientInstance.append(result.toString());    // 读入一行完毕，执行相应操作    if (result.indexOf("/n") >= 0) {     System.out.println("client input" + result);     clientInstance.execute();    }   }  }   // 该类封装了怎样对客户端的通道进行操作，具体实现可以通过重载execute()方法  public class ClientChInstance {   SocketChannel channel;   StringBuffer buffer = new StringBuffer();    public ClientChInstance(SocketChannel channel) {    this.channel = channel;   }    public void execute() throws IOException {    String message = "This is response after reading from channel!";    writeToChannel(this.channel, message);    buffer = new StringBuffer();   }    // 当一行没有结束时，将当前字窜置于缓冲尾   public void append(String values) {    buffer.append(values);   }  }   // 主程序  public static void main(String[] args) {   NBlockingServer nbServer = new NBlockingServer(8000);   try {    nbServer.initialize();   } catch (Exception e) {    e.printStackTrace();    System.exit(-1);   }   try {    nbServer.portListening();   } catch (Exception e) {    e.printStackTrace();   }  } }

小结： 
从 以上程序段可以看出，服务器端没有引入多余线程就完成了多客户的客户/服务器模式。该程序中使用了回调模式(CALLBACK)。需要注意的是，请不要将 原来的输入输出包与新加入的输入输出包混用，因为出于一些原因的考虑，这两个包并不兼容。即使用通道时请使用缓冲完成输入输出控制。该程序在 Windows2000,J2SE1.4下，用telnet测试成功。

传统的Socket是阻塞，像ServerSocket在调用accept方法后便处于阻塞状态等待Client端的连接，所以一般会在Server端使用许多线程，对每一个Socket连接分配一个线程。充分利用并发特性来提高性能。 
但这样会带来许多问题： 
１、Server端创建了许多线程来处理Socket连接，而这些线程大部分的时间都在等待连接， 
也就是说这些线程占了资源，真正做事情的时间却不多。也就是说资源利用率比较低，这就会 
直接导致一个问题，可伸缩性比较差，当接受1000个连接还可以，但增加到10000个或更多时性能会很快下降。像Web服务器Jetty和Tomcat6.x都是用了异步通信模式，来接受客户端的连接，从而很大程度上提高了系统的伸缩性，提高了性能。 
2、由于使用多线程，就会使问题变得复杂，事实如果你敢说精通并发编程，说明你太乐观了，并发编程很容易出错，并且你很难发现问题。并且需要互斥访问一些资源，这往往是个瓶颈，会降低并发性。 
异步的Socket可以解决上面的问题,异步的Socket它是非阻塞的,它尝试去连接,但不管是否能够立即建立连接,它都会立即返回,返回之后它便可以做其他的事情了,但连接真正建立成功,就会有相应的事件来通知,这时候你去做连接成功之后的读写操作了.这个过程,整个线程都是处于忙碌状态,所以只需要单个或者很少几个线程,就可以达到阻塞方式的成百上千的线程的性能. 
类似异步Socket功能应运而生，但Java在jdk1.4才引入这个功能，考虑以前Socket的已提供的功能，而且接口很难一致，Java并没有单独设计异步Socket，而是在java nio中引入了SocketChannel之类的通道来处理这个问题，我们会发现这些通道和对应的Socket提供的接口有很大的相似之处，但这些Channel不是关于Socket的抽象，它们并不处理TCP/UDP协议，而是委托给对Socket来处理。 
这种新的Channel可以在非阻塞的模式下操作。通过注册Selector，使用一种类似观察者模式。其实是Selector不断的轮询连接的端口，我们可以通过Selector的select()方法，这个方法是阻塞的，他会更新就绪操作集的键的数目，并作为返回值返回。我们会通常在判断这个返回值如果不为零，则可能有我们感兴趣的事件发生，然后我们可以通过 

Java代码 
  1. Iterator it = selector.selectedKeys().iterator();  


来得到键的迭代器，这样我们就可以通过遍历这个集合来判断有没有我们感兴趣的事情发生，如果有我们就做一些处理，没有我们可以把这个键remove掉： 

Java代码 
  1. while(it.hasNext()){  
  2.     SelectionKey key = (SelectionKey)it.next();  
  3.     if(key.isAcceptable()){  
  4.        //do something  
  5.       }  
  6.      if(key.isReadable()){  
  7.         //read data           
  8.       }  
  9.     it.remove();//we remove the key beacause of we don't care about it  
  10. }  


一、下面我们介绍一下与Socket相关的各种Channel 
与几种Socket对应的提供了一下几种Channel: 
ServerSocketChannel,SocketChannel,DatagramChannel. 
1、ServerSocketChannel: 

Java代码 
  1. abstract  SocketChannel accept()   
  2.          // 接受到此通道套接字的连接。   
  3. static ServerSocketChannel open()   
  4.          //打开服务器套接字通道。   
  5. abstract  ServerSocket socket()   
  6.           //获取与此通道关联的服务器套接字。   
  7.  int validOps()   
  8.           //返回一个操作集，标识此通道所支持的操作。   


我们发现这个Channel根本不支持读写操作，叫Channel有点名不副实了，但Java中Channel本身的抽象也不一定支持读写操作的，需要实现WriteableChannel和ReadableChannnel接口才能支持。其实ServerSocketChannel本身也不是用于读写 
操作的，它通常通过socket() 方法获取相关的ServerSocket,然后通过ServerSocket 方法bind来绑定端口。ServerSocketChannel提供了open()静态工厂方法来创建ServerSocketChannel对象。同时ServerSocketChannel从AbstractSelectableChannel 
继承了： 

Java代码 
  1. SelectableChannel configureBlocking(boolean block)   
  2.           //调整此通道的阻塞模式。   
  3. SelectionKey register(Selector sel, int ops)   
  4.           //向给定的选择器注册此通道，返回一个选择键。   


这两个方法是最常用的了。通过configureBlocking来设置通道的是否为阻塞模式， 
通过register向给定的选择器注册此通道。 
从上面的过程我们用代码总结一下一般的流程： 

Java代码 
  1.           ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();  
  2.           ServerSocket serverSocket = serverSocketChannel.socket();  
  3.           Selector selector = Selector.open();  
  4.           serverSocket.bind(new InetSocketAddress(port));  
  5.           serverSocketChannel.configureBlocking(false);  
  6.           serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);  
  7.           while (true) {  
  8.           int n  = selector.select();  
  9.           if( n == 0)  
  10.          continue;  
  11.           Iterator it = selector.selectedKeys().iterator();  
  12.           while(it.hasNext()){  
  13.             SelectionKey key = (SelectionKey)it.next();  
  14.                 if(key.isAcceptable()){  
  15.                 ServerSocketChannel server =  
  16.                                 (ServerSocketChannel) key.channel();  
  17.                                 SocketChannel channel = server.accept();//获取SocketChannel来通信  
  18.                                 registerChannel (selector, channel,  
  19. SelectionKey.OP_READ);       doSomething(channel);  
  20.                 }  
  21.                 if(key.isReadable()){  
  22.                     readDataFormSocket(key);  
  23.                 }  
  24.                 it.remove();  
  25.             }  
  26.           }  


2、SocketChannel： 
SocketChannel通常作为客户端，建立一个对Server端的连接，任何一个SocketChannel 
都是和对应的Socket关联的，但一个Socket并不一定有SocketChannel可以获得。 
同样的SocketChannel也适用静态工厂方法open()来实例化SocketChannel. 
下面来看看最常用的操作： 

引用

public abstract boolean connect(SocketAddress remote) 
                         throws IOException连接此通道的套接字。 
如果此通道处于非阻塞模式，则调用此方法会发起一个非阻塞连接操作。如果立即建立连接（使用本地连接时就是如此），则此方法返回 true。否则此方法返回 false，并且必须在以后通过调用 finishConnect 方法来完成该连接操作。 


我们可以通过 

Java代码 
  1. socketChannel.connect (new InetSocketAddress ("somehost", somePort));  


来建立连接，这个过程是异步的，他会立即返回，如果立即建立连接成功则返回true,否则 
返回false.随后可以通过finishConnect来完成连接的建立。 
另外可通过： 

Java代码 
  1. SocketChannel socketChannel =  
  2. SocketChannel.open (new InetSocketAddress ("somehost", somePort));  

建立连接 
等价于： 

Java代码 
  1. SocketChannel socketChannel = SocketChannel.open();  
  2. socketChannel.connect (new InetSocketAddress ("somehost", somePort));  


下面我们演示一下整个的使用过程： 

Java代码 

    新的改变

    我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：

    1. 全新的界面设计 ，将会带来全新的写作体验；
    2. 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
    3. 增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
    4. 全新的 KaTeX数学公式 语法；
    5. 增加了支持甘特图的mermaid语法1 功能；
    6. 增加了 多屏幕编辑 Markdown文章功能；
    7. 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
    8. 增加了 检查列表 功能。

    功能快捷键

    撤销：Ctrl/Command + Z
    重做：Ctrl/Command + Y
    加粗：Ctrl/Command + B
    斜体：Ctrl/Command + I
    标题：Ctrl/Command + Shift + H
    无序列表：Ctrl/Command + Shift + U
    有序列表：Ctrl/Command + Shift + O
    检查列表：Ctrl/Command + Shift + C
    插入代码：Ctrl/Command + Shift + K
    插入链接：Ctrl/Command + Shift + L
    插入图片：Ctrl/Command + Shift + G

    合理的创建标题，有助于目录的生成

    直接输入1次#，并按下space后，将生成1级标题。
    输入2次#，并按下space后，将生成2级标题。
    以此类推，我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。

    如何改变文本的样式

    强调文本 强调文本

    加粗文本 加粗文本

    标记文本

    删除文本

    引用文本

    H2O is是液体。

    210 运算结果是 1024.

    插入链接与图片

    链接: link.

    图片: Alt

    带尺寸的图片: Alt

    当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。

    如何插入一段漂亮的代码片

    去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

    // An highlighted block var foo = 'bar';

    生成一个适合你的列表

    • 项目
      • 项目
        • 项目
    1. 项目1
    2. 项目2
    3. 项目3
    • 计划任务
    • 完成任务

    创建一个表格

    一个简单的表格是这么创建的：

    项目Value
    电脑$1600
    手机$12
    导管$1

    设定内容居中、居左、居右

    使用:---------:居中
    使用:----------居左
    使用----------:居右

    第一列第二列第三列
    第一列文本居中第二列文本居右第三列文本居左

    SmartyPants

    SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：

    TYPEASCIIHTML
    Single backticks'Isn't this fun?'‘Isn’t this fun?’
    Quotes"Isn't this fun?"“Isn’t this fun?”
    Dashes-- is en-dash, --- is em-dash– is en-dash, — is em-dash

    创建一个自定义列表

    Markdown
    Text-to- HTML conversion tool
    Authors
    John
    Luke

    如何创建一个注脚

    一个具有注脚的文本。2

    注释也是必不可少的

    Markdown将文本转换为 HTML。

    KaTeX数学公式

    您可以使用渲染LaTeX数学表达式 KaTeX:

    Gamma公式展示 Γ ( n ) = ( n − 1 ) ! ∀ n ∈ N \Gamma(n) = (n-1)!\quad\forall n\in\mathbb N Γ(n)=(n−1)!∀n∈N 是通过欧拉积分

    Γ ( z ) = ∫ 0 ∞ t z − 1 e − t d t &ThinSpace; . \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,. Γ(z)=∫0∞​tz−1e−tdt.

    你可以找到更多关于的信息 LaTeX 数学表达式here.

    新的甘特图功能，丰富你的文章

    gantt
        dateFormat  YYYY-MM-DD
        title Adding GANTT diagram functionality to mermaid
        section 现有任务
        已完成               :done,    des1, 2014-01-06,2014-01-08
        进行中               :active,  des2, 2014-01-09, 3d
        计划一               :         des3, after des2, 5d
        计划二               :         des4, after des3, 5d
    • 关于 甘特图 语法，参考 这儿,

    UML 图表

    可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：:

    张三 李四 王五 你好！李四, 最近怎么样? 你最近怎么样，王五？ 我很好，谢谢! 我很好，谢谢! 李四想了很长时间, 文字太长了 不适合放在一行. 打量着王五... 很好... 王五, 你怎么样? 张三 李四 王五

    这将产生一个流程图。:

    链接
    长方形
    圆
    圆角长方形
    菱形
    • 关于 Mermaid 语法，参考 这儿,

    FLowchart流程图

    我们依旧会支持flowchart的流程图：

    • 关于 Flowchart流程图 语法，参考 这儿.

    导出与导入

    导出

    如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。

    导入

    如果你想加载一篇你写过的.md文件或者.html文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，
    继续你的创作。

    1. mermaid语法说明 ↩︎

    2. 注脚的解释 ↩︎

    这是晾衣服的地方吗
    关注
    java socket 阻塞模式_（四） 如何将socket设置为非阻塞模式
    weixin_39633090的博客
    02-12 991
    1. windows平台上无论利用socket()函数还是WSASocket()函数创建的socket都是阻塞模式的：SOCKET WSAAPI socket( _In_ int af, _In_ int type, _In_ int protocol ); SOCKET WSASocket( _In_ int af, ...
    Java实现简单的阻塞队列2种方式
    06-10
    Java实现简单的阻塞队列2种方式，1使用wait()，notify();2使用countdownlatch实现
    Java 中的阻塞 IO 和非阻塞 IO
    ✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
    07-10 5236
    IO（输入输出）操作是一个基础而又关键的部分。在 Java 中，处理 IO 通常涉及到阻塞 IO 和非阻塞 IO 两种模式。本文将介绍这两种模式的概念、特点以及在 Java 编程中的应用场景与区别。
    TCP同步与异步及阻塞模式，多线程+阻塞模式，非阻塞模式简单介绍
    weixin_34160277的博客
    08-14 144
    首先我简单介绍一下同步TCP编程 与异步TCP编程。 在服务端我们通常用一个TcpListener来监听一个IP和端口。客户端来一个请求的连接，在服务端可以用同步的方式来接收，也可以用异步的方式去接收。比如： TcpListene server = new TcpListener(IPAddress.Parse("127.0.0.1"), port); TcpClien...
    TCP/IP总结1：阻塞socket和非阻塞socket
    热门推荐
    pingnanlee的专栏
    07-21 2万+
    序：前段时间狂看了很多关于网络编程的资料，这里自己总结一下，以便自己以后可以参考。 什么是阻塞socket，什么是非阻塞socket。对于这个问题，我们要先弄清什么是阻塞/非阻塞。阻塞与非阻塞是对一个文件描述符指定的文件或设备的两种工作方式。 阻塞的意思是指，当试图对该文件描述符进行读写时，如果当时没有东西可读或者暂时不可写，程序就进入等待状态，直到有东西可读或者可写为止。 非阻塞的意思是，
    Java实现阻塞队列的两种方式
    weixin_33824363的博客
    09-09 282
    方式一：importjava.util.PriorityQueue; /** *使用非阻塞队列PriorityQueue以及notify(),wait()机制实现一个阻塞队列 *@authoruser * */ publicclassMyBlockingQueue{ publicfinalstaticintqueueSize=1...
    java解读NIOSocket非阻塞模式.zip
    09-02
    jdk供的无阻塞I/O（NIO）有效解决了多线程服务器存在的线程开销问题，但在使用上略显得复杂一些。在NIO中使用多线程，主要目的已不是为了应对每个客户端请求而分配独立的服务...非阻塞的NIO有何神秘之处？直接上代码！
    【Java设计模式】基于事件的异步模式：掌握非阻塞系统设计
    最新发布
    08-31
    基于事件的异步模式允许系统处理可能需要一些时间才能完成的任务，而不会阻塞程序的执行。它通过释放原本会被阻塞等待任务完成的线程，从而实现更好的资源利用。 ## 二、详细解释及实际示例 1. **实际示例**： - ...
    java 中同步、异步、阻塞和非阻塞区别详解
    08-30
    而非阻塞模式下，`send`会立即返回失败状态，`recv`则会告知没有数据可读，这样线程可以继续处理其他任务，提高了系统并发能力。 总的来说，选择同步还是异步、阻塞还是非阻塞取决于具体的应用场景和性能需求。同步...
    让人一看就会的java阻塞队列与非阻塞队列
    m0_73533108的博客
    09-04 909
    今天要来讲一下java里的队列，队列，顾名思义，排队的列，既然按排队形来做的话，生活中的银行排队啊，上车排队啊，都是先到先办理或者先上车，队列存取数据列也一样，这就是先进先出，使用队列的规则是：使用队素时，数据元素只能从表的一端进入队列，另一端出队列。
    基于VS2010的 TCP协议连接的例子，包括阻塞和非阻塞方式
    03-25
    基于VS2010 使用TCP协议进行网口连接的例子，包括阻塞和非阻塞方式，以及超时设置，使用非阻塞方式进行连接，使用阻塞方式进行收发
    Linux下的Socket编程实例(阻塞和非阻塞)
    06-05
    Linux下基于C/C++的Socket的阻塞和异步编程实例
    3.tcp中的阻塞与非阻塞
    houshaoyun的博客
    04-26 1587
                   struct timeval timeout = {10, 0}; int err = 0x00; err = setsockopt(client_fd, SOL_SOCKET, SO_SNDTIMEO,(const char*)&amp;timeout, sizeof(timeout)); if(err != 0x00){...
    【TCP/IP Socket】Socket的阻塞与非阻塞
    10-26 160
    阻塞与非阻塞
    tcp 阻塞与非阻塞
    dragon_cdut的博客
    08-05 3740
    原文地址：http://blog.chinaunix.net/uid-8489474-id-2031025.html tcp协议本身是可靠的,并不等于应用程序用tcp发送数据就一定是可靠的.不管是否阻塞,send发送的大小,并不代表对端recv到多少的数据. 在阻塞模式下, send函数的过程是将应用程序请求发送的数据拷贝到发送缓存中发送就返回.但由于发送缓存的存在,表现为:如果发送缓存大小比请求发送的大小要大,那么send函数立即返回,同时向网络中发送数据;否则,send会等待接收端对之前发送数据的确认
    TCP阻塞与非阻塞优缺点
    老赵的博客
    10-12 725
    这几篇博客比较好，分享记录下： 1.阻塞与非阻塞socket的优缺点_modi000的博客-CSDN博客_阻塞与非阻塞的特点 2.TCP客户端判断与服务端断开连接的几种方法_话小兵的博客-CSDN博客_epoll检测tcp断开
    TCP、UDP的阻塞和非阻塞模式
    lzg_na的博客
    08-24 8655
    前言 socket在默认情况下是阻塞状态的，这就使得发送和接受都处于阻塞状态; TCP协议下发送选用send，UDP协议下，发送选用sendto. TCP协议下接收选用recv，UDP协议下，接收选用recvfrom. 一、阻塞模式&&send 假设发送缓冲区大小为4096KB,其中已经使用4000KB空间，剩余96KB空间；现在又有200KB的数据需要发送，则只能先将96KB的数据放入发送缓冲区但不发送（阻塞），直到缓冲区空出空间足够放入剩余104KB，再send操作将这200子节发送
    Java网络编程：阻塞与非阻塞模式解析
    在非阻塞模式下，线程可以继续处理其他任务，而不用等待I/O操作完成，从而提高了系统的并发性能。 在给出的代码示例中，服务器端使用了阻塞I/O来处理客户端的连接。`getReader()`和`getWriter()`方法分别创建了`...
    评论
    添加红包

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

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

    抵扣说明：

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

    余额充值