首先，让我简要解释一下为什么我会提出这个问题： 我正在编写一个Python程序（带有wxPython图形用户界面），需要从Python调用Java AWT程序并从中提取数据。在Windows上，我有一个进程内的工作解决方案。在OSX上，只要我运行Java应用程序无头模式，就可以有一个进程内的解决方案。不幸的是，我没有找到任何合理的解决方案可以在OSX上在同一个进程中运行两个GUI，因为AWT和WX都想要第一个线程，并且不能共享wx消息循环。
我想要做的是，在我的Python程序中启动一个独立的Java程序，并建立一个管道或队列或其他传递数据（特别是字节数组）的方法。
我非常感谢任何建议，甚至是对正确方向的指引，因为我在IPC方面几乎没有经验。
使用Python中的subprocess实现IPC
这里有一个IPC.java文件，其中Java代码将接收数字并发送它的平方。
import java.util.Scanner;
public class IPC {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String data="";
while(scanner.hasNext()){
// Receive data from Python code
data = scanner.nextLine();
// Process data (calculate square)
int x = Integer.parseInt(data);
int square = x*x;
// Send data to python code
System.out.println(square);
}
scanner.close();
}
}
import subprocess
subprocess.run(["javac", "IPC.java"])
proc = subprocess.Popen(["java", "IPC"], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
for i in range(10):
# Send to java code
proc.stdin.write(b'%d\n' % i)
proc.stdin.flush()
proc.stdout.flush()
# Receive data from java code
output = proc.stdout.readline()
print (output.rstrip())
proc.communicate()
命名管道 可能是您的答案。请参见：在Python中创建临时FIFO（命名管道）？
.jar文件放置在Python应用程序的目录中。
stdin、stdout 和 stderr 流是操作系统内核用于应用程序和进程的主要 I/O 系统。通过修改这些流从子进程到操作系统，再到子进程到父进程的流动，这些流将被绕过父进程，并使父进程能够直接与子进程执行输入和输出操作。
[ Java 代码 ]
public class Main {
public static void main(String[] args)
{
// Send input over the "stdout" stream to the Python parent process
System.out.println("Message from Java application");
System.out.flush();
// Read input over the "stdin" stream from the Python parent process
Scanner s = new Scanner(System.in);
String input = s.nextLine();
s.close();
// Send input over the "stdout" stream to the Python parent process
System.out.println(input);
System.out.flush();
}
}
[ Python 代码 ]
import subprocess
# Path to java.exe, in case the application contains a self-contained java environment, else just the "java" command
path_to_java_exe = "C:\\Users\\Teodor Mihail\\PycharmProjects\\Python_IPC\\jre\\bin\\java.exe"
# Command line argument that specifies the compiler what it should compile, in this case is a ".jar" file
java_exe_arguments = "-jar"
# The path to the file that the compiler will run and the runtime will execute, in this case it is the whole program compiled as a ".jar" file
java_jar_file_path = "C:\\Users\\Teodor Mihail\\PycharmProjects\\Python_IPC\\Java_I.P.C.jar"
# Global variable that holds the sub-process
process = None
def subprocess_startup():
# Specify that the "process" variable is a reference to the global variable "process"
global process
# Open the process and redirect the "stdin", "stdout", and "stderr" streams from the sub-process to the OS to the Python process
process = subprocess.Popen([path_to_java_exe, java_exe_arguments, java_jar_file_path], stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
def subprocess_read_stdout():
# Read the output sent by the Java application sub-process over the "stdout" stream
received = process.stdout.readline()
print(received)
def subprocess_write_stdin(data):
# Write input to the Java application over the "stdin" stream
process.stdin.write(data.encode("utf-8"))
process.stdin.flush()
def main():
subprocess_startup()
# A loop can be implemented here for continuous read and write operations.
# Both the read and write operation methods can be open on different threads
# to perform continuous read and write operations executed in parallel
subprocess_read_stdout()
# Data to be written on the stdin stream must end in "\n" otherwise the Java
# Scanner will lock. This will happen because the Scanner in Java is
# scanning until a "\n" is found, otherwise it will wait indefinitely
# until it will find a "\n" within the input stream.
subprocess_write_stdin("Message from Python application\n")
subprocess_read_stdout()
if __name__ == '__main__':
main()
process.stdin.write方法时，发送到子进程的数据必须以换行符("\n")结尾。这是因为Java扫描器将扫描stdin流以查找换行符，并且由于流被缓冲，这将导致在执行此操作的线程上出现锁定。