如何确保主线程仅在子线程启动之后才继续？

Question

I am trying to write a program that first ssh'es to two different machines, and then executes some http requests against them. This means that in order to be able to execute my http requests the ssh tunnel should be running.

What I have done is that I have two threads, each running the ssh command to one of the boxes:

    Thread thread1 = new Thread(new Runnable(){
            public void run(){
                try{
                    Process p1 = Runtime.getRuntime().exec("ssh -A -L12345:localhost:54321 firsthost.com");
                    p1.waitFor();
                }catch (Exception e){}
            }
        }) ;
        thread1.start();

    Thread thread2 = new Thread(new Runnable(){
        public void run(){
            try{
                Process p2 = Runtime.getRuntime().exec("ssh -A -L12345:localhost:54321 secondhost.com");
                p2.waitFor();
            }catch (Exception e){}
        }
    }) ;
    thread2.start();

Now the problem is that after starting the threads, they do not always immediately start running, which means that I will send my requests before the connection is made. Is there a simple way (without using locks or mutex) that I can make sure I only return to my main program after the threads are started? (I don't want of course to wait for them to end because they never end. Just run the first command once :) Also if there is a better way to run the processes in the background instead of having these two seperate threads, that would be great too!)

Thanks!

Answer 1

Try adding the -f and -N flags to tell ssh to background itself once the port forwarding is setup. Then you can execute the ssh commands in the main thread and wait until they exit (ie background themselves) before continuing.

-f

Requests ssh to go to background just before command execution. This is useful if ssh is going to ask for passwords or passphrases, but the user wants it in the background. This implies -n . The recommended way to start X11 programs at a remote site is with something like ssh -f host xterm .

If the ExitOnForwardFailure configuration option is set to “yes”, then a client started with -f will wait for all remote port forwards to be successfully established before placing itself in the background.

-N

Do not execute a remote command. This is useful for just forwarding ports (protocol version 2 only).

(Unfortunately I'm unable to test this at the moment. Apologies if it doesn't work.)

Answer 2

First of all using threads directly is not encouraged in JDK5 onwards. The well packed Executors will do the job for us. If you have a lower version of java or you want to do this still in this way then, here is one quick solution,

public class Main {

public static void main(String... objs) throws Exception {

    final Process1Thread p1Thread = new Process1Thread();
    final Process2Thread p2Thread = new Process2Thread();

     Thread p1 = new Thread(p1Thread);
     Thread p2 = new Thread(p2Thread);

     p1.start(); p2.start();

     while(true) {
         if(p1Thread.isFinishedCommand() && p2Thread.isFinishedCommand()) {
             //send commands
            System.out.println("sending commands"); 
             break;
         }   
     }       
}

interface FinishedCommand {
    boolean isFinishedCommand();
}

static class Process1Thread implements Runnable, FinishedCommand {

    private boolean finished = false; 

    @Override
    public boolean isFinishedCommand() {
        synchronized(this) {
            return finished;
        }
    }

    @Override
    public void run() {         
        try {
            final Process p2 = Runtime.getRuntime().exec("dir");

            synchronized(this) {
                finished = true;
            }               
            p2.waitFor();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }       
}


static class Process2Thread implements Runnable, FinishedCommand {

    private boolean finished = false; 

    @Override
    public boolean isFinishedCommand() {
        synchronized(this) {
            return finished;
        }
    }

    @Override
    public void run() {         
        try {
            final Process p2 = Runtime.getRuntime().exec("dir");

            synchronized(this) {
                finished = true;
            }               
            p2.waitFor();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

}

Regards Lyju

Answer 3

You can use thread1.getState() method to get the state of the thread. After you can thread1.start() it should be moved to RUNNABLE state. When thread1 is waiting for the process to finish it will be in BLOCKED state.