Java servlet exec process

Java – Running linux process from servlet useing Runtime.exec()

Is it good idea to run linux process in multi user environment.

Ex: Runtime rt = Runtime.getRuntime();
Process proc = rt.exec(«linux command»);
int exitVal = proc.waitFor(); // may wait till 5 to 10 mins

Best Solution

You need to be aware of some things:

• If the process uses files, you must make sure that each process gets its own set or they will overwrite each others input/output. Use File.createTempFile() .
• The processes will run with the user rights of the server.
• If the process gets data which the user can change in the browser, make sure that he can’t send something like «; rm -rf /» .
• If the process runs more than a few seconds, you must run it in the background and parse the output to see when it completes. This can get hairy quickly because of error handling, you’ll need to keeping a reference to the running process in the session, etc.

Other than that, there is no reason to be afraid of this. Unix is a server OS which is designed to run many, many processes at the same time 🙂

Related Solutions

C++ – How to profile C++ code running on Linux

If your goal is to use a profiler, use one of the suggested ones.

However, if you’re in a hurry and you can manually interrupt your program under the debugger while it’s being subjectively slow, there’s a simple way to find performance problems.

Just halt it several times, and each time look at the call stack. If there is some code that is wasting some percentage of the time, 20% or 50% or whatever, that is the probability that you will catch it in the act on each sample. So, that is roughly the percentage of samples on which you will see it. There is no educated guesswork required. If you do have a guess as to what the problem is, this will prove or disprove it.

You may have multiple performance problems of different sizes. If you clean out any one of them, the remaining ones will take a larger percentage, and be easier to spot, on subsequent passes. This magnification effect, when compounded over multiple problems, can lead to truly massive speedup factors.

Caveat: Programmers tend to be skeptical of this technique unless they’ve used it themselves. They will say that profilers give you this information, but that is only true if they sample the entire call stack, and then let you examine a random set of samples. (The summaries are where the insight is lost.) Call graphs don’t give you the same information, because

1. They don’t summarize at the instruction level, and
2. They give confusing summaries in the presence of recursion.

They will also say it only works on toy programs, when actually it works on any program, and it seems to work better on bigger programs, because they tend to have more problems to find. They will say it sometimes finds things that aren’t problems, but that is only true if you see something once. If you see a problem on more than one sample, it is real.

P.S. This can also be done on multi-thread programs if there is a way to collect call-stack samples of the thread pool at a point in time, as there is in Java.

P.P.S As a rough generality, the more layers of abstraction you have in your software, the more likely you are to find that that is the cause of performance problems (and the opportunity to get speedup).

Added: It might not be obvious, but the stack sampling technique works equally well in the presence of recursion. The reason is that the time that would be saved by removal of an instruction is approximated by the fraction of samples containing it, regardless of the number of times it may occur within a sample.

Another objection I often hear is: «It will stop someplace random, and it will miss the real problem«. This comes from having a prior concept of what the real problem is. A key property of performance problems is that they defy expectations. Sampling tells you something is a problem, and your first reaction is disbelief. That is natural, but you can be sure if it finds a problem it is real, and vice-versa.

Added: Let me make a Bayesian explanation of how it works. Suppose there is some instruction I (call or otherwise) which is on the call stack some fraction f of the time (and thus costs that much). For simplicity, suppose we don’t know what f is, but assume it is either 0.1, 0.2, 0.3, . 0.9, 1.0, and the prior probability of each of these possibilities is 0.1, so all of these costs are equally likely a-priori.

Then suppose we take just 2 stack samples, and we see instruction I on both samples, designated observation o=2/2 . This gives us new estimates of the frequency f of I , according to this:

Prior P(f=x) x P(o=2/2|f=x) P(o=2/2&&f=x) P(o=2/2&&f >= x) P(f >= x | o=2/2) 0.1 1 1 0.1 0.1 0.25974026 0.1 0.9 0.81 0.081 0.181 0.47012987 0.1 0.8 0.64 0.064 0.245 0.636363636 0.1 0.7 0.49 0.049 0.294 0.763636364 0.1 0.6 0.36 0.036 0.33 0.857142857 0.1 0.5 0.25 0.025 0.355 0.922077922 0.1 0.4 0.16 0.016 0.371 0.963636364 0.1 0.3 0.09 0.009 0.38 0.987012987 0.1 0.2 0.04 0.004 0.384 0.997402597 0.1 0.1 0.01 0.001 0.385 1 P(o=2/2) 0.385 

The last column says that, for example, the probability that f >= 0.5 is 92%, up from the prior assumption of 60%.

Suppose the prior assumptions are different. Suppose we assume P(f=0.1) is .991 (nearly certain), and all the other possibilities are almost impossible (0.001). In other words, our prior certainty is that I is cheap. Then we get:

Prior P(f=x) x P(o=2/2|f=x) P(o=2/2&& f=x) P(o=2/2&&f >= x) P(f >= x | o=2/2) 0.001 1 1 0.001 0.001 0.072727273 0.001 0.9 0.81 0.00081 0.00181 0.131636364 0.001 0.8 0.64 0.00064 0.00245 0.178181818 0.001 0.7 0.49 0.00049 0.00294 0.213818182 0.001 0.6 0.36 0.00036 0.0033 0.24 0.001 0.5 0.25 0.00025 0.00355 0.258181818 0.001 0.4 0.16 0.00016 0.00371 0.269818182 0.001 0.3 0.09 0.00009 0.0038 0.276363636 0.001 0.2 0.04 0.00004 0.00384 0.279272727 0.991 0.1 0.01 0.00991 0.01375 1 P(o=2/2) 0.01375 

Now it says P(f >= 0.5) is 26%, up from the prior assumption of 0.6%. So Bayes allows us to update our estimate of the probable cost of I . If the amount of data is small, it doesn’t tell us accurately what the cost is, only that it is big enough to be worth fixing.

Yet another way to look at it is called the Rule Of Succession. If you flip a coin 2 times, and it comes up heads both times, what does that tell you about the probable weighting of the coin? The respected way to answer is to say that it’s a Beta distribution, with average value (number of hits + 1) / (number of tries + 2) = (2+1)/(2+2) = 75% .

(The key is that we see I more than once. If we only see it once, that doesn’t tell us much except that f > 0.)

So, even a very small number of samples can tell us a lot about the cost of instructions that it sees. (And it will see them with a frequency, on average, proportional to their cost. If n samples are taken, and f is the cost, then I will appear on nf+/-sqrt(nf(1-f)) samples. Example, n=10 , f=0.3 , that is 3+/-1.4 samples.)

Added: To give an intuitive feel for the difference between measuring and random stack sampling:
There are profilers now that sample the stack, even on wall-clock time, but what comes out is measurements (or hot path, or hot spot, from which a «bottleneck» can easily hide). What they don’t show you (and they easily could) is the actual samples themselves. And if your goal is to find the bottleneck, the number of them you need to see is, on average, 2 divided by the fraction of time it takes. So if it takes 30% of time, 2/.3 = 6.7 samples, on average, will show it, and the chance that 20 samples will show it is 99.2%.

Here is an off-the-cuff illustration of the difference between examining measurements and examining stack samples. The bottleneck could be one big blob like this, or numerous small ones, it makes no difference.

Measurement is horizontal; it tells you what fraction of time specific routines take. Sampling is vertical. If there is any way to avoid what the whole program is doing at that moment, and if you see it on a second sample, you’ve found the bottleneck. That’s what makes the difference — seeing the whole reason for the time being spent, not just how much.

Linux – Peak memory usage of a linux/unix process

[Edit: Works on Ubuntu 14.04: /usr/bin/time -v command Make sure to use the full path.]

Looks like /usr/bin/time does give you that info, if you pass -v (this is on Ubuntu 8.10). See, e.g., Maximum resident set size below:

$ /usr/bin/time -v ls / . Command being timed: "ls /" User time (seconds): 0.00 System time (seconds): 0.01 Percent of CPU this job got: 250% Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.00 Average shared text size (kbytes): 0 Average unshared data size (kbytes): 0 Average stack size (kbytes): 0 Average total size (kbytes): 0 Maximum resident set size (kbytes): 0 Average resident set size (kbytes): 0 Major (requiring I/O) page faults: 0 Minor (reclaiming a frame) page faults: 315 Voluntary context switches: 2 Involuntary context switches: 0 Swaps: 0 File system inputs: 0 File system outputs: 0 Socket messages sent: 0 Socket messages received: 0 Signals delivered: 0 Page size (bytes): 4096 Exit status: 0

Related Question

Источник

runtime exec a process on another server using a servlet

posted 19 years ago

Hello,
I was wondering if it was possible to runtime exec a process on another server.
For instance I am on server one and I have accessible rights to server two. I would like the user to call a servlet on server one that executes a process on server 2. How would I go about doing this?
Any help would be appreciated.
Thank you,
Maneesh

posted 19 years ago

client (probably with browser) —> servlet1-server1—>servlet2@server2
If this is the case; @servlet1 create a URL Object with target to URL of server2-servlet2.
but I am not sure yet..
please try and inform..

posted 19 years ago

If you can have a process on server 1 execute a process on server 2 then it can be done with a servlet on server 1. Have you read the API for the various java.lang.Runtime exec() methods?
Bill

posted 19 years ago

I reviewed the API but am still unsure about doing this.
yes, that is correct. I am trying to access the servlet from a browser that will then call a process on server 1 which should call a process on server 2.
any further information.
Thank you,
Maneesh

posted 19 years ago

Maybe this helps:
To call a Servlet from Java (Another servlet or any Java code) you could use this:

You are working with Java, so you can send anything to the servlet (like an Objet), not just a URLEncoded string.
If you just want to do a GET (previous was a POST), you can change :

posted 19 years ago

also, there is no servlet on server 2. This server only has processes running on it and this process would need to run somehow.
browser—>servlet1—>serverProc1—>server2—>serverProc2
Thank you,
Maneesh

Sun Certified Java Programmer 2 (1.4)
Sun Certified Web Component Developer

posted 19 years ago

I suggest you experiment with the Runtime exec methods outside the servlet environment first. There are a lot of things that can go wrong and mixing in all the things that can go wrong with servlets does not help.
Important points:
Read the api for java.lang.Process carefully.
You will need to capture the output of the resulting process using Threads that read the stdout and stderr streams. If you don’t read these streams, the process may freeze-up mysteriously.
Bill

Источник