Java通过共享内存调用机器学习python代码示例

背景：弱鸡的java不支持丰富的机器学习算法。

需求：python实现了一个bert分类，希望给java代码调用。因此，使用共享内存的方式实现跨进程调用。

在进程间通信（IPC）中，性能是一个重要的考虑因素。以下是几种常见的IPC方式及其性能比较：

1. Socket通信:

优点: 跨网络和本地通信都可以使用，灵活性高。

缺点: 相对较慢，因为涉及网络协议栈的开销。

适用场景: 分布式系统、跨主机通信。

2. 管道（Pipes）:

优点: 简单、易用，适合父子进程间通信。

缺点: 只能用于单向通信，且仅限于同一主机。

适用场景: 父子进程间的简单数据传输。

3. 共享内存（Shared Memory）:

优点: 速度最快，因为数据直接在内存中共享。

缺点: 需要同步机制（如信号量）来避免竞争条件，编程复杂度较高。

适用场景: 高性能需求的进程间通信。

4. 消息队列（Message Queues）:

优点: 支持消息的有序传递和优先级。

缺点: 相对较慢，适合中小规模数据传输。

适用场景: 需要消息排队和优先级的场景。

5. 信号量（Semaphores）:

优点: 用于进程间的同步和互斥。

缺点: 只适用于同步，不适合大数据传输。

适用场景: 进程间的同步和资源管理。

性能比较

共享内存通常是最快的，因为它避免了数据在内核和用户空间之间的拷贝，直接在内存中共享数据。

管道和消息队列的性能次之，因为它们需要在内核和用户空间之间进行数据拷贝。

Socket通信的性能最慢，尤其是跨网络通信时，因为涉及网络协议栈的开销。

选择建议

如果你需要在同一主机上的进程间进行高性能通信，共享内存是最佳选择。

如果你需要简单的父子进程间通信，管道是一个不错的选择。

如果你需要跨主机通信，Socket是唯一的选择。

Java代码：

import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.StandardCharsets;
 
public class Main {
    private final static String FILE_PATH = "D:\\shared_memory.bin3";
    private final static int FILE_SIZE =  1024*1024*1024 + 1; // 1MB for text, 1 byte for lock
 
    public static void main(String[] args) {
        try (RandomAccessFile memoryFile = new RandomAccessFile(FILE_PATH, "rw");
             FileChannel fileChannel = memoryFile.getChannel()) {
 
            MappedByteBuffer buffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, FILE_SIZE);
 
            String textToClassify = "什么是sql注入？";
 
            // Wait until the buffer is available for writing
            while (buffer.get(0) != 0) {
                System.out.println("Waiting for buffer to be available for writing...");
                Thread.sleep(100);
            }
 
            // Write the text to the buffer
            buffer.put(0, (byte) 1);  // Mark as written
            byte[] textBytes = textToClassify.getBytes(StandardCharsets.UTF_8);
            buffer.position(1);
            buffer.put(textBytes);
            // Pad the remaining part with 0x00 (null character in C, '\0' character)
            buffer.position(1 + textBytes.length);
            buffer.put(new byte[1024 - textBytes.length]);
            System.out.println("Written to memory: " + textToClassify);
 
            // Polling for result
            byte[] data = new byte[1024];
            String classificationResult = "";
            while (true) {
                if (buffer.get(0) == 0) {  // Check if buffer is available for writing
                    buffer.position(1);
                    buffer.get(data);
                    classificationResult = new String(data, StandardCharsets.UTF_8).trim();
                    System.out.println("Classification result received: " + classificationResult);
                    break;
                }
                Thread.sleep(1);  // Sleep for a short time before polling again
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

python代码：

# server.py
import json
import mmap
import time
import os
# from bert_classify import predict
# from sec_tool_rag import search_sectool_knowledge_base
 
def classify_text(text):
    return 100
    # predicted_label, prediction = predict(text)
    # return predicted_label
 
FILE_PATH = 'D:\\shared_memory.bin3'
FILE_SIZE = 1024*1024*1024 + 1  # 1MB bytes for text, 1 byte for lock
 
if not os.path.exists(FILE_PATH):
    with open(FILE_PATH, 'w+b') as f:
        f.write(b'\x00' * FILE_SIZE)
 
with open(FILE_PATH, 'r+b') as f:
    mm = mmap.mmap(f.fileno(), FILE_SIZE)
    while True:
        mm.seek(0)
        lock = mm.read_byte()
 
        if lock == 1:  # Data written and ready to be read
            mm.seek(1)
            message = mm.read(1024).decode('utf-8').rstrip('\x00').strip()
            print(f"Received message: {message}")
            # tools = search_sectool_knowledge_base(message, topk=3)
            # print(f"Sec tools for '{message}': {tools}")
 
            label = classify_text(message)
            print(f"Classified label: {label}")
            # str2write = json.dumps(tools)
            str2write = str(label)
            # Write the classification result
            mm.seek(1)
            mm.write(str2write.encode().ljust(1024, b'\x00'))
            mm.seek(0)
            mm.write_byte(0)  # Mark as available for writing
            print("Result written and memory marked as available for writing")
 
        time.sleep(0.001)

启动python程序，再启动java代码：

输出

Received message: 什么是sql注入？
Classified label: 100
Result written and memory marked as available for writing
 
------------------------------------------
 
Written to memory: 什么是sql注入？
Classification result received: 100