File download on production slow compated to test java

Sometimes this could be as simple as changing the data structure you are storing your data in. Streams are a great addition to the Java language, letting you easily lift error prone patterns from for loops into generic, more reusable blocks of code with consistent guarantees. This is especially true for any very high throughput applications, the increased memory allocations from the streams API according to this StackOverflow post each filter adds 88 bytes of used memory can cause enough increased memory pressure to require more frequent GC runs causing a heavy hit on performance.

On smaller data sets the cost of the stream computation determines what constitutes a smaller data set the cost of splitting up the work, scheduling it on other threads and stitching it back together once the stream has been processed will dwarf the speedup from running the computations in parallel.

In fact, under load, this might be worse than non-parallel execution. A sample of the benchmarks I performed. The testList is a , element array of the numbers 1 to , converted to a String, shuffled. In summary, streams are a great win for code maintenance and readability with a negligible performance impact for the vast majority of cases but it pays to be aware of the overhead for the rare case where you really need to wring the extra performance out of a tight loop.

Imagine a scenario where you had a list of a million objects either strings directly or objects representing some item with a date field on them backed by a string , and you had to perform an adjustment to the date on them. In the context where this date is represented as a string you first have to parse it from that string into a Date object, update the Date object and then format it back into a string. String manipulation is probably one of the most common operations in any program.

But when they do, they can be a performance killer. A very simple String. By monitoring JavaEE Servers in both production and QA environments, you become able to make decisions based on trends, before problems become too severe. You could also find out the causes of response times, implementing optimizations based on such times. JavaMelody is an example of a tool that can help you perform environment monitoring. Application memory analysis after a crash can help with identifying the cause of a memory leak.

The heap dump file can be loaded into an analyzer: Eclipse MAT. You can dive into the Overview or Leaks Suspects reports to help identify the cause of the memory exception. The big takeaway is that Java performance monitoring is easier than ever with all these tools. Start with the low hanging fruit first, like exception tracking. It is really good to at least know what options are available to you, and I hope you found this list helpful.

Click here to read more about the acquisition. Try Our Free Code Profiler. Try Our Code Profiler. By Role. By Technology. By Language. Documentation Support Ideas Portal Menu. Start Free Trial. Tip: Find application errors and performance problems instantly with Stackify Retrace.

It comes down to your definition of "slow". Compared to a pure interpreter, Java is extremely fast. Compared to other languages that are normally compiled to some sort of bytecode, then dynamically compiled to machine code e.

C or anything else on. NET Java is roughly on a par. Compared to the languages that are normally compiled to pure machine code, and have often large teams of people working on nothing but improving their optimizers e. Therefore, most Java and C , etc. In a lot of cases, it's less about what optimizations are done, than where they're applied.

Many optimization problems are NP complete, so the time they take grows quickly with the size of problem being attacked. One way to keep time within reason is to only apply the optimization to something like a single function at a time.

When it's only the developer waiting for the compiler, you can afford to take a lot longer, and apply that same optimization to much larger chunks of the program. Likewise, the code for some optimizations is pretty hairy and therefore can be pretty big. Again, since the user is waiting while that code loads and the JVM startup time is often a significant factor in the overall time , the implementation has to balance time saved in one place vs.

A second problem is that with Java, you frequently get a more or less "one size fits all" kind of solution. Just for example, for many Java developers Swing is essentially the only windowing library available. The only real sticking point is that some e. Qt can be quite expensive at least for commercial use.

At lot of it contains a core of routines written decades ago, when spending extra time optimizing the code was normal, expected behavior.

That often has a real benefit in code that's smaller and faster. To summarize, the normal implementation of Java makes maximum optimization problematic at best. Worse, where Java is visible , such things as windowing toolkits and JVM startup time often play a larger role than the execution speed of the language itself anyway. As to the second question, I think it's largely a matter of human nature at work. A few zealots make rather inflated claims about Java being blindingly fast.

Somebody tries it out, and finds that even a trivial program takes a few seconds to get started, and feels slow and clumsy when it does run. Few probably bother analyzing things to realize that a great deal of this is the startup time of the JVM, and the fact that when they first try things out, none of the code has been compiled yet -- some of the code is being interpreted, and some being compiled while they wait.

Worse, even when it runs fast enough, the look and feel will usually seem foreign and clumsy to most users, so even if objective measurements showed fast response times, it'd still seem clumsy.

Adding those together leads to a fairly simple and natural reaction: that Java is slow, ugly and clumsy. Given the hype saying it's really fast, there's a tendency to overreact and conclude think of it as horribly slow, instead of a more accurate "slightly slower, and that mostly under specific circumstances. Execution of a "hello world" program in most languages appears instantaneous, but in Java there's an easily perceptible pause as the JVM starts up.

Even a pure interpreter that runs much more slowly on tight loops and such will still often appear faster for code like this, simply because it can get loaded and started executing a bit sooner. It's out-dated information from the early days mid-to-late s of Java.

Every major version of Java has introduced significant speed-ups compared to the previous version. Compared to many other popular modern languages Python, Ruby, PHP , Java is actually significantly faster for most uses. The real performance concerns ought to be about how much memory it ends up using.

The main culprit in the "long startup time" is dynamic linking. A Java application consists of compiled classes. Each class references other classes for argument types, method invocations The JVM must examine and match those names upon startup. It does so incrementally, doing only the parts that it needs at any given time, but that is still some work to do. In a C application, that linking phase occurs at the end of the compilation. It is slow, especially for big applications, but only the developer sees it.

In Java, linking occurs every single time that the application is run. Hence the long startup time. Various optimizations have been applied, including caching techniques, and computers get faster and they get "more faster" than applications get "more bigger" , so the problem importance has much reduced lately; but the old prejudice remains.

This is an edge case. In each of these languages I can matrix multiply a by matrix of doubles with itself in around 4 seconds. Using Colt and Parallel Colt in Java, the same operation take seconds! Astonishing despite these java libraries being parallel in nature. So all in all, pure Java is unsuitable for quantitative work. I use bit Ubuntu For most people's experience interacting with it - Java is slow.

We've all seen that coffee cup spinning around on our browser before some applet comes up. It takes a while to spin up the JVM and download the applet binaries, and that impacts the user experience in a way that is noticed. It doesn't help that the slow JVM spin-up and applet download time is conspicuously branded with a Java coffee cup, so people associate the wait with Java. When Flash takes a long time to load, the branding of the "loading" message is specified by the Flash developer, so people don't blame Flash technology as a whole.

All of this has nothing to do with Java's performance on a server, or in the many other ways that Java gets used outside the browser.

But it's what people see, and what non-Java developers remember when they think about Java. Java has the reputation of being slow because it was slow. The first versions of Java had either no or rather poor Just In Time compilation. This meant that the code, although bytecode, was being interpreted, so even for the simplest operations like adding two integers the machine had to do all sorts of compares and pointer dereferences and function calls.

If you want to see just how big a difference JIT compilation makes, check out the interpreted vs. Pidigits uses an external library to do all the computations, so that benchmark doesn't change; the others show a x speedup! So, that's the main reason. There are a variety of other, lesser reasons that did not help matters: originally, Java startup time was slow now fixed ; web apps in Java take a long time to download much less true now with widely accessible broadband, and with large things like movies being expected ; the UI Swing was not and still is not written with performance in mind so it is much less snappy than equivalents in e.

Java WAS slow, back in the day. It has become much faster, due to a few generations of performance enhancements. Java applet startup is still slow because you've got to start a whole JVM, which has to load all it's classes. Somewhat like booting another computer. Once the JVM starts it is quite fast, but the startup is usually what people remember.

Also, there are at least a few people that will never believe in the viability of Java. I have been with Java since the beginning, so from my point of view the fame of being slow was created by non-responsive and slow GUI frontends AWT, and then Swing and in Applets probably because of the additional slow startup times of the VM's. Java has stipulated and promoted a lot of research in the VM area, and there have been quite some improvements, including the garbage collection you can tune a lot of things actually; however, often I see systems where only defaults are used and hotspot optimization which at the beginning and probably still is more efficient on the server side.

Java at the backend and the computational level is not that slow. Colt is one of the best examples:. The latest stable Colt release breaks the 1. There are many things outside mainstream Java that should be considered, like Realtime Java or special mechanisms to enhance the speed like Javolution , as well as Ahead-Of-Time compilation like gcj. However, there are many other languages for the Java VM nowadays e. Personally I continue to enjoy it as a flexible and reliable platform, with excellent tooling and library availability, that allows one to work with everything from the smallest device e.

JavaCard to the largest servers. A hammer is much slower at rolling out dough than many other tools. If all you do is run through an MM file top to bottom, you're just going to stress the memory manager and not receive any benefit from the paradigm.

Show 1 more comment. Sign up or log in Sign up using Google. Sign up using Facebook. Sign up using Email and Password.

Post as a guest Name. Email Required, but never shown. The Overflow Blog. Who owns this outage? Building intelligent escalation chains for modern SRE. Podcast Who is building clouds for the independent developer?

Featured on Meta. Now live: A fully responsive profile. Reducing the weight of our footer. Linked Related Hot Network Questions. Question feed. Stack Overflow works best with JavaScript enabled. Accept all cookies Customize settings.