Rapide IPC/communication par Socket en Java/Python

Vous avez un certain nombre d'options. Puisque vous utilisez Linux, vous pouvez utiliser les sockets de domaine UNIX. Ou, vous pourriez serialise les données au format ASCII ou JSon ou d'un autre format et l'alimentation à travers un tuyau, SHM (segment de mémoire partagée), le message de la file d'attente, DBUS ou similaire. Il vaut la peine de penser à ce genre de données que vous avez, ainsi que ces mécanismes IPC ont des caractéristiques de performance différentes. Il y a un projet de USENIX papier avec une bonne analyse des différents arbitrages qui vaut la peine de lire.

Puisque vous dites (dans les commentaires de cette réponse) que vous préférez utiliser la SHM, voici quelques exemples de code pour vous commencer. À l'aide de l'Python posix_ipc bibliothèque:

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    

Pour le Java côté que vous souhaitez créer la même classe, en dépit de ce que j'ai dit dans les commentaires JTux semble fournir l'équivalent de la fonctionnalité et de l'API que vous avez besoin est dans UPosixIPC classe.

Le code ci-dessous est un aperçu du genre de chose que vous devez mettre en œuvre. Cependant, il ya plusieurs choses manquantes-la gestion des exceptions est le plus évident, quelques-unes des options (les trouver dans UConstant), et vous aurez envie d'ajouter dans un sémaphore à la garde du put /get méthodes. Toutefois, cela devrait vous mettre sur la bonne voie. Rappelez-vous qu'un mmap ou fichier mappé en mémoire est un fichier d'interface semblable à un segment de mémoire vive. Ainsi, vous pouvez utiliser son descripteur de fichier comme si c'était la fd d'un fichier normal.

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);
}
}

OriginalL'auteur snim2