标签: multiplexing

如何在C++中创建客户端UDP套接字,以便它可以侦听另一个应用程序正在侦听的端口？换句话说,如何在C++中应用端口多路复用？

我正在开发一个嵌入式项目,我需要一个没有外部依赖项的程序,它可以像screen或tmux一样工作.这两个程序并不好,因为它们需要其他库.

因为我只需要分离一个程序,当我再次登录时能够注销并取回它,我想知道我是否可以为此编写一个小程序.

你知道我需要做哪些调用(在C中)来分离程序并将其恢复吗？

服务器代码：

            TMultiplexedProcessor processor = new TMultiplexedProcessor();

            processor.registerProcessor(
                "AddService",
                new AddService.Processor(new AddHandler()));

            processor.registerProcessor(
                "MultiplyService",
                new MultiplyService.Processor(new MultiplyHandler()));

            TServerTransport serverTransport = new TServerSocket(7911);



            TSimpleServer server = new TSimpleServer(new TSimpleServer.Args(serverTransport).
                   processor(processor));

            System.out.println("Starting server on port 7911 ...");
            server.serve();

客户代码：

    TFramedTransport transport;

   transport = new TFramedTransport(new TSocket("localhost", 7911));  
   transport.open();  


   TProtocol protocol = new TBinaryProtocol(transport);

   System.out.println("1");
   TMultiplexedProtocol mp = new TMultiplexedProtocol(protocol, "AddService");
   AddService.Client service = new AddService.Client(mp);

   System.out.println("2");
   TMultiplexedProtocol mp2 = new TMultiplexedProtocol(protocol, "MultiplyService");
   MultiplyService.Client service2 = new MultiplyService.Client(mp2);

   System.out.println("3");

   System.out.println(service.add(2,2));
   System.out.println(service2.multiply(2000,200));

但是当我运行服务器（侦听端口 7911）和客户端时，客户端不会处理对加/乘函数的最后两次调用。

我可以调试参数已发送到服务器，但服务器无法处理它们。 …

外部服务器上托管了两个媒体文件 - 音频和视频.我需要将它们复用并通过Android MediaPlayer类作为在线流播放.

主要问题是,我不知道,如果有任何可能的解决方案连续下载-mux-play进程.我见过MediaMuxer类使用的例子,但只有本地文件.

目前,我刚开始这样的两个媒体播放器:

//Setting up video
MediaPlayer video = new MediaPlayer();
video.setDataSource("videurl");
video.prepare();
//Setting up audio
MediaPlayer audio = new MediaPlayer();
video.setDataSource("audiourl");
video.prepare();
//Starting both players simultaneously
video.start();
audio.start();

但是,当然,这会在音频和视频之间产生可怕的同步.所以,问题是 - 这是否有可能复用在线流,如果是的话 - 我从哪里开始研究？

<Image>每个屏幕都有许多React Native 组件渲染，并且由于同时存在许多HTTP请求，因此出现性能问题。打开和关闭连接的成本很高，并且同时连接过多会导致限制，从而导致超时。

HTTP / 2具有多路复用功能，允许通过单个连接而不是多个连接同时运行客户端和服务器之间的多个请求和响应消息，从而缩短了页面加载时间。

CloudFront默认情况下支持HTTP / 2，HTTP / 1.1和HTTP / 1，具体取决于客户端在请求标头中发送的版本。

我们注意到，我们的React Native应用程序正在将HTTP / 1.1作为版本的HTTP请求发送到请求标头中<Image>。与流行的应用程序不同，我们为每个GET打开和关闭一个连接。我们如何确保React Native Image请求使用HTTP / 2并共享连接？

（我们的映像都共享相同的CloudFront域。）

编辑-更多信息：

我们的CloudFront发行版支持HTTP / 2：

看来客户端和服务器在h2上达成了共识：

我正在perf_event_opensyscall之上进行自定义实现。

实施旨在支持各种的PERF_TYPE_HARDWARE，PERF_TYPE_SOFTWARE和PERF_TYPE_HW_CACHE事件上的任何核心特定的线程。

在英特尔® 64 位和 IA-32 架构软件开发人员手册第 3B 卷中，我看到以下用于测试 CPU (Kaby Lake) 的内容：

到目前为止，我的理解是，可以同时监视（理论上）无限的PERF_TYPE_SOFTWARE事件，但同时监视有限的（没有多路复用）PERF_TYPE_HARDWARE和PERF_TYPE_HW_CACHE事件，因为每个事件都是通过 CPU 的 PMU 计数器的有限（如上面的手册中所见）数量来衡量的。

因此，对于启用了超线程的四核 Kaby Lake CPU，我假设最多可以同时监视4 个PERF_TYPE_HARDWARE/PERF_TYPE_HW_CACHE事件（如果仅使用 4 个线程，则最多可监视 8 个）。

对上述假设进行试验后，我发现虽然我最多可以成功监控 4 个PERF_TYPE_HARDWARE事件（8 个线程），但对于PERF_TYPE_HW_CACHE最多只能同时监控 2 个事件的事件，情况并非如此！

我还尝试仅使用 4 个线程，但同时监控的“PERF_TYPE_HARDWARE”事件的上限仍然为 4。禁用超线程也会发生同样的情况！

有人可能会问：为什么需要避免多路复用。首先，实现需要尽可能准确，避免多路复用的潜在盲点，其次，当超过“上限”时，所有事件值都为 0...

PERF_TYPE_HW_CACHE我针对的事件是：

CACHE_LLC_READ(PERF_HW_CACHE_TYPE_ID.PERF_COUNT_HW_CACHE_LL.value  | PERF_HW_CACHE_OP_ID.PERF_COUNT_HW_CACHE_OP_READ.value << 8 | PERF_HW_CACHE_OP_RESULT_ID.PERF_COUNT_HW_CACHE_RESULT_ACCESS.value << 16),
CACHE_LLC_WRITE(PERF_HW_CACHE_TYPE_ID.PERF_COUNT_HW_CACHE_LL.value  | …

我更新了我的旧 spring/java 应用程序，它将事务推送到远程 ISO 服务器（银行）。使用经典方法（channel.seng(isoMsg)）通过同步方法，因为通过同一通道发送多个 ISO 请求很难映射请求和响应。过去有太多事务留在队列中，因为每个事务需要 5 秒才能从远程服务器接收响应。因此，所有即将进行的事务都会超时。为了解决这个问题，我开始实施 QMUX。该系统现已上线。

现在我的问题是，如果已经有 50 笔交易的响应未到达或超时，银行告诉我不要发送交易。

所以，现在我需要配置 MUX 框架，以便一旦系统等待 50 个响应，框架应该停止发送并应该在我的末尾排队，当它收到 1 个响应时，它可以再次发送一个事务以保持等待总数响应小于或等于 50。如何使用 jpos QMUX 实现此目的？

为了更好地理解Java中的线程,我编写了以下代码

public class SimpleRunnableTest {
   public static void main(String[] args) throws InterruptedException {
       long start = System.currentTimeMillis();

       Thread t1 = new Thread(new TT1());
       t1.start();
       Thread t2 = new Thread(new TT2());
       t2.start();

       t2.join();
       t1.join();

       long end = System.currentTimeMillis();
       System.out.println("end-start="+(end-start));
       }
}
class TT1 implements Runnable {
    public void run(){
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class TT2 implements Runnable {
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    } …

我最近在读Redis.Redis实现了一个基于I/O多路复用的简单事件驱动库.Redis表示会选择系统支持的最佳多路复用,并提供以下代码:

/* Include the best multiplexing layer supported by this system.
 * The following should be ordered by performances, descending. */
#ifdef HAVE_EVPORT
#include "ae_evport.c"
#else
    #ifdef HAVE_EPOLL
    #include "ae_epoll.c"
    #else
        #ifdef HAVE_KQUEUE
        #include "ae_kqueue.c"
        #else
        #include "ae_select.c"
        #endif
    #endif
#endif

我想知道他们是否有基本的性能差异？如果是这样,为什么？

最好的祝福

我不是专业的网络工程师，所以我希望我的问题不会显得含糊或na\xc3\xafve。

HTTP/2.0 中的多路复用似乎利用单个 TCP 连接来同时处理多个/不同的请求，这样我们就可以避免队头阻塞问题。我想知道在数据重组的意义上它是如何与底层 TCP 连接一起工作/重叠的意义上它是如何与底层 TCP 连接一起工作/重叠的。