Java / Python中的快速IPC / Socket通信

Question

兩個進程（Java和Python）需要在我的應用程序中進行通信。 我注意到套接字通信占用了93％的運行時間。 為什么溝通這么慢？ 我應該尋找套接字通信的替代方案，還是可以加快速度？

更新：我發現了一個簡單的修復。 似乎緩沖輸出流由於某種未知原因而沒有真正緩沖。 所以，我現在將所有數據放入客戶端/服務器進程的字符串緩沖區中。 我在flush方法中將它寫入套接字。

我仍然對使用共享內存在進程之間快速交換數據的示例感興趣。

一些其他信息：

1. 應用程序中的消息大小大多數時間不到64kb。
2. 服務器是Java，客戶端是用Python編寫的。
3. 套接字IPC在下面實現：它需要50個周期發送200個字節！ 這必須太高了。 如果我在5000個周期內發送2個字節，則需要的時間要少得多。
4. 這兩個進程都在一台Linux機器上運行。
5. 在實際應用程序中，每個周期都會對客戶端的iFid.write（）進行大約10次調用。
6. 這是在Linux系統上完成的。

這是服務器端：

public class FastIPC{
    public PrintWriter out;
    BufferedReader in;
    Socket socket = null;
    ServerSocket serverSocket = null;


    public FastIPC(int port) throws Exception{
        serverSocket = new ServerSocket(port);
        socket = serverSocket.accept();
        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);
        in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    }

    public void send(String msg){
        out.println(msg); // send price update to socket
    }

    public void flush(){
        out.flush();
    }

    public String recv() throws Exception{
        return in.readLine();
    }

    public static void main(String[] args){
        int port = 32000;
        try{
            FastIPC fip = new FastIPC(port);
            long start = new Date().getTime();
            System.out.println("Connected.");
            for (int i=0; i<50; i++){
                for(int j=0; j<100; j++)
                    fip.send("+");
                fip.send(".");
                fip.flush();
                String msg = fip.recv();
            }
            long stop = new Date().getTime();
            System.out.println((double)(stop - start)/1000.);
        }catch(Exception e){
            System.exit(1);
        }
    }
}

客戶端是：

import sys
import socket

class IPC(object):
    def __init__(self):
        self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.s.connect(("localhost", 32000))
        self.fid = self.s.makefile() # file wrapper to read lines
        self.listenLoop() # wait listening for updates from server

    def listenLoop(self):
        fid = self.fid
        print "connected"
        while True:
            while True:
                line = fid.readline()
                if line[0]=='.':
                    break
            fid.write('.\n')
            fid.flush()

if __name__ == '__main__':
    st = IPC()

Answer 1

你有很多選擇。 由於您使用的是Linux，因此可以使用UNIX域套接字。 或者，您可以將數據序列化為ASCII或JSon或其他格式，並通過管道，SHM（共享內存段），消息隊列，DBUS或類似方式提供數據。 值得思考您擁有的數據類型，因為這些IPC機制具有不同的性能特征。 有一份USENIX論文草案 ，對各種值得一讀的權衡進行了很好的分析。

既然你說（在這個答案的評論中）你更喜歡使用SHM，這里有一些代碼示例來啟動你。 使用Python posix_ipc庫：

import posix_ipc # POSIX-specific IPC
import mmap      # From Python stdlib

class SharedMemory(object):
    """Python interface to shared memory. 
    The create argument tells the object to create a new SHM object,
    rather than attaching to an existing one.
    """

    def __init__(self, name, size=posix_ipc.PAGE_SIZE, create=True):
        self.name = name
        self.size = size
        if create:
            memory = posix_ipc.SharedMemory(self.name, posix_ipc.O_CREX,
                                            size=self.size)
        else:
            memory = posix_ipc.SharedMemory(self.name)
        self.mapfile = mmap.mmap(memory.fd, memory.size)
        os.close(memory.fd)
        return

    def put(self, item):
        """Put item in shared memory.
        """
        # TODO: Deal with the case where len(item) > size(self.mapfile)
        # TODO: Guard this method with a named semaphore
        self.mapfile.seek(0)
        pickle.dump(item, self.mapfile, protocol=2)
        return

    def get(self):
        """Get a Python object from shared memory.
        """
        # TODO: Deal with the case where len(item) > size(self.mapfile)
        # TODO: Guard this method with a named semaphore
        self.mapfile.seek(0)
        return pickle.load(self.mapfile)

    def __del__(self):
        try:
            self.mapfile.close()
            memory = posix_ipc.SharedMemory(self.name)
            memory.unlink()
        except:
            pass
        return    

對於Java端，你想創建相同的類，盡管我在評論中說過， JTux似乎提供了相同的功能，你需要的API是在UPosixIPC類中。

下面的代碼概述了您需要實現的類型。 但是，有幾個缺失 - 異常處理是顯而易見的，也有一些標志（在UConstant中找到它們），並且你想要添加一個信號量來保護put / get方法。 但是，這應該讓你走上正軌。 請記住， mmap或內存映射文件是一段RAM的文件類接口。 因此，您可以使用其文件描述符，就好像它是普通文件的fd 。

import jtux.*;

class SHM {

    private String name;
    private int size;
    private long semaphore;
    private long mapfile; // File descriptor for mmap file

    /* Lookup flags and perms in your system docs */
    public SHM(String name, int size, boolean create, int flags, int perms) {
        this.name = name;
        this.size = size;
        int shm;
        if (create) {
            flags = flags | UConstant.O_CREAT;
            shm = UPosixIPC.shm_open(name, flags, UConstant.O_RDWR);
        } else {
            shm = UPosixIPC.shm_open(name, flags, UConstant.O_RDWR);
        }
        this.mapfile = UPosixIPC.mmap(..., this.size, ..., flags, shm, 0);
        return;
    }


    public void put(String item) {
        UFile.lseek(this.mapfile(this.mapfile, 0, 0));
        UFile.write(item.getBytes(), this.mapfile);
        return;
    }


    public String get() {    
        UFile.lseek(this.mapfile(this.mapfile, 0, 0));
        byte[] buffer = new byte[this.size];
        UFile.read(this.mapfile, buffer, buffer.length);
        return new String(buffer);
    }


    public void finalize() {
        UPosix.shm_unlink(this.name);
        UPosix.munmap(this.mapfile, this.size);
    }

}

Answer 2

一些想法

• 服務器是Java，客戶端是用Python編寫的。

一個奇怪的組合，但是有什么理由不能通過stdin，stdout調用另一個發送？

• 套接字IPC在下面實現：它需要50個周期發送200個字節！ 這必須太高了。 如果我在5000個周期內發送2個字節，則需要的時間要少得多。

對操作系統的任何調用都會相對較慢（延遲明智）。 使用共享內存可以通過內核。 如果您遇到吞吐量問題，我發現如果延遲不是您的問題，您可以使用套接字達到1-2 GB / s。

• 這兩個進程都在一台Linux機器上運行。

使共享內存理想化。

• 在實際應用程序中，每個周期都會對客戶端的iFid.write（）進行大約10次調用。

不知道為什么會這樣。 為什么不構建單個結構/緩沖區並將其寫入一次。 我會使用直接緩沖區是NIO來最小化延遲。 使用字符轉換非常昂貴，特別是如果您只需要ASCII。

• 這是在Linux系統上完成的。

應該很容易優化。

我通過內存映射文件使用共享內存。 這是因為我需要記錄每條消息以進行審計。 對於數百萬條消息，我得到的往返平均延遲大約為180 ns，在實際應用中大約為490 ns。

這種方法的一個優點是，如果有短暫的延遲，讀者可以很快趕上作者。 它還支持輕松重新啟動和復制。

這只是用Java實現的，但原理很簡單，我相信它也適用於python。

https://github.com/peter-lawrey/Java-Chronicle