标签: serversocket

我需要一个简单的客户端 - 服务器通信才能实现单元测试.

我的步骤:

1. 创建服务器线程
2. 等待服务器线程将服务器套接字置于监听模式(serverSocket.accept())
3. 创建客户端
4. 提出一些要求,验证回复

基本上,我对第2步有问题.当服务器套接字处于"监听"状态时,我找不到向我发信号的方法.在这种情况下,对"accept"的异步调用会起作用,但是java不支持这种情况(它似乎只支持异步通道,而且根据文档,它们与"accept()"方法不兼容).

因为我可以放一个简单的"睡眠",但这并不是生产代码的真正解决方案.

因此,总而言之,我需要检测ServerSocket何时进入侦听模式而不使用睡眠和/或轮询.

我们正在开始在.Net 中设计可扩展的多线程套接字推送服务器,它最初将为每个节点处理10K个客户端.由于设计这可能非常复杂,如果所有专家都可以提供任何指导,资源,最佳实践等,那将对我有所帮助.

由于我对套接字编程知之甚少,如果有人可以建议我开源的开源项目真的很好......我用Google搜索,但找不到任何好的解决方案.

这对于想要设计此类服务器的其他人也很有帮助.

[为了您的信息,我们计划为此服务器使用.Net 4.0]

我一直在阅读有关Async Socket及其Pinning相关问题的大量信息.这个问题在.Net 4.0中是否仍然存在？

提前致谢...

我在linux中使用服务器套接字,我需要关闭它并在time_wait TCP状态到期之前重新打开.我在绑定之前设置了服务器套接字的重用地址选项,但它仍然抛出BindException.我也试过这个http://meteatamel.wordpress.com/2010/12/01/socket-reuseaddress-property-and-linux/,但它仍然不起作用.

要打开服务器套接字我使用:

ServerSocket ss = new ServerSocket();
ss.setReuseAddress(true);
ss.bind(new InetSocketAddress(12345));

并关闭:

ss.close();

"已经在使用的地址"BindException在绑定调用时被抛出.

此代码生成异常:

for (int i = 0; i < 2; i++) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    final ServerSocket ss = new ServerSocket();
                    ss.setReuseAddress(true);
                    ss.bind(new InetSocketAddress(12345));
                    Socket s = ss.accept();
                    System.out.println((char) s.getInputStream().read());
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        Thread.sleep(500);
        Socket s = new Socket("localhost", 12345);
        s.getOutputStream().write('c');
    }

我的metod receiveArrayLists中有一个arraylist,我想添加到JList中.我怎样才能做到这一点？

import java.awt.Dimension;
import java.awt.Scrollbar;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class GUI implements Runnable {

private Server server;
private JFrame frame = new JFrame();
private JTextField jtf = new JTextField();
private JList jl = new JList();
private JTextArea jl1 …

我目前正在学校参与一个项目,我们正在建立一个用于Android手机的通信系统.为此,我们将使用一个服务器向所有客户端打开套接字,使它们进行通信.

我之前已经完成了几个聊天应用程序,没有任何套接字或线程处理问题,但这一次,出于某种原因,它让我感到困惑.

问题是,一旦我启动ServerSocket对象,应用程序就会开始监听serverSocket = new ServerSocket(5000),而不是在serverSocket.accept().

这是为什么？

只要我使用以下方法:

public void startListen(String port) {
try {
    serverSocket = new ServerSocket(Integer.parseInt(port));
    portField.setEditable(false);
} catch (IOException e) {
    printMessage("Failed to initiate serverSocket: " + e.toString());
}}

端口在命令提示符(使用netstat)中显示为Listening .如果我不调用它,则端口不会被列为侦听.

TCP 0.0.0.0:5000计算机:0聆听

那么,在使用该ServerSocket对象时,我在这里缺少什么吗？我使用的旧程序ServerSocket在我打电话之前都没有开始听accept().

我正在创建一个服务器应用程序,它执行以下任务

• 接受客户端的连接
• 处理每个客户端连接到单独的线程
• 从客户端接收数据
• 将数据发送到客户端

我能够连接客户端但无法从客户端接收数据

只有当客户端断开连接时才能在我的控制台中看到数据.. !!!

代码: -

public class ServerListener {

    public static void main(String[] args) {
        new ServerListener().startServer();
    }

    public void startServer() {
        final ExecutorService clientProcessingPool = Executors
                .newFixedThreadPool(10);

        Runnable serverTask = new Runnable() {
            @Override
            public void run() {
                try {
                    ServerSocket serverSocket = new ServerSocket(8000);
                    System.out.println("Waiting for clients to connect...");
                    while (true) {
                        Socket clientSocket = serverSocket.accept();
                        clientProcessingPool
                                .submit(new ClientTask(clientSocket));
                    }
                } catch (IOException e) {
                    System.err.println("Unable to process client request");
                    e.printStackTrace();
                }
            } …

双方的ServerSocket和插座有方法close()关闭套接字.

两者有什么区别？

假设,在服务器端,

ServerSocket serverSocket = new ServerSocket(port);
Socket socket = serverSocket.accept();  
...

在这种情况下,怎么样

socket.close();

不同于

serverSocket.close();

如果有的话？

TIA.

我打算为我的应用程序添加一个直接的无服务器点对点语音传输功能，从我的想法来看，每个客户端都需要一个服务器套接字（？）和客户端套接字（？）来按需建立连接，其余的必须与编写语音相同文件，而是在 tcp 上写入 (socket?) 。但由于它是一个很长的镜头，我需要更多的帮助，比如 2 个套接字可以同时发送和接收吗？或者更重要的是，socket 可以继续读取并更新输出吗？或者有什么更好的办法？有什么建议？

我是套接字编程的新手，我在理解 serversocket 时遇到了问题。假设我们创建了一个这样的 serversocket：

loadbalancerSocket = new ServerSocket(port, 20);
connection = loadbalancerSocket.accept();

然后在一些东西之后，在它的缓冲区中写一些东西：

BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(connection.getOutputStream()));
                writer.write("Hello!");
                writer.flush();
                writer.close();

我的问题是：连接如何理解哪个客户端应该得到服务器的响应？我们的积压是 20 ，并且 20 个客户端可以同时连接到服务器套接字（据我了解）。

背景

• 我想使用Java的非阻塞SocketChannel发送大量(30MB,但将来可能会大得多)数据量
  • 为什么不阻塞？这样就不会阻止计算要发送的下一个字节等待网络
• 当我在阻塞模式下使用SocketChannel时,传输完成没有问题
• 当我设置的SocketChannel非阻塞,它完成显著快,但服务器没有收到所有数据
  • 但是,服务器确实收到了一些数据

题

• 为什么我的大(30MB)文件传输在使用非阻塞Java NIO SocketChannel时失败,我该如何解决？

档

• 我扼杀了程序并编写了示例,以便它可以一次性运行 javac *.java && java Main

  • 它为服务器创建了Future,为客户端创建了Future,让客户端向服务器发送30MB的随机字节,然后在主线程上阻塞,直到两个Futures完成(尽管服务器从未这样做)

• 注意:这主要是关于TheClient.java

  • 如果意见之间的界限<CommentOutToMakeWork>,并</CommentOutToMakeWork>已被注释掉,在一个SocketChannel将被阻塞和传输将完成

Main.java:

import java.io.IOException;
import java.lang.InterruptedException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
  public static void main(String[] args) throws ExecutionException, IOException, InterruptedException {
    final SocketAddress address = new InetSocketAddress("127.0.0.1", 12345);
    final int size              = 30 * 1000 * 1000;

    ExecutorService executor …