Performance

Deep Dive Into Multi-Threading in Java

Multi-threading represents a very intriguing topic, even after years of research and development for high quality, robust, and efficient software. With equal emphasis on hardware improvements and the software that runs on it – we have newer paradigms for parallelism.

The most important yet basic concepts are the ones which I present here. I then explain the intricacies of multi-threading in the Java programming language. Some of these are newer features and supported only from the Java Platform Standard Edition 5.0. Let us start with a quick overview and understanding of the core concepts.

A (Definitive?) Guide to LazyInitializationException

Posts that have been written about Hibernate’s LazyInitializationException could probably fill whole books.

Yet, I believe each of them focuses on a particular aspect of it: some on a specific solution, some on how to solve it with Spring Boot, etc.

I’d like this post to be the definitive guide on the subject, even though I’m pretty sure it won’t.

At least, I’ll be able to point others to it!

Billion Events Per Second with Millisecond Latency: Streaming Analytics at Giga-Scale

We’re preparing a scientific paper on Hazelcast Jet, describing its architecture based on symmetric, data-local, non-blocking distributed event processing. As a part of this effort, we implemented the vendor-neutral NEXMark benchmark suite, consisting of 8 streaming queries that aim to capture typical kinds of questions you’re likely to ask about your real-time data.

The queries deal with a domain model of auctions, sellers, and bids. For example, Query 5 asks: “Which auctions have achieved the highest price in the last period?”

Kicking Spring Native’s Tires

I’ve been playing with GraalVM Ahead-Of-Time compilation capability since I became aware of it.

As a long-time Spring aficionado, I carefully monitored the efforts that the engineers at Tanzu have put into making Spring AOT-compatible. Recently, they announced the beta version of the integration.

In this post, I want to check how easy it is to produce a (working!) Docker image from an existing Spring Boot application.

Evolution of Java Memory Architecture (Post Java 7.0)

Welcome to the next part of a series of articles on key concepts in Core Java and J2EE. The series revolves around memory architecture, connection and memory leaks, core Java syntax and semantics, Java Object layout/anatomy, multi-threading, asynchronous task execution, design patterns, Java agents, class loading, API design, OOPs & SOLID.

Today, we learn about the evolution of the Java Memory Architecture, post Java 7.0.

Evolution of Java Memory Architecture (Pre Java 8.0)

Welcome to a series of articles on key concepts in Core Java and J2EE. The series revolves around memory architecture, connection and memory leaks, core Java syntax and semantics, Java Object layout/anatomy, multi-threading, asynchronous task execution, design patterns, Java agents, class loading, API design, OOPs & SOLID.

In this part, we focus on the Java Memory Architecture, from before Java 8.

Towards Continuous Performance Regression Testing

JfrUnit is an extension for JUnit 5 which integrates Flight Recorder into unit tests.

It makes it straightforward to initiate a JFR recording for a given set of event types, execute some test routine, and then assert the JFR events which should have been produced.

Stay tuned for next parts in this series, where we’ll explore how to trace the SQL statements executed by an application using the JMC Agent and assert these query events using JfrUnit.

Safe Writing to Files in IoT and Industrial Systems

Especially on IoT devices, file corruption on shutdown is a common concern.

This article discusses how to write to disk safely in Java, combining disk sync, shutdown hooks, and atomic renaming of files.

A Compendium of 2021 Java & OpenJDK Predictions

Now that 2021 is well underway, many prominent Java developers have taken the time to predict what 2021 may bring to the Java universe.

In this post, I arrange these predictions and observations by topic, in essence creating a series of brief panel discussions about each topic area: a sort of mini-Java conference in the form of an article!

High Performance Rendering in JavaFX

In this article, we comparatively evaluate four different approaches to render particles in JavaFX in terms of runtime performance.

The approaches are Canvas, PixelBuffer AWT, PixelBuffer CPU and PixelBuffer GPU.

The evaluation suggests the following order of approaches from fastest to slowest:

– PixelBuffer GPU (fastest).
– PixelBuffer CPU.
– PixelBuffer AWT.
– Canvas (slowest).

Continuous Production Profiling and Diagnostics

I’ve gotten a lot of questions about continuous production profiling lately. Why would anyone want to profile in production, or, if production profiling seems reasonable, why the heck leave it on continuously?

I thought I’d take a few moments and share my take on the problem and the success I’ve seen the past years applying continuous production profiling in systems in the real world.

Profiling these days is no longer limited to high overhead development profilers. The capabilities of the production time profilers are steadily increasing and their value is becoming less controversial, some preferring them for complex applications even during development.