- iOS/Objective-C 元类和类别
- objective-c - -1001 错误,当 NSURLSession 通过 httpproxy 和/etc/hosts
- java - 使用网络类获取 url 地址
- ios - 推送通知中不播放声音
我目前正在将 java.nio.channel.Selectors & SocketChannels 用于将打开一对多连接以继续流式传输到服务器的应用程序。我的应用程序有三个线程:StreamWriteWorker - 对 SocketChannel 执行写入操作,StreamReadWorker - 从缓冲区读取字节并解析内容,StreamTaskDispatcher - 执行 Selector 对 readyOps 的选择并为工作线程分派(dispatch)新的可运行对象。
问题 - 对选择器的选择方法的调用在第一次调用时仅返回一个 > 0 的值(有效的 readyOps);我能够一次性在所有就绪 channel 上执行写入和发送数据,但以下所有选择器选择方法的调用都返回 0。
问题:我是否需要在每次读/写后调用关闭 SocketChannel(我希望不需要!)?如果不是,是什么原因导致 SocketChannels 不可用于任何读/写操作?
很抱歉我不能发布代码,但我希望我已经足够清楚地解释了问题以便有人提供帮助。我已经搜索了答案,我看到您无法在关闭后重用 SocketChannel 连接,但我的 channel 不应该关闭,服务器永远不会收到 EOF 流结果。
我取得了一些进展,发现由于 json 解析错误,写操作没有在服务器应用程序上发生。因此,现在客户端应用程序代码上的 SocketChannel 在处理读取操作后准备好进行另一次写入操作。我猜这是 SocketChannels 的 TCP 特性。但是,SocketChannel 不能用于服务器应用程序端的另一个读取操作。这是 SocketChannels 的正常行为吗?读取操作后是否需要在客户端关闭连接并建立新连接?
这是我正在尝试做的代码示例:
package org.stream.socket;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CodingErrorAction;
import java.util.HashMap;
import java.util.Iterator;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import org.apache.commons.lang3.RandomStringUtils;
import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.JsonPrimitive;
import com.google.gson.stream.JsonToken;
public class ClientServerTest {
private LinkedBlockingQueue<byte[]> dataQueue = new LinkedBlockingQueue<byte[]>();
private ExecutorService executor = Executors.newFixedThreadPool(1);
private HashMap<String, Integer> uuidToSize = new HashMap<String, Integer>();
private class StreamWriteTask implements Runnable {
private ByteBuffer buffer;
private SelectionKey key;
private Selector selector;
private StreamWriteTask(ByteBuffer buffer, SelectionKey key, Selector selector) {
this.buffer = buffer;
this.key = key;
this.selector = selector;
}
@Override
public void run() {
SocketChannel sc = (SocketChannel) key.channel();
byte[] data = (byte[]) key.attachment();
buffer.clear();
buffer.put(data);
buffer.flip();
int results = 0;
while (buffer.hasRemaining()) {
try {
results = sc.write(buffer);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (results == 0) {
buffer.compact();
buffer.flip();
data = new byte[buffer.remaining()];
buffer.get(data);
key.interestOps(SelectionKey.OP_WRITE);
key.attach(data);
selector.wakeup();
return;
}
}
key.interestOps(SelectionKey.OP_READ);
key.attach(null);
selector.wakeup();
}
}
private class StreamReadTask implements Runnable {
private ByteBuffer buffer;
private SelectionKey key;
private Selector selector;
private StreamReadTask(ByteBuffer buffer, SelectionKey key, Selector selector) {
this.buffer = buffer;
this.key = key;
this.selector = selector;
}
private boolean checkUUID(byte[] data) {
return uuidToSize.containsKey(new String(data));
}
@Override
public void run() {
SocketChannel sc = (SocketChannel) key.channel();
buffer.clear();
byte[] data = (byte[]) key.attachment();
if (data != null) {
buffer.put(data);
}
int count = 0;
int readAttempts = 0;
try {
while ((count = sc.read(buffer)) > 0) {
readAttempts++;
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (count == 0) {
buffer.flip();
data = new byte[buffer.limit()];
buffer.get(data);
if (checkUUID(data)) {
key.interestOps(SelectionKey.OP_READ);
key.attach(data);
} else {
System.out.println("Clinet Read - uuid ~~~~ " + new String(data));
key.interestOps(SelectionKey.OP_WRITE);
key.attach(null);
}
}
if (count == -1) {
try {
sc.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
selector.wakeup();
}
}
private class ClientWorker implements Runnable {
@Override
public void run() {
try {
Selector selector = Selector.open();
SocketChannel sc = SocketChannel.open();
sc.configureBlocking(false);
sc.connect(new InetSocketAddress("127.0.0.1", 9001));
sc.register(selector, SelectionKey.OP_CONNECT);
ByteBuffer buffer = ByteBuffer.allocateDirect(65535);
while (selector.isOpen()) {
int count = selector.select(10);
if (count == 0) {
continue;
}
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
while (it.hasNext()) {
final SelectionKey key = it.next();
it.remove();
if (!key.isValid()) {
continue;
}
if (key.isConnectable()) {
sc = (SocketChannel) key.channel();
if (!sc.finishConnect()) {
continue;
}
sc.register(selector, SelectionKey.OP_WRITE);
}
if (key.isReadable()) {
key.interestOps(0);
executor.execute(new StreamReadTask(buffer, key, selector));
}
if (key.isWritable()) {
key.interestOps(0);
if(key.attachment() == null){
key.attach(dataQueue.take());
}
executor.execute(new StreamWriteTask(buffer, key, selector));
}
}
}
} catch (IOException ex) {
// Handle Exception
}catch(InterruptedException ex){
}
}
}
private class ServerWorker implements Runnable {
@Override
public void run() {
try {
Selector selector = Selector.open();
ServerSocketChannel ssc = ServerSocketChannel.open();
ServerSocket socket = ssc.socket();
socket.bind(new InetSocketAddress(9001));
ssc.configureBlocking(false);
ssc.register(selector, SelectionKey.OP_ACCEPT);
ByteBuffer buffer = ByteBuffer.allocateDirect(65535);
DataHandler handler = new DataHandler();
while (selector.isOpen()) {
int count = selector.select(10);
if (count == 0) {
continue;
}
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
while (it.hasNext()) {
final SelectionKey key = it.next();
it.remove();
if (!key.isValid()) {
continue;
}
if (key.isAcceptable()) {
ssc = (ServerSocketChannel) key.channel();
SocketChannel sc = ssc.accept();
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_READ);
}
if (key.isReadable()) {
handler.readSocket(buffer, key);
}
if (key.isWritable()) {
handler.writeToSocket(buffer, key);
}
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
private class DataHandler {
private JsonObject parseData(StringBuilder builder) {
if (!builder.toString().endsWith("}")) {
return null;
}
JsonParser parser = new JsonParser();
JsonObject obj = (JsonObject) parser.parse(builder.toString());
return obj;
}
private void readSocket(ByteBuffer buffer, SelectionKey key)
throws IOException {
SocketChannel sc = (SocketChannel) key.channel();
buffer.clear();
int count = Integer.MAX_VALUE;
int readAttempts = 0;
try {
while ((count = sc.read(buffer)) > 0) {
readAttempts++;
}
} catch (IOException e) {
e.printStackTrace();
}
if (count == 0) {
buffer.flip();
StringBuilder builder = key.attachment() instanceof StringBuilder ? (StringBuilder) key
.attachment() : new StringBuilder();
Charset charset = Charset.forName("UTF-8");
CharsetDecoder decoder = charset.newDecoder();
decoder.onMalformedInput(CodingErrorAction.IGNORE);
System.out.println(buffer);
CharBuffer charBuffer = decoder.decode(buffer);
String content = charBuffer.toString();
charBuffer = null;
builder.append(content);
System.out.println(content);
JsonObject obj = parseData(builder);
if (obj == null) {
key.attach(builder);
key.interestOps(SelectionKey.OP_READ);
} else {
System.out.println("data ~~~~~~~ " + builder.toString());
JsonPrimitive uuid = obj.get("uuid").getAsJsonPrimitive();
key.attach(uuid.toString().getBytes());
key.interestOps(SelectionKey.OP_WRITE);
}
}
if (count == -1) {
key.attach(null);
sc.close();
}
}
private void writeToSocket(ByteBuffer buffer, SelectionKey key)
throws IOException {
SocketChannel sc = (SocketChannel) key.channel();
byte[] data = (byte[]) key.attachment();
buffer.clear();
buffer.put(data);
buffer.flip();
int writeAttempts = 0;
while (buffer.hasRemaining()) {
int results = sc.write(buffer);
writeAttempts++;
System.out.println("Write Attempt #" + writeAttempts);
if (results == 0) {
buffer.compact();
buffer.flip();
data = new byte[buffer.remaining()];
buffer.get(data);
key.attach(data);
key.interestOps(SelectionKey.OP_WRITE);
break;
}
}
key.interestOps(SelectionKey.OP_READ);
key.attach(null);
}
}
public ClientServerTest() {
for (int index = 0; index < 1000; index++) {
JsonObject obj = new JsonObject();
String uuid = UUID.randomUUID().toString();
uuidToSize.put(uuid, uuid.length());
obj.addProperty("uuid", uuid);
String data = RandomStringUtils.randomAlphanumeric(10000);
obj.addProperty("event", data);
dataQueue.add(obj.toString().getBytes());
}
Thread serverWorker = new Thread(new ServerWorker());
serverWorker.start();
Thread clientWorker = new Thread(new ClientWorker());
clientWorker.start();
}
/**
* @param args
*/
public static void main(String[] args) {
ClientServerTest test = new ClientServerTest();
for(;;){
}
}
}
最佳答案
处理 OP_CONNECT
的正确方法是尝试一次 finishConnect()
,如果成功,注销 OP_CONNECT
并注册 OP_READ
或 OP_WRITE
,可能是后者,因为您是客户。在非阻塞模式下循环和 hibernate 没有意义。如果 finishConnect()
返回 false,OP_CONNECT
将再次触发。
您对 !key.isAcceptable()
、!key.isReadable()
和 !key.isWriteable()
的处理> 绝对没有任何意义。如果 key 是可接受的,则调用 accept()
。如果可读,调用 read()
。如果它是可写的,调用 write()
。就这么简单。
您需要注意 channel 几乎总是可写的,除了套接字发送缓冲区已满的短暂时间。因此,只有在您有要写的东西时才注册 OP_WRITE
,或者更好的是在您已经尝试写入并获得零返回之后;然后当 OP_WRITE
触发时,重试写入并取消注册 OP_WRITE
除非你得到另一个零。
您使用 ByteBuffer
太省钱了。实际上,您每个 channel 都需要一个。您可以将其保存为 key 附件,以便在需要时取回。否则,您将无法累积肯定会发生的部分读取,也无法以任何方式重试写入。
关于用于继续流式传输的 java.nio 选择器和 SocketChannel,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/10716057/
我知道 SocketChannel 通过在调用 read() 后接收到“-1”来“通知”有序关闭的连接。 但是它如何通知我有关无序关闭的连接呢? (作为整个基于 NIO 的服务器的一部分,使用选择器和
我尝试在两个不同的线程(Android API 级别 25)中同时使用 SocketChannel.write 和 SocketChannel.read。 我将 SocketChannel 配置为阻塞
根据文档,我可以这样做: SocketChannel mySocketChannel = new SocketChannel(SelectorProvider.provider()); 根据 JDK,
我正在用Java开发多线程非阻塞tcp服务器和客户端。我在服务器意识到客户端套接字已关闭时遇到问题。对他来说一切都是开放的。这是代码和我的代码的输出: 服务器: /* * To change thi
我正在编写一个聊天室服务器,它从聊天客户端获取消息并将该消息广播给所有用户。这是《Java 网络编程简介:Java 7 兼容》一书中的一个练习,我正在自学 Java 网络基础知识。我按照书中代码的示例
我构建了一个客户端(SocketChannel),它正在获取大消息(每条消息的大小约为 1MB-2MB)。我怎样才能收到消息?我正在使用选择器。当键为Readable时,我想读取接收消息的所有数据包。
我正在尝试通过 SocketChannel 发送数据(400016 字节)。由于某种原因,并未发送所有数据。 (我希望看到所有 400016 字节都将被发送) 代码如下:公共(public) bool
我编写了一个应用程序,它通过 TCP 和 SocketChannel 连接到服务器但我有两个问题: 第一个是次要的 - 有时出于某种未知的原因我会发送串联的消息, 第二个至关重要 - 应用会定期停止发
假设我们有一个打开的 SocketChannel。在终止应用程序之前明确关闭它很重要吗?换句话说,如果我们不这样做,是否存在留下未关闭的系统资源的风险? 最佳答案 假设您的操作系统是一个现代的多用户操
这是我的代码。从测试服务器,我尝试通过输出流发送数据并从测试客户端接收数据。我使用 SocketChannel 是因为我需要客户端同时监听 3 个端口。目前,我只想从一个套接字读取数据。但是它似乎没有
我再次遇到 Android 套接字编程方面的问题。我的问题是 Selector.select() 返回零,表示没有准备好写入的 SocketChannels。同样的代码同样适用于普通的 Java,但不
我正在使用套接字 channel 和 NIO 概念从客户端读取数据。 Socket Channel 如何知道文件读取完成? ByteBuffer byteBuffer = ByteBuffer.all
我创建了一个到远程服务器的 SocketChannel,以便在 Tomcat 上发送和接收消息。为了从远程计算机接收消息,我使用了一个专用于任务的线程(只有这个线程将从套接字读取,没有其他线程)。 当
我有一个正在运行的套接字,使用选择器。我正在尝试检查我的套接字是否已连接到服务器。 Boolean connected = _channel.isConnected(); 它总是返回真。我关闭了计算机
我想使用 SocketChannel 并为其读/写方法设置超时。我试过为拥有我的 SocketChannel 的套接字设置超时,如下所示: channel.socket().setSoTimeout(
我正在努力理解 SocketChannels , 和 NIO一般来说。我知道如何使用常规套接字以及如何制作一个简单的每个客户端线程服务器(使用常规阻塞套接字)。 所以我的问题: 什么是 SocketC
我刚刚写了一些 NIO 代码,想知道如何对我的实现进行压力测试 SocketChannel.write(ByteBuffer) 无法写入整个字节缓冲区 SocketChannel.read(ByteB
我们有一个带有 https 的服务器,它在端口 443 上运行。我想从服务器读取字节。我正在使用以下代码。 private void openAndConfigureChannel(Selector
这个问题已经有答案了: when I use nio, serverSocket.accept() throws IllegalBlockingModeException (3 个回答) 已关闭 4
我的应用程序有一个队列,其中包含“传出网络数据包”(带有 ByteBuffer 和 SocketChannel 的 POJO),由将数据写入的单个线程使用SocketChannel。 我这样做是为了保
我是一名优秀的程序员,十分优秀!