两个进程（Java和Python）需要在我的应用程序中进行通信。我注意到套接字通信占用了93％的运行时间。为什么沟通这么慢？我是否应该寻找套接字通信的替代方案，还是可以更快地实现这一目标？
更新：我发现了一个简单的修复程序。似乎缓冲输出流由于某种未知原因而没有真正缓冲。所以，我现在将所有数据放入客户端/服务器进程的字符串缓冲区中。我在flush方法中将它写入套接字。
我仍然对使用共享内存在进程之间快速交换数据的示例感兴趣。
其他一些信息：
这是服务器端：
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()
答案 0 :(得分：11)
您有很多选择。由于您使用的是Linux，因此可以使用UNIX域套接字。或者，您可以将数据序列化为ASCII或JSon或其他格式，并通过管道，SHM（共享内存段），消息队列，DBUS或类似方式提供数据。值得思考您拥有的数据类型，因为这些IPC机制具有不同的性能特征。有draft USENIX paper分析了值得阅读的各种权衡因素。
既然你说（在这个答案的评论中）你更喜欢使用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 / { {1}}方法。但是，这应该让你走上正轨。请记住，get或内存映射文件是一段RAM的文件类接口。因此，您可以使用其文件描述符，就好像它是普通文件的mmap一样。
fd答案 1 :(得分：1)
一些想法
一个奇怪的组合，但有什么理由不能通过stdin，stdout调用另一个发送？
对操作系统的任何调用都会相对较慢（延迟明智）。使用共享内存可以通过内核。如果您遇到吞吐量问题，我发现如果延迟不是您的问题，您可以使用套接字达到1-2 GB / s。
使共享内存成为理想选择。
不确定为什么会这样。为什么不构建单个结构/缓冲区并将其写入一次。我会使用直接缓冲区是NIO来最小化延迟。使用字符翻译非常昂贵，特别是如果你只需要ASCII。
应该易于优化。
我通过内存映射文件使用共享内存。这是因为我需要记录每条消息以进行审计。数百万条消息的平均延迟时间约为180 ns，实际应用程序的平均延迟约为490 ns。
这种方法的一个优点是，如果有短暂的延迟，读者可以很快赶上作者。它还支持轻松重新启动和复制。
这仅在Java中实现，但原理很简单，我相信它也适用于python。