Synchronisation de processus croisée en Java

Il n'est pas possible de faire quelque chose comme vous le souhaitez en Java. Différentes applications Java utiliseront différents JVM se séparant complètement en différents 'Blackbox'es. Cependant, vous avez 2 options:

1. Utilisez des sockets (ou des canaux). Fondamentalement, une application ouvrira la prise d'écoute et commencera à attendre jusqu'à ce qu'il reçoive un signal. L'autre application va se connecter là-bas et envoyer des signaux quand il avait terminé quelque chose. Je dirais que c'est une manière préférée utilisée dans 99,9% des applications.
2. Vous pouvez appeler Winapi à partir de Java. Je ne me souviens pas des détails, mais vous pouvez trouver une pléthore d'exemple si votre Google "Java Winapi".

Vous ne savez pas ce que vous essayez de faire, je le ferais éventuellement en exposant quelque chose via JMX et que les processus distincts définissent un indicateur d'état qui reviennent de manière programmable votre thread d'un état d'attente. Au lieu de JMX, vous pouvez bien sûr utiliser une prise / RMI.

Je ne pense pas qu'il existe des méthodes natales dans la plate-forme Java pour cela. Cependant, il existe plusieurs façons d'obtenir le même type d'effet en fonction de la synchronisation que vous essayez d'accomplir. En plus de la communication des processus communiquant sur des connexions réseau (prises directes, multidiffusion avec une élection, etc.) ou de laisser tomber les appels spécifiques à la plate-forme, vous pouvez également explorer l'obtention d'un verrouillage de fichier à un fichier partagé (voir Activemq Passif Stand-By avec un Système de fichiers partagé pour un exemple) ou en utilisant une base de données soit avec quelque chose comme une sélection de mise à jour ou une mise à jour optimiste d'une ligne de table.

Utiliser les sockets pour les processus de processus croisés est une pratique courante. Non seulement pour les applications Java, car dans la plupart des environnements * Nix, nous n'avons pas de mutiles à l'échelle du système que nous avons sous Windows.

Verrouillage croisé Java:

// Tester
try {
    if (crossProcessLockAcquire(SomeClassInYourApp.class, 3000)) {
       // Success - This process now has the lock. (Don't keep it too long.)
    }
    else {
       // Fail (Timeout) - Another process still had the lock after 3 seconds.
    }
} finally {
    crossProcessLockRelease(); // try/finally is very important.
}

// Acquire - Returns success ( true/false )
private static boolean crossProcessLockAcquire(final Class<?> c, final long waitMS) {
    if (fileLock == null && c != null && waitMS > 0) {
        try {
            long dropDeadTime = System.currentTimeMillis() + waitMS;
            File file = new File(lockTempDir, c.getName() + ".lock");
            RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
            FileChannel fileChannel = randomAccessFile.getChannel();
            while (System.currentTimeMillis() < dropDeadTime) {
                fileLock = fileChannel.tryLock();
                if (fileLock != null) {
                    break;
                }
                Thread.sleep(250); // 4 attempts/sec
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return fileLock == null ? false : true;
}

// Release
private static void crossProcessLockRelease() {
    if (fileLock != null) {
        try {
            fileLock.release();
            fileLock = null;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// Some class vars and a failsafe lock release.
private static File lockTempDir = new File(System.getProperty("java.io.tmpdir") + File.separator + "locks");
private static FileLock fileLock = null;
static {
    Runtime.getRuntime().addShutdownHook(new Thread() {
        public void run(){
            crossProcessLockRelease();
        }
    });
}    

J'ai simplifié java42 strong> réponse

utilisation h2> xxx PRE>

Le code dans la successlockRunnable verrouille tout autre processus sur la même machine à l'aide de cette implémentation. P>

Source H2>

/**
 * Created by Ilya Gazman on 13/06/2016.
 * Based on https://stackoverflow.com/a/9577667/1129332
 */
public class ProcessLock {
    // Some class vars and a fail safe lock release.
    private File lockTempDir = new File(System.getProperty("java.io.tmpdir") + File.separator + "locks");
    private FileLock fileLock = null;
    private String key;

    public ProcessLock() {
        this("lock");
    }

    public ProcessLock(String key) {
        this.key = key;
        Runtime.getRuntime().addShutdownHook(new Thread() {
            public void run() {
                crossProcessLockRelease();
            }
        });
    }

    public void run(Runnable successCallback) {
        run(successCallback, null);
    }

    public void run(Runnable successCallback, Runnable timeOutCallback) {
        try {
            if (crossProcessLockAcquire(3000)) {
                successCallback.run();
            } else if (timeOutCallback != null) {
                timeOutCallback.run();
            }
        } finally {
            crossProcessLockRelease(); // try/finally is very important.
        }
    }

    // Acquire - Returns success ( true/false )
    private boolean crossProcessLockAcquire(final long waitMS) {
        if (fileLock == null && waitMS > 0) {
            try {
                long dropDeadTime = System.currentTimeMillis() + waitMS;
                File file = new File(lockTempDir, "_" + key + ".lock");
                RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
                FileChannel fileChannel = randomAccessFile.getChannel();
                while (System.currentTimeMillis() < dropDeadTime) {
                    fileLock = fileChannel.tryLock();
                    if (fileLock != null) {
                        break;
                    }
                    Thread.sleep(250); // 4 attempts/sec
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return fileLock != null;
    }

    // Release
    private void crossProcessLockRelease() {
        if (fileLock != null) {
            try {
                fileLock.release();
                fileLock = null;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Nous utilisons ce type d'instructions pour vous assurer qu'un seul processus peut faire un bloc de code clé par "myLOOsKey": xxx pré>

ici, nous utilisons cette classe: P >

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.util.function.Supplier;

import com.headlandstech.utils.FileUtils;
import com.headlandstech.utils.Log;

public class LocalFileLock {

  private final File lockFile;

  public LocalFileLock(String name) {
    this.lockFile = new File(FileUtils.TEMP_DIR, name + ".lock");
    if (!lockFile.isFile()) {
      FileUtils.writeStringToFile("", lockFile);
    }
  }

  public <T> T doWithLock(Supplier<T> f) {
    Log.log.info("Waiting on lock " + lockFile);
    try (FileChannel channel = new RandomAccessFile(lockFile, "rw").getChannel()) {
      final FileLock fileLock = channel.lock();
      Log.log.info("Lock " + lockFile + " obtained");
      T result = f.get();
      fileLock.release();
      Log.log.info("Lock " + lockFile + " released");
      return result;
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

}