How to detect via Java whether a particular process is running under Windows?

Well the title pretty much sums the question. The only thing I found is this but I’m not sure if thats the way to go.

5 Answers 5

You can use the wmic utility to check the list of running processes.
Suppose you want to check if the windows’ explorer.exe process is running :

os.name should do it. More information here

Depends on what you need to know it for!

Most information can be derived from the default runtime properties, without actually checking the operating system properties.

You are trying to determine if a process you created is still running?

1. If you have the PID the link you posted will do.
2. If the other process is also your own (your code), you can make it get exclusive lock on a file; try locking it from the other code if it succeeds the other process is not running.

I have not tried in non Windows based systems. perhaps the PID divisibility by 4 will provide a clue More info on this PID propery here : About the pid of the process

Not the answer you’re looking for? Browse other questions tagged java or ask your own question.

Linked

Related

Hot Network Questions

Subscribe to RSS

To subscribe to this RSS feed, copy and paste this URL into your RSS reader.

site design / logo © 2021 Stack Exchange Inc; user contributions licensed under cc by-sa. rev 2021.4.16.39093

By clicking “Accept all cookies”, you agree Stack Exchange can store cookies on your device and disclose information in accordance with our Cookie Policy.

How can we stop a running java process through Windows cmd?

I am a newbie in cmd, so please allow me to ask a stupid question: How can we stop a running Java process through Windows cmd?

For example, if we start Jetty (a mini web server) with the following command:

How do we find the process and stop it later?

Obviously the following command does not work:

11 Answers 11

It is rather messy but you need to do something like the following:

(This kind of thing is much easier if you have a UNIX / LINUX system . or if you run Cygwin or similar on Windows.)

When I ran taskkill to stop the javaw.exe process it would say it had terminated but remained running. The jqs process (java qucikstart) needs to be stopped also. Running this batch file took care of the issue.

I like this one.

You can actually kill a process on a remote machine the same way.

wmic is awesome!

Normally I don’t have that many Java processes open so

should suffice. This will kill all instances of Java, though.

Open the windows cmd. First list all the java processes,

now get the name and run below command,

or simply kill the process ID

sample 🙂

In case you want to kill not all java processes but specif jars running. It will work for multiple jars as well.

Else taskkill /im java.exe will work to kill all java processes

The answer which suggests something like taskkill /f /im java.exe will probably work, but if you want to kill only one java process instead of all, I can suggest doing it with the help of window titles. Expample:

Start

start «MyProgram» «C:/Program Files/Java/jre1.8.0_201/bin/java.exe» -jar MyProgram.jar

taskkill /F /FI «WINDOWTITLE eq MyProgram» /T

How to get a list of current open windows/process with Java?

Does any one know how do I get the current open windows or process of a local machine using Java?

What I’m trying to do is: list the current open task, windows or process open, like in Windows Taskmanager, but using a multi-platform approach — using only Java if it’s possible.

14 Answers 14

This is another approach to parse the the process list from the command «ps -e«:

If you are using Windows, then you should change the line: «Process p = Runtime.getRun. » etc. (3rd line), for one that looks like this:

Hope the info helps!

Finally, with Java 9+ it is possible with ProcessHandle :

On Windows there is an alternative using JNA:

The only way I can think of doing it is by invoking a command line application that does the job for you and then screenscraping the output (like Linux’s ps and Window’s tasklist).

Unfortunately, that’ll mean you’ll have to write some parsing routines to read the data from both.

YAJSW (Yet Another Java Service Wrapper) looks like it has JNA-based implementations of its org.rzo.yajsw.os.TaskList interface for win32, linux, bsd and solaris and is under an LGPL license. I haven’t tried calling this code directly, but YAJSW works really well when I’ve used it in the past, so you shouldn’t have too many worries.

You can easily retrieve the list of running processes using jProcesses

There is no platform-neutral way of doing this. In the 1.6 release of Java, a «Desktop» class was added the allows portable ways of browsing, editing, mailing, opening, and printing URI’s. It is possible this class may someday be extended to support processes, but I doubt it.

If you are only curious in Java processes, you can use the java.lang.management api for getting thread/memory information on the JVM.

For windows I use following:

This might be useful for apps with a bundled JRE: I scan for the folder name that i’m running the application from: so if you’re application is executing from:

then you can find if it’s already running in J9, by:

Using code to parse ps aux for linux and tasklist for windows are your best options, until something more general comes along.

Linux can pipe the results of ps aux through grep too, which would make processing/searching quick and easy. I’m sure you can find something similar for windows too.

The below program will be compatible with Java 9+ version only.

To get the CurrentProcess information,

For all running processes,

We have to use process.getOutputStream.close() otherwise it will get locked in while loop.

TASKLIST /v /FI «STATUS eq running» /FO «CSV» /FI «Username eq LHPL002\soft» /FI «MEMUSAGE gt 10000» /FI «Windowtitle ne N/A» /NH

How to find the process id of a running Java process on Windows? And how to kill the process alone?

I want to kill the particular Java process in Windows, like in Linux ( ps -aux to get processid and then kill processid to kill the process).

8 Answers 8

You can use the jps utility that is included in the JDK to find the process id of a Java process. The output will show you the name of the executable JAR file or the name of the main class.

Then use the Windows task manager to terminate the process. If you want to do it on the command line, use

You can also find the PID of a java program with the task manager. You enable the PID and Command Line columns View -> Select Columns and are then able to find the right process.

Your result will be something like this :

After setting the path of your jdk use JPS .Then You can eaisly kill it by Task Manager
JPS will give you all java processes

This will work even when there are multiple instance of jar is running

The solution I found is very simple. Use Window’s WMIC & Java’s Runtime to locate & kill the process.

Part 1: You need to put some sort of identifier into your app’s startup command line. E.g. something like:

Part 2: When you run your app, make sure to include the string. Let’s say you start it from within Java, do the following:

Part 3: To kill the process, use Window’s WMIC. Just make sure you app was started containing your id from above:

In windows XP and later, there’s a command: tasklist that lists all process id’s.

For killing a process in Windows, see:

You can execute OS-commands in Java by:

If you need to handle the output of a command, see example: using Runtime.exec() in Java

This is specific to Windows. I was facing the same issue where I have to kill one specific java program using taskkill. When I run the java program, tasklist was showing the same program with Image name set as java.exe. But killing it using taskkill /F java.exe will stop all other java applications other than intended one which is not required.

So I run the same java program using:

Here start command will open a new window and run the java program with window’s title set to MyProgramName.

Now to kill this java-program use the following taskkill command:

Your Java program will be killed only. Rest will be unaffected.

Guide to java.lang.Process API

Last modified: January 2, 2021

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

If you have a few years of experience in the Java ecosystem, and you’re interested in sharing that experience with the community (and getting paid for your work of course), have a look at the «Write for Us» page. Cheers, Eugen

1. Introduction

In this tutorial, we’re going to take an in-depth look at the Process API.

For a shallower look into how to use Process to execute a shell command, we can refer to our previous tutorial here.

The process that it refers to is an executing application. The Process class provides methods for interacting with these processes including extracting output, performing input, monitoring the lifecycle, checking the exit status, and destroying (killing) it.

2. Using Process Class for Compiling and Running Java Program

Let’s see an example to compile and run another Java program with the help of Process API:

Thus, the applications of executing Java code within an existing Java code is virtually limitless.

3. Creating Process

Our Java application can call upon any application which is running within our computer system subjective to Operating System restrictions.

Therefore we can execute applications. Let’s see what the different use cases we can run by utilizing the Process API are.

The ProcessBuilder class allows us to create subprocesses within our application.

Let’s see a demo of opening Windows-based Notepad application:

4. Destroying Process

Process also provides us with methods to destroy sub-processes or process. Although, how the application is killed is platform-dependent.

Let’s see different use cases by which are possible.

4.1. Destroying a Process by Reference

Let’s say we’re using Windows OS and want to spawn the Notepad application and destroy it.

As before, we can create an instance of Notepad application by using the ProcessBuilder class and the start() method.

Then we can call the destroy() method on our Process object.

4.2. Destroying a Process by ID

We can also kill processes which are running within our Operating System that might not be created by our application.

Caution should be advised while doing this, as we can unknowingly destroy a critical process that might make the operating system unstable.

We first need to find out the process ID of the current running process by checking the task manager and find out the pid.

Let’s see an example:

4.3. Destroying a Process by Force

On the execution of the destroy() method, the subprocess will get killed as we saw earlier in the article.

In the case when destroy() doesn’t work, we have the option of destroyForcibly().

We should always start with destroy() method first. After that, we can perform a quick check on the sub-process whether by executing isAlive().

If it returns true then execute destroyForcibly():

5. Waiting for a Process to Complete

We also have two overloaded methods, through which we can ensure we can wait for completion of a process.

5.1. waitfor()

When this method is executed, then it will place the current execution process thread in a blocking-wait state unless the sub-process gets terminated.

Let’s take a look at the example:

We can see from the above example for the current thread to continue execution it will keep on waiting for the subprocess thread to end. Once the subprocess ends, the current thread will continue its execution.

5.2. waitfor(long timeOut, TimeUnit time)

When this method is executed, then it will place the current execution process thread in the blocking-wait state unless the sub-process gets terminated or runs out of time.

Let’s take a look at the example:

We can see from the above example for the current thread to continue execution it will keep on waiting for the subprocess thread to end or if the specified time interval has elapsed.

When this method is executed, then it will return a boolean value of true if the subprocess has exited or a boolean value false if the wait time had elapsed before the subprocess exited.

6. exitValue()

When this method is run then the current thread won’t wait for the sub-process to get terminated or destroyed, however, it will throw an IllegalThreadStateException if the subprocess isn’t terminated.

Another way around if the subprocess has been successfully terminated then it will result in an exit value of the process.

It can be any possible positive integer number.

Let’s look at an example when the exitValue() method returns a positive integer when the subprocess has been terminated successfully:

7. isAlive()

When we’d like to perform business processing which is subjective whether the process is alive or not.

We can perform a quick check to find whether the process is alive or not which returns a boolean value.

Let’s see a quick example of it:

8. Handling Process Streams

By default, the created subprocess does not have its terminal or console. All its standard I/O (i.e., stdin, stdout, stderr) operations will be sent to the parent process. Thereby the parent process can use these streams to feed input to and get output from the subprocess.

Consequently, this gives us a huge amount of flexibility as it gives us control over the input/output of our sub-process.

8.1. getErrorStream()

Interestingly we can fetch the errors generated from the subprocess and thereon perform business processing.

After that, we can execute specific business processing checks based on our requirements.

Let’s see an example:

8.2. getInputStream()

We can also fetch the output generated by a subprocess and consume within the parent process thus allowing share information between the processes:

8.3. getOutputStream()

We can send input to a subprocess from a parent process:

8.4. Filter Process Streams

It’s a perfectly valid use-case to interact with selective running processes.

Process provides us the facility to selectively filter running processes based on a certain predicate.

After that we can perform business operations on this selective process set:

9. Conclusion

Process is a powerful class for Operating System level interaction. Triggering terminal commands as well as launching, monitoring and killing applications.

For more reading on the Java 9 Process API, take a look at our article here.

As always, you’ll find the sources over on Github.