You are reading from the Process's InputStream. You should be looking at Process.getErrorStream() or Process.getOutputStream().

https://docs.oracle.com/javase/7/docs/api/java/lang/Process.html

You could also inspect the exitValue to see if the process successfully completed.

When does ProcessBuilder.start() returns null ...

According to the javadoc, start() does not return null. The javadoc says that it returns a Process and doesn't mention returning null. If there was any circumstance in which start() could return null, then that should be mentioned explicitly in the javadoc in the "Returns:" for the method.

That is the convention that they follow.

I took a look at the source code for ProcessBuilder.start() in Java 11, and by my reading it is actually impossible for the result to be null.

The actual code is in a static Process start() method that is declared in the package private ProcessImpl class. If that method returns at all, it returns an newly created instance of ProcessImpl ... which extends Process.

(There are different versions of ProcessImpl for Unix and Windows platforms. I check both versions.)

So the question is: how come you are getting that NPE?

My guess is that you are misreading the stacktrace (which you haven't shown us!), and the exception is not being thrown in that call to getOutputStream(). Or maybe the compiled code that you are running doesn't match the source code you are looking at.

Either way, we will need you to provide a proper minimal reproducible example if we are to take this any further. A "minrepex" that we can actually compile and run, and that actually throws an NPE for us to diagnose.

(And for what it is worth, I am disinclined to believe that either the javadocs or the Java SE implementation are incorrect.)

Any other way I can call the start() method?

Not that I am aware of. But that is probably a blind alley. The real solution will involve figuring out where that NPE is really coming from.

The problem isn't with handling the external process, it's the incorrect use of the ExecutorService returned by Executors.newSingleThreadExecutor(). This method creates a thread running in the background, and because you never shut down this executor (which would stop the thread), this thread prevents the JVM from exiting.

If you want to, you can prove that the ls process exits by adding a line which prints out its exit code. Note however that this line might not appear at the bottom of the output.

To address this, we need to keep a reference to the ExecutorService created, and then shut it down when we don't need it any more. Try replacing

        Executors.newSingleThreadExecutor().submit(streamGobbler);

        int exitCode = process.waitFor();

with

        ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.submit(streamGobbler);

        int exitCode = process.waitFor();

        executor.shutdown();

I made this change to your code and it went from hanging to exiting cleanly.

reg is a cmd shell command not an executable as in it only exists inside the cmd.exe shell environment.

If there is no constraint to start another JVM (for example: usage of System.exit() in test.jar) you could load and run the test.jar inside the current JVM.

Following snippet shows the principle.

File file = new File("/tmp/test.jar");
URLClassLoader loader = new URLClassLoader(
        new URL[]{file.toURI().toURL()}
);

String className = new JarFile(file)
        .getManifest()
        .getMainAttributes()
        .getValue(Attributes.Name.MAIN_CLASS);

Method main = loader
        .loadClass(className)
        .getDeclaredMethod("main", String[].class);

Object arg = new String[]{"1", "20"};

try {
    main.invoke(null, arg);
} catch (Exception e) {
    // do appropriate exception handling here
    e.printStackTrace(System.err);
}

This problem may be related to sub-process's input stream buffers.

You should clear the sub-process's input stream buffers.

These stream buffers got increased within the parent process's memory with time and at some moment your sub-process will stop responding.

There are few options to make sub-process work normally

1. Read continuously from sub-process's input streams
2. Redirect sub-process's input streams
3. Close sub-process's input streams

Closing sub-process's input streams

ProcessBuilder processBuilder = new ProcessBuilder(command);
Process process = processBuilder.start();
InputStream inStream = process.getInputStream();
InputStream errStream = process.getErrorStream();
try {
    inStream.close();
    errStream.close();
} catch (IOException e1) {
}
process.waitFor();

Reading sub-process's input streams

    ProcessBuilder processBuilder = new ProcessBuilder(command);
    Process process = processBuilder.start();
    InputStreamReader tempReader = new InputStreamReader(new BufferedInputStream(p.getInputStream()));
    final BufferedReader reader = new BufferedReader(tempReader);
    InputStreamReader tempErrReader = new InputStreamReader(new BufferedInputStream(p.getErrorStream()));
    final BufferedReader errReader = new BufferedReader(tempErrReader);

    try {
        while ((line = reader.readLine()) != null) {
        }
    } catch (IOException e) {
    }

    try {
        while ((line = errReader.readLine()) != null) {
        }
    } catch (IOException e) {
    }
    process.waitFor();

Redirecting sub-process's input streams

ProcessBuilder processBuilder = new ProcessBuilder(command);
processBuilder.redirectInput();
processBuilder.redirectError();
Process process = processBuilder.start();
process.waitFor();

Looks like your process writes something in its out and/or err streams. Their buffer overflow and process blocks. You should read out and err streams of your process to avoid this.

See "When Runtime.exec() won't" for more information

You are not doing the same thing with ProcessBuilder that you’re doing with Runtime.exec, so I don't know why you think ProcessBuilder is the problem.

You have a few problems with how you’re writing the command’s output to a file.

First, the presence of ">", satellite_scan_temp_file in your ProcessBuilder command is incorrect. Output redirection is not part of any command; it is handled by a shell. But when you run with Runtime.exec or ProcessBuilder, you are not running in a shell, you are executing the process directly. Neither w_scan nor any other command considers > a special character.

The correct way to redirect to a file is with the redirectOutput method:

ProcessBuilder pb = new ProcessBuilder(
    "/usr/bin/w_scan", "-fs", "-s" + satellite_code, "-c" + country_code);

pb.redirectOutput(new File(satellite_scan_temp_file));

Second, your ScanThread code is ignoring the (currently incorrect) redirect, and is attempting to read the command’s output. But there is no output, because you are redirecting it all to a file.

Once you are properly redirecting output to a file, you can remove your BufferedReader and BufferedWriter loops completely.

Finally, it is worth noting that the error output you captured probably told you that > is not a valid argument to the w_scan process.

lmBuilder.redirectErrorStream();

This is incorrect.

This method only tells whether you redirect stderr to stdout; it does not instruct that stderr should be redirected to it.

What you should use is:

lmBuilder.redirectErrorStream(true);

Got the solution for the same. I just commented inheritIO() as shown below.

ProcessBuilder builder = new ProcessBuilder();//.inheritIO();

One more point is , if you have inheritIO() in your code, the output will be printing in the console of the calling program.

As @DavidMaze mentioned , these ips are of no use. So I have added another method to check the status of docker container.

The error message says that Java does not find an executable called zip in the current directory or on the path, which can be seen with:

String systemPath = System.getenv("PATH");
System.out.println("PATH="+systemPath);

Fix your launcher to include the full path to "zip" or fix the PATH used for your Java VM to include a directory that contains zip.

myListOfString.add("/the/path/to/zip");

or something like this (depending on your shell / terminal)

export PATH=/the/path/to:$PATH

As @Abra suggests, there are better ways to ZIP inside Java without relying on ProcessBuilder such as:

public static void zip(Path dir, Path zip) throws IOException
{
    Map<String, String> env = Map.of("create", "true");
    try (FileSystem fs = FileSystems.newFileSystem(zip, env))
    {
        // This predicate processed the action because it makes use of BasicFileAttributes
        // Rather than process a forEach stream which has to call Files.isDirectory(path)
        BiPredicate<Path, BasicFileAttributes> foreach = (p,a) -> {
            copy(p,a, fs.getPath("/"+dir.relativize(p)));
            return false;
        };

        Files.find(dir, Integer.MAX_VALUE, foreach).count();
    }
    System.out.println("ZIPPED "+dir +" to "+zip);
}
private static void copy(Path from, BasicFileAttributes a, Path target)
{
    System.out.println("Copy "+(a.isDirectory() ? "DIR " : "FILE")+" => "+target);
    try
    {
        if (a.isDirectory())
            Files.createDirectories(target);
        else if (a.isRegularFile())
            Files.copy(from, target, StandardCopyOption.REPLACE_EXISTING);
    }
    catch (IOException e)
    {
        throw new UncheckedIOException(e);
    }
}