Run java program as process

Processes and Threads

In concurrent programming, there are two basic units of execution: processes and threads. In the Java programming language, concurrent programming is mostly concerned with threads. However, processes are also important.

A computer system normally has many active processes and threads. This is true even in systems that only have a single execution core, and thus only have one thread actually executing at any given moment. Processing time for a single core is shared among processes and threads through an OS feature called time slicing.

It’s becoming more and more common for computer systems to have multiple processors or processors with multiple execution cores. This greatly enhances a system’s capacity for concurrent execution of processes and threads — but concurrency is possible even on simple systems, without multiple processors or execution cores.

Processes

A process has a self-contained execution environment. A process generally has a complete, private set of basic run-time resources; in particular, each process has its own memory space.

Processes are often seen as synonymous with programs or applications. However, what the user sees as a single application may in fact be a set of cooperating processes. To facilitate communication between processes, most operating systems support Inter Process Communication (IPC) resources, such as pipes and sockets. IPC is used not just for communication between processes on the same system, but processes on different systems.

Most implementations of the Java virtual machine run as a single process. A Java application can create additional processes using a ProcessBuilder object. Multiprocess applications are beyond the scope of this lesson.

Threads

Threads are sometimes called lightweight processes. Both processes and threads provide an execution environment, but creating a new thread requires fewer resources than creating a new process.

Threads exist within a process — every process has at least one. Threads share the process’s resources, including memory and open files. This makes for efficient, but potentially problematic, communication.

Multithreaded execution is an essential feature of the Java platform. Every application has at least one thread — or several, if you count «system» threads that do things like memory management and signal handling. But from the application programmer’s point of view, you start with just one thread, called the main thread. This thread has the ability to create additional threads, as we’ll demonstrate in the next section.

Источник

How to run a system application (executable) from Java

Learn how to run an executable from Java using the process class.

In many applications nowadays, it is necessary to rely on other applications during the runtime to guarantee the application integrity. For example, third party applications whose goal is to store a signature from a device installed on the computer. In Java this is pretty easy using the Runtime class, this class allows the application to interface with the environment in which the application is running. For example, in windows you will be able to open the Notepad.exe application using the alias notepad from the CLI, so with Java you should be able to start the notepad.exe application with the following 3 lines of code:

Runtime runTime = Runtime.getRuntime(); String executablePath = "notepad"; Process process = runTime.exec(executablePath);

However, you won’t have always shortcuts for executables, so you will need to provide the absolute path to the executable. In this short article, we’ll provide you with a short snippet that allows you to start a third party application from the system easily.

Full example

The following snippet packed within an application, will start the application (executable) defined in the executablePath variable and will catch any exception triggered by the example:

package sandbox; import java.io.IOException; public class Sandbox < /** * Example of how to run an executable from Java. * * @param args */ public static void main(String[] args) < try < Runtime runTime = Runtime.getRuntime(); String executablePath = "C:\\Users\\sdkca\\AppData\\Local\\Programs\\Microsoft VS Code\\Code.exe"; Process process = runTime.exec(executablePath); >catch (IOException e) < e.printStackTrace(); >> >

If the executable doesn’t exist, the code will catch the exception and will display in the console an output similar to:

java.io.IOException: Cannot run program "my-executable-path.exe": CreateProcess error=2, The system cannot find the file specified at java.lang.ProcessBuilder.start(ProcessBuilder.java:1048) at java.lang.Runtime.exec(Runtime.java:620) at java.lang.Runtime.exec(Runtime.java:450) at java.lang.Runtime.exec(Runtime.java:347) at sandbox.Sandbox.main(Sandbox.java:18) Caused by: java.io.IOException: CreateProcess error=2, The system cannot find the file specified at java.lang.ProcessImpl.create(Native Method) at java.lang.ProcessImpl.(ProcessImpl.java:386) at java.lang.ProcessImpl.start(ProcessImpl.java:137) at java.lang.ProcessBuilder.start(ProcessBuilder.java:1029)

Источник

IT Experts

Each ProcessBuilder instance manages a collection of process attributes. The start() method creates a new Process instance with those attributes. The start() method can be invoked repeatedly from the same instance to create new subprocesses with identical or related attributes.

Each process builder manages these process attributes:

• a command, a list of strings which signifies the external program file to be invoked and its arguments, if any. Which string lists represent a valid operating system command is system-dependent. For example, it is common for each conceptual argument to be an element in this list, but there are operating systems where programs are expected to tokenize command line strings themselves – on such a system a Java implementation might require commands to contain exactly two elements.
• an environment, which is a system-dependent mapping from variables to values. The initial value is a copy of the environment of the current process (see System.getenv() ).
• a working directory. The default value is the current working directory of the current process, usually the directory named by the system property user.dir .
• a source of standard input. By default, the subprocess reads input from a pipe. Java code can access this pipe via the output stream returned by Process.getOutputStream() . However, standard input may be redirected to another source using redirectInput . In this case, Process.getOutputStream() will return a null output stream, for which:
  • the write methods always throw IOException
  • the close method does nothing
  • the read methods always return -1
  • the available method always returns 0
  • the close method does nothing
  • standard error is merged with the standard output and always sent to the same destination (this makes it easier to correlate error messages with the corresponding output)
  • the common destination of standard error and standard output can be redirected using redirectOutput
  • any redirection set by the redirectError method is ignored when creating a subprocess
  • the stream returned from Process.getErrorStream() will always be a null input stream

  Following example demonstrate how to run external Java program, Same way we can run any external program which must be set in OS environment.

  Before running this program on your machine, make sure that JAVA_HOME must be set in your OS environment.

   package com.itexpert.exam; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; public class JavaProcessBuilder < /** * Provide absolute JAVA file path */ private static final String JAVA_FILE_LOCATION = "D:\\Test.java"; public static void main(String args[]) throws IOException< String command[] = ; ProcessBuilder processBuilder = new ProcessBuilder(command); Process process = processBuilder.start(); /** * Check if any errors or compilation errors encounter then print on Console. */ if( process.getErrorStream().read() != -1 ) < print("Compilation Errors",process.getErrorStream()); >/** * Check if javac process execute successfully or Not * 0 - successful */ if( process.exitValue() == 0 )< process = new ProcessBuilder(new String[]).start(); /** Check if RuntimeException or Errors encounter during execution then print errors on console * Otherwise print Output */ if( process.getErrorStream().read() != -1 ) < print("Errors ",process.getErrorStream()); >else < print("Output ",process.getInputStream()); >> > private static void print(String status,InputStream input) throws IOException < BufferedReader in = new BufferedReader(new InputStreamReader(input)); System.out.println("************* "+status+"***********************"); String line = null; while((line = in.readLine()) != null )< System.out.println(line); >in.close(); > > 

  External Java Program source code below:-

  Output if Compilation done successfully

   ************* Output *********************** Hello, How are you . 

  Suppose, if we pass incorrect file “Test1” through command[] object which does not exist in your given path then-

   ************* Compilation Errors*********************** avac: file not found: D:\Test1.java Usage: javac use -help for a list of possible options 

  Suppose, if any compilation errors exist in Java file then-

   ************* Compilation Errors*********************** :\Test.java:3: error: cannot find symbol System.out.printlna("Hello, How are you . "); ^ symbol: method printlna(String) location: variable out of type PrintStream 1 error 

  Источник