Subscribe: JavaPerformanceTuning.com News
http://www.javaperformancetuning.com/newsletters.rss
Preview: JavaPerformanceTuning.com News

JavaPerformanceTuning.com News



JavaPerformanceTuning.com lists all the information and resources available for Java performance tuning



Published: Wed, 30 Nov 2016 08:44:00 GMT

Last Build Date: Wed, 30 Nov 2016 08:44:00 GMT

Copyright: Copyright 2000-2016, Jack Shirazi
 



Java Performance News November 2016
We list all the latest Java performance related news and articles. "A good performance expert tends to be a good troubleshooter because many of the analysis skills are the same"



November 2016 New Java Performance Tips
The latest Java performance tips from around the web, like "GC pauses with high 'sys' time compared to 'user' can occur from underlying OS IO happening, pausing the JVM. Similarly GC pauses with low 'user' and low 'sys' but high 'real' can be caused from JVM getting stuck waiting for OS IO to complete (including when GC file rotation triggers filesystem flushing)."



Java Performance News October 2016
We list all the latest Java performance related news and articles. "When 20 nanoseconds per request matter to you, you need to know about Thread.onSpinWait()."



October 2016 New Java Performance Tips
The latest Java performance tips from around the web, like "Accept that the bottlenecks will shape your architecture, and consider them early on."



Java Performance News September 2016
We list all the latest Java performance related news and articles. "jcmd will now be able to alter some fine-grained JIT compiler directives at runtime and you can define them statically at startup; this may be particularly useful for those low latency applications with warmup concerns"



September 2016 New Java Performance Tips
The latest Java performance tips from around the web, like "JEP 269, available in Java 9, adds factory methods for collections which return immutable collections, eg List.of(a, b, c, ...), Map.of(k1, v1, k2, v2, ...). Note that immutable collections are automatically threadsafe. They are also space efficient."



Java Performance News August 2016
We list all the latest Java performance related news and articles. "After that I realised that this is now the most dynamic, interesting, innovative time we've ever seen for Java! More than 20 years of ever improving Java and, instead of maturing and slowing down, we're actually accelerating improvements in Java all the way from the very bottom of the stack on through every stage!"



August 2016 New Java Performance Tips
The latest Java performance tips from around the web, like "In order of increasing complexity for concurrency options: stateless; immutable; synchronized; locks; read-copy-update; java.util.concurrent.atomic; queueing"



Java Performance News July 2016
We list all the latest Java performance related news and articles. "both 'don't share' and 'don't mutate' techniques tend to increase copies of data, which incurs runtime and garbage collection costs that both impact latency. You gain lower maintenance costs, but it's very hard to maintain high throughput together with low latency with those two techniques. If you need low latency, you need 'coordinate access' and, more specifically, coordinate access using lock-free techniques."



July 2016 New Java Performance Tips
The latest Java performance tips from around the web, like "SSD throughput is typically 2 orders of magnitude higher than HDD, but you can gain up to a further 4x speedup by making the application SSD friendly - eg using multiple concurrrent I/O threads (for small reads; large reads should keep the concurrent I/O thread count low). This differs markedly from HDDs where multiple concurrrent I/O threads tends to actually decrease throughput."



Java Performance News June 2016
We list all the latest Java performance related news and articles. "Target having two JVM instances, (three if you need more scale or redundancy), grow those instances up to the NUMA-node size but preferentially try to stay below either 4GB or 32GB max heaps; above NUMA-node RAM you need to test whether a bigger heap single JVM or per-NUMA-node memory restricted JVMs are more efficient"



June 2016 New Java Performance Tips
The latest Java performance tips from around the web, like "The probability that a customer will see a worse than a nth centile request is 1-(n)^requests, eg the average page makes 42 requests to display the page, then 1-(0.95)^24 = 88% of pages see the 95th centile or worse in latency!"



Java Performance News May 2016
We list all the latest Java performance related news and articles. "An architect's primary approach is to see how the system will scale, handle failure modes staying resilient, and remain secure"



May 2016 New Java Performance Tips
The latest Java performance tips from around the web, like "Why distribute your system? Scale and fault tolerance. But these are in conflict with each other - higher scale means more failure, more failure tolerance means more overhead which reduces scaling. Everything is a tradeoff between these"



Java Performance News April 2016
We list all the latest Java performance related news and articles. "If you're storing ints into a HashMap, they're being converted to and from Integers (either explicitly or through autoboxing). Changing the code to use the appropriate trove map (TObjectIntHashMap, TIntObjectHashMap or TIntIntHashMap) gives you a smaller, faster, and higher throughput implementation, at almost no effort"



April 2016 New Java Performance Tips
The latest Java performance tips from around the web, like "You can auto-tune a system if you have a parameter which can be adjusted that you can control, a measure that the parameter affects, and a target for that measure (and assuming the parameter and measure react within reasonable times). Then using a controller with a feedback loop, the parameter can be auto-adjusted to minimize deviations from the target. This can allow your system to adapt to dynamically changing resource contention (eg request surges)"



Java Performance News March 2016
We list all the latest Java performance related news and articles. "In the performance world, we always go for the 'fail fast' implementation - as with any collection comparison, you compare subsets of the collection, and fail as soon as you know any subset does not equate. But in the security world, this can be dangerous"



March 2016 New Java Performance Tips
The latest Java performance tips from around the web, like "If you need extremely low latencies, you have to take account of the mode and route of physical transmission of signals as well as the transport layer. Fibre transmits at 2/3 the speed of light, and most fibre routes tested were 1.5-2 times longer than the shortest physical path, so a typical good fibre route is already ~3x slower than maximum possible. DNS lookup and TCP handshakes imply further large overheads"



Java Performance News February 2016
We list all the latest Java performance related news and articles. "I list the pros and cons of microservices"



February 2016 New Java Performance Tips
The latest Java performance tips from around the web, like "Concurrent access techniques in order of increasing throughput are: a lock; lock striping; splitting data structure to split writes; commit logging with asynchronous batched updates"



Java Performance News January 2016
We list all the latest Java performance related news and articles. "We've had software transactional memory in Java for 20 years in at least one system"



January 2016 New Java Performance Tips
The latest Java performance tips from around the web, like "In general you should size a JVM system based on heap allocation, not CPU allocation"



Java Performance News December 2015
We list all the latest Java performance related news and articles. "99.99% means you have less than an hour's total downtime over the whole year (8760 hours)"



December 2015 New Java Performance Tips
The latest Java performance tips from around the web, like "Soft references are collected much less eagerly than weak ones, typically in response to memory pressure (weakly referenced objects could be collected at any time). This means a double hit happens when memory pressure increases, with the GC already trying hard to free up memory it also starts to look at softly referenced objects meaning even longer or more frequent GCs"



Java Performance News November 2015
We list all the latest Java performance related news and articles. "where to actually focus your effort: on enabling the architecture to scale horizontally and specifically handling the interactions between the components"



November 2015 New Java Performance Tips
The latest Java performance tips from around the web, like "Choice of protocol for IoT depends on how and what pattern of communications the devices need to do - device processing capability, interoperability, message sizes, communication encryption, reliability of message delivery (atmost once, at least once, exactly once), and communication flow control (importantly whether you need to ensure there is a control channel open which means you can't allow congested channels) all need to factor in to the protocol decision"



Java Performance News October 2015
We list all the latest Java performance related news and articles. "the clear implication for JVMs: memory access is going to become the bottleneck in CPU processing"



October 2015 New Java Performance Tips
The latest Java performance tips from around the web, like "Put limits on everything: bound queues; timeout remote calls; terminate idle connections; kill long (db) queries; etc." and "For stateful services in a service instance, cache data and have the client talk to the same instance (use sticky sessions)."



Java Performance News September 2015
We list all the latest Java performance related news and articles. "In Java 9, these combinations will cause a startup error instead of the deprecated message, aborting JVM startup"



September 2015 New Java Performance Tips
The latest Java performance tips from around the web, like "The compare-and-swap (CAS) loop is a pattern used in many lock-free data structures. If another thread modifies the shared memory and changes it back before the first thread resumes execution (the ABA problem), a CAS can incorrectly succeed"



Java Performance News August 2015
We list all the latest Java performance related news and articles. "'-Xrun' is a generic command to the JVM to run a shared library agent given by the name of the subsequent characters, ie '-Xrunxyz' would run the shared library agent 'xyz'; on unix there will be a 'libxyz.so', on windows a 'xyz.dll'"



August 2015 New Java Performance Tips
The latest Java performance tips from around the web, like "For more efficient debugging of asynchronous calls, either pass the stacks as you move from one context to the next, or more efficiently generate a UUID at the start and pass the UUID across all asynchronous contexts (and log that UUID) so that you can track a request across asynchronous processing using the UUID"



Java Performance News July 2015
We list all the latest Java performance related news and articles. "A tiny change in Java 8 is that Thread.stop(Throwable) is now disabled - it now throws an UnsupportedOperationException instead of working as it did in earlier Java versions. Thread.stop() still works (ie the stop() call with no argument)"



July 2015 New Java Performance Tips
The latest Java performance tips from around the web, like "Make sure everything is getting JIT compiled. A quick technique to check this is to switch on the -XX:+PrintCompilation flag, then redo with -XX:ReservedCodeCacheSize doubled and if more methods are getting compiled the second time, the code cache was too small"



Java Performance News June 2015
We list all the latest Java performance related news and articles. "you can probably get the Oracle JVM down to about 5ms pauses if you are very careful with your code, but most code that uses third-party libraries will have a really hard time getting it down to 10ms"



June 2015 New Java Performance Tips
The latest Java performance tips from around the web, like "-XX:+UseCondCardMark can make multi-threaded code faster"



Java Performance News May 2015
We list all the latest Java performance related news and articles. "In Java 8, Permgen disappeared, but Metaspace appeared. Metaspace has some of the same challenges - identifying classloader leaks will still be equally challenging. But instead of having a default maximum size as Permgen had, Metaspace is unlimited by default"



May 2015 New Java Performance Tips
The latest Java performance tips from around the web, like "In Java 8 java.util.logging.Logger methods accept a Supplier (as an alternative to a String), which means that you can now pass a Supplier and the resulting code only gets evaluated when the log line is actually emitted - ie you get lazy evaluation and the log entry no longer needs to be guarded to avoid the string getting evaluated if the log level is insufficient to trigger the log line"



Java Performance News April 2015
We list all the latest Java performance related news and articles. "Optimal use of a shared resource is done by multiplexing where possible"



April 2015 New Java Performance Tips
The latest Java performance tips from around the web, like "A microservice with correctly bounded context is self-contained - you can understand and update the microservice's code without knowing anything about the internals of its peers; the microservices and its peers interact strictly through APIs and so don't share data structures, database schemata, or other internal representations. This allows you to focus on fixing a single bottleneck without impacting anything else in the system"



Java Performance News March 2015
We list all the latest Java performance related news and articles. "if the majority of your requests need both microservice A and microservice B, and these two microservices both each need to scale to the same number of JVMs, there is no point at all in having those microservices running in separate JVMs - you may as well coalesce those microservices into the same JVM and gain the benefit of single JVM efficiency"



March 2015 New Java Performance Tips
The latest Java performance tips from around the web, like "For thread-safety you just have to follow one simple rule - no mutable state in the code. No instance variables and you are safe, regardless of how many threads execute the same piece of code"



Java Performance News February 2015
We list all the latest Java performance related news and articles. "even if your program does almost no IO, that tiny IO operation it does gets queued up until the current flush completes, pausing your program"



February 2015 New Java Performance Tips
The latest Java performance tips from around the web, like "Distributed caching requires cache updates to be propagated but this has overheads which in some situations can make the cache less effective than no cache"



Java Performance News January 2015
We list all the latest Java performance related news and articles. "volatile++ is not atomic, AtomicIntegerFieldUpdater.getAndIncrement(object) is"



January 2015 New Java Performance Tips
The latest Java performance tips from around the web, like "When there is a large difference in retained memory between a parent and child object, this is a good candidate for the holder of a memory leak" and "Objects can be collected earlier than you might expect - the finalize() method can run when calls to other object methods are concurrently running!"



Java Performance News December 2014
We list all the latest Java performance related news and articles. "you cannot possibly know what the biggest bottleneck is beforehand, you can only determine what it is using your various measuring tools, and these tools can mislead you"



December 2014 New Java Performance Tips
The latest Java performance tips from around the web, like "final fields provide for thread-safety for primitives and also object references as long as the object referred to is immutable. If the referred object is mutable, you can still get thread-safe access and update as long as the mutability is handled in a thread-safe way (eg the example StringInterner class can have threads overwrite the internal data structure in a non-deterministic way, but the result of any call will still always produce a coherent object adhering to the class API. Specifically, the 'interned' String could be interned several times as different objects in different threads but this doesn't violate the class API)."



Java Performance News November 2014
We list all the latest Java performance related news and articles. "The advantage of a microservice architecture is that you only need to scale the services that need scaling, rather than all components"



November 2014 New Java Performance Tips
The latest Java performance tips from around the web, like "The cloud is a new environment with it's own very specific challenges that need independent consideration for testing, monitoring and analysis - you can't just take the techniques you use on a server or browser or client application or mobile app and transfer those to cloud services, you actually have to use different techniques, it's a completely new environment class to add to those four: it has a server-like environment, but resource competition similar to a browser and mobile app type unpredictability of uptime."



Java Performance News October 2014
We list all the latest Java performance related news and articles. "If you're interested in a little more about types of sizeof, or a little Java history (or both) then you might want to check my java.net blog"



October 2014 New Java Performance Tips
The latest Java performance tips from around the web, like "In designing multithreaded components, you need to consider exactly how the component responds to interaction with other threads. Do you give hard or soft guarantees - for example the view of the size of a multithreaded collection depends on whether you want to be quick and just return the local thread's current impression of the collection size, or do you want to be thorough but slow and give the completely accurate size across all threads (which means suspending element additions and removals until the sizing operation completes! This is a design decision (not implementation), and has definite performance consenqences. It may be worth providing multiple methods, some with hard guarantees and others with soft guarantees so the developer can choose what is best for them"



Java Performance News September 2014
We list all the latest Java performance related news and articles. "I look through all the Java sizeof implementations and choose the best"



September 2014 New Java Performance Tips
The latest Java performance tips from around the web, like "There are two high level reasons for bottlenecks: a node has insufficient capacity (making other requests queue); A shared resource is too busy handling other nodes to provide the resource to a requesting node, making the node wait to acquire the shared resource."



Java Performance News August 2014
We list all the latest Java performance related news and articles. "The GC tuning guide includes details about ergonomics, the various collectors (note it places G1 together with CMS as 'mostly' concurrent GCs); generations, sizing, GC phases, and much more"



August 2014 New Java Performance Tips
The latest Java performance tips from around the web, like "Apart from the core collections that come with the JDK, there are now many alternative collection frameworks. The following provide high performance options: Higher Frequency Trading's OpenHFT Collections; Carrotsearch's High Performance Primitive Collections (HPPC); The fastutil collections; Goldman Sachs GS-Collections; The Trove collections; Apache's Mahout Collections."



Java Performance News July 2014
We list all the latest Java performance related news and articles. "If you have any ideas for Java performance related tool categories, please do suggest them to me so that I can catalogue them and add a page on them"



July 2014 New Java Performance Tips
The latest Java performance tips from around the web, like "When using memory mapped files, your performance is at in-memory speeds as long as the memory mapped segments you are working on fit in memory. Once you go outside this area the OS needs to page out and in the pages you are addressing, so there is IO overhead. This is still highly efficient if you need to address more memory than you have available in RAM, but you should be aware of the tradeoff"



Java Performance News June 2014
We list all the latest Java performance related news and articles. "Please help me organise the over 700 Java performance tools I've referenced over the years"



June 2014 New Java Performance Tips
The latest Java performance tips from around the web, like "A sequence of Stream operations (called a pipeline) allows you to pass only one result from each step on to the next stage of the pipeline. If you want to pass multiple results, you must pass them as an object, but creating an object for the result of each individual comparison would hurt the performance of a stream approach compared to chunked approaches. Streams let's you handle this case efficiently by alowing you to pass a mutable intermediate container object which gets executed for each element"



Java Performance News May 2014
We list all the latest Java performance related news and articles. "I have the distinct impression that the JavaSphere has gone into overdrive"



May 2014 New Java Performance Tips
The latest Java performance tips from around the web, like "The main targets for tuning garbage collection are: 1) Modify the heap/permgen size; 2) Change the GC algorithm; 3) Configure the ratios between the memory regions"



Java Performance News April 2014
We list all the latest Java performance related news and articles. "the tuning target isn't really 'make it as fast as I can'. It's actually 'make it as fast as I can within a reasonable effort'. Now while that's not an ideal performance target, it is a valid one"



April 2014 New Java Performance Tips
The latest Java performance tips from around the web, like "GC characteristics you should optimize include: Stop-the-world pause time duration and frequency; CPU contention with the application; Heap fragmentation; GC memory overhead compared to application memory requirements"



Java Performance News March 2014
We list all the latest Java performance related news and articles. "low latency tips are practices that people have found work - I won't call them 'best' practices because often they aren't. But generally the advice centered around the ones detailed here ..."



March 2014 New Java Performance Tips
The latest Java performance tips from around the web, like "Off-heap memory storage is useful for low latency applications, to avoid GC overheads on that data; Low latency applications benefit from 'no-copy' implementations, where you avoid copying objects as much as possible, thus minimizing or even avoiding GC"



Using SharedHashMap
Jack Shirazi and Peter Lawrey give a worked example of using SharedHashMap, a high performance persisted off-heap hash map, shareable across processes.



Java Performance News February 2014
We list all the latest Java performance related news and articles. "A puzzler related to a performance anti-pattern - getting a null pointer exception seemingly without a null"



February 2014 New Java Performance Tips
The latest Java performance tips from around the web, like "Before Java 7u6 String.intern() was slow and not particularly efficient, nor was it tunable (and the internal String map was held in perm space). You were recommended to use your own WeakHashMap to create your own version of intern'ed strings. After Java 7u6 String.intern() is efficient, the map is now in the heap, and you can tune it's bucket size with -XX:StringTableSize= (default 1009 in Java 7, 60013 in Java 8)."



Java Performance News January 2014
We list all the latest Java performance related news and articles. "Locking is considered a pessimistic approach - you're assuming the worst case, that something else will try and change your value while you do, and so you lock them out so that you can guarantee you don't waste your operation. Compare-and-swap is an optimistic approach - you assume that mostly nothing else is going to change the value when you are, so it's best to just give it a go, and deal with (hopefully) the odd failure with a retry"



January 2014 New Java Performance Tips
The latest Java performance tips from around the web, like "Multidimensional arrays (in Java) are arrays of arrays, so not necessarily close in physical memory. You can convert a multidimensional array to a linear array, e.g. using a calculated index like array[ROWS * col + row]. Make sure the inner loop is iterating over sequential elements, if you get this the wrong way round you'll just get cache misses all the time (i.e. NOT array[COLS * row + col], but array[ROWS * col + row] where the inner loop is for (int row=0; row < ROWS; row++)"



Java Performance News December 2013
We list all the latest Java performance related news and articles. "quote of the year : when web companies grow up they turn into Java shops"



December 2013 New Java Performance Tips
The latest Java performance tips from around the web, like "Thread pools have various strategies to deal with incoming work when all threads are busy, e.g.: rejecting the excess work; waiting; executing the job in the thread adding the work. In the last case, this could potentially cause the work pipeline to stall behind one work item, even if the pool becomes free to accept more work, so should be considered carefully. The symptom for this situation would be for the 'adding' thread to be busy while many of the pool threads become idle."



Java Performance News November 2013
We list all the latest Java performance related news and articles. "Oracle are targeting providing deterministic low latency pauses in G1 - aiming for consistent deterministic pauses in the 10ms range"



November 2013 New Java Performance Tips
The latest Java performance tips from around the web, like "Software-based contention management can improve the performance of hardware based compare-and-swap operations. By using contention management and backoff techniques, you can improve throughput by an order of magnitude at high contention, with only a small overhead at low contention"



Multi-tenancy JVMs and Frameworks
Jack Shirazi lists all tools that support multi-tenancy, the ability to run more than one Java application in the same JVM while maintaining independence between the applications.



Java Performance Related Books
Jack Shirazi lists all Java performance related books



Java Performance News October 2013
We list all the latest Java performance related news and articles. "I've listed all the Java multi-tenancy tools in this month's tools section"



October 2013 New Java Performance Tips
The latest Java performance tips from around the web, like "Scalability problems are solved by: 1. Doing less work (simplest option); 2. Tuning what you have (simple to moderate difficulty); Throwing more resources at it (moderately difficult); Fixing the code (difficult); Rearchitecting (most difficult option)."



Java Performance News September 2013
We list all the latest Java performance related news and articles. "if you look in the JDK bin directory there are now many tools in there that I would categorize as providing "visibility" into the JVM: jcmd, jconsole, jhat, jinfo, jmap, jmc, jps, jsadebugd, jstack, jstat, jstatd, jvisualvm"



September 2013 New Java Performance Tips
The latest Java performance tips from around the web, like "If looping on Object.wait(), you might want to first reset the thread's interrupted state (e.g. if(Thread.currentThread().isInterrupted()) Thread.currentThread().interrupted();) before entering the wait() on each iteration or it could just throw the exception every iteration leading to a Livelock situation."



Java Performance News August 2013
We list all the latest Java performance related news and articles. "Load on the server is NOT a measure of user performance - if a user's session gets frozen, that reduces the load on the server. But for sure performance has not improved for that user."



August 2013 New Java Performance Tips
The latest Java performance tips from around the web, like "GC ergonomics (UseParallelGC with -XX:+UseAdaptiveSizePolicy) tries to meet, in order, the: pause time goal; throughput goal; minimum footprint. To find out what the ergonomics are doing, set -XX:AdaptiveSizePolicyOutputInterval=1 which will print the ergonomics details every GC."



Java Performance News July 2013
We list all the latest Java performance related news and articles. "the system was sufficiently fast that by the time it could be stopped, nearly half a billion dollars had already been lost"



June 2013 New Java Performance Tips
The latest Java performance tips from around the web, like "Most performance problems, once detected, are relatively easily solvable - so the biggest difficulties are in diagnosing the problem. Learning to use a profiler should be a core competency of any developer"



Java Performance News June 2013
We list all the latest Java performance related news and articles. "Is it worth fixing the leak or is the very cheap option of just having the heap big enough to last the run the best option?"



June 2013 New Java Performance Tips
The latest Java performance tips from around the web. If you don't know about the effect of NIC interrupt coalescing on latency-sensitive apps or the effect of following flags, you need to read this week's newsletter tips: -XX:+TieredCompilation -XX:PredictedClassLoadCount=# -XX:StringTableSize=# -XX:InitiatingHeapOccupancyPercent=n -XX:G1OldCSetRegionLiveThresholdPercent -XX:+UseNUMA



Java Performance News May 2013
We list all the latest Java performance related news and articles. "experts are hugely more productive than everyone else, and are worth their weight in gold"



May 2013 New Java Performance Tips
The latest Java performance tips from around the web, such as "Determine the fixed limits of resources. Measure usage as a proportion of the fixed limit, so you can immediately tell how close to exhasution they are" and "If you need warmup code, the system should not be able to distinguish between real and fake (e.g. a downstream system could filter the fakes). Avoid any conditional or class-specific code based on fake requests. Path depedencies should depend on the data in the request, not on code (though a smart enough compiler could even optimise that)."



Java Performance News April 2013
We list all the latest Java performance related news and articles. "software engineering has a cost model that mostly encourages us to build incomplete constructs, because it's relatively cheap to fix."



April 2013 New Java Performance Tips
The latest Java performance tips from around the web, such as "Where a deadlock is caused reversing the ordering of acquiring locks from both a synchronized object and ReentrantLock read lock, the JVM does not (yet) detect this." AND "Common load balancing algorithms (ignoring affinity) include: simple round-robin (each request goes to the next resource in a list); weighted round-robin (higher weighted resources get requests more frequently than lower weighted resources, resources of the same weight have requests distributed evenly); random distribution; utilisation-balanced (requests are sent to the resource which currently has the lowest utilisation)."



Java Performance News March 2013
We list all the latest Java performance related news and articles. "Load tests and stress tests rarely check for request storms on startup or failover, because the standard testing paradigm is to ramp up load gradually since that tends to be the most common load increase. If you don't have the 'request storm on startup and failover' scenario in your load test performance suite - it's time to add it."



March 2013 New Java Performance Tips
The latest Java performance tips from around the web, such as "If application processing is slow but there doesn't seem to be an abnormally high CPU usage, look for blocked threads across several stack dumps. These are likely showing lock contention causing a bottleneck in an otherwise parallel application. The stack traces and lock information show exactly where the contention is occurring."



Java Performance News February 2013
We list all the latest Java performance related news and articles. "Java is continually pronounced dead by Cluebies - let's just hope none of these Cluebies provide investment advice; with a track record that consistently wrong they would have recommended every disaster from Enron to Lehman as the next big winner to invest in!"



February 2013 New Java Performance Tips
The latest Java performance tips from around the web, such as "Percentiles (50th, 99th, 99.9th, 99.99th) are more accurate and informative than averages in the vast majority of distributed systems. Averages are normally only meanignfull for normal distribution statistics, and distributed systems tend to not show normal distribution for the statistics of most interest" and "Monitoring workflow consists of: collecting metrics; tracking them against a threshold; notifying if the threshold is breached; notifications are routed to the people that can handle them asap; providing dashboards (with drill down) that allow operators to see the status of (parts of) the system; providing trend visualization to allow identification and resolution of issues; and capacity analysis"



Java Performance News January 2013
We list all the latest Java performance related news and articles. "I've categorised the first batch of the 600 java performance tools we've listed over the last 12 years"



January 2013 New Java Performance Tips
The latest Java performance tips from around the web, such as "There is a difference between design optimization and code optimization - optimization is usually necessary at the design phase, and is not premature; not optimizing at the design phase can easily lead to bad architecture." and "Appropriate choices of data structures and algorithms are optimisations that are NOT premature."



GC log analysis tools
Jack Shirazi lists all the garbage collectors log analyser tools available for analysing garbage collections



Java Performance News December 2012
We list all the latest Java performance related news and articles. "Over the years we've had many tools that have tried to analyse GC logs. Sun had three (no longer supported); IBM supports two and HP supports one!"



December 2012 New Java Performance Tips
The latest Java performance tips from around the web, such as "The USE (utilization, saturation, and errors) methodology for identifying performance issues is for early use in a performance investigation to identify systemic bottlenecks quickly. It can be summarized as: For every resource, check utilization, saturation, and errors. Utilization is the percentage of time that the resource is busy servicing work during a specific time interval; Saturation is the degree to which a fully utilized resource has extra work pending; errors include retries as well as failures (retries often indicate a performance issue). Resources to monitor include: CPU utilization per core; CPU run-queue length; CPU faults; Avalable free memory; paging/swapping; failed mallocs; network IO utilization; NIC saturation; storage controller utilization; storage device utilization; storage device wait queue length; storage device error count; lock utilization (how long the locks were held); lock saturation (the number of threads waiting to acquire the lock); thread pool utilization (busy vs idle threads); thread pool saturation (waiting requests count); process/thread errors (e.g. can't fork); file descriptor errors (e.g. can't allocate/create)."