This post outlines a non-intrusive method for diagnosing CPU spikes in Java Virtual Machine (JVM) applications using the open-source yCrash data script. It captures 360° data without significant overhead, enabling thorough analysis of CPU-consuming threads. Users can diagnose issues and obtain root cause reports efficiently, aiding in effective troubleshooting.
Java virtual threads, introduced in JDK 19, enhance application performance but come with pitfalls. Developers should avoid synchronized blocks, thread pools, and excessive use of ThreadLocal variables. Implementing ReentrantLock and Semaphore can mitigate resource access issues, enhancing memory efficiency by preventing unnecessary blocking and managing concurrent accesses effectively.
ConFoo Montreal is a conference for developers featuring a global exchange of knowledge. Architect Ram Lakshmanan presented on "Memory Patterns to predict production outages," discussing six unique memory patterns that help forecast outages and optimize application performance. Attendees could view videos, presentations, and feedback from the conference.
ConFoo Montreal is a technology conference for developers featuring global speakers. Architect Ram Lakshmanan discussed "KNOWN JAVA APIs, UNKNOWN PERFORMANCE IMPACT," highlighting commonly used Java APIs and their potential performance consequences. The session included video content, slides, and student feedback, emphasizing the importance of understanding API impacts on application performance.
This post discusses variable scopes in Java, focusing on ThreadLocal variables that are specific to individual threads. ThreadLocal avoids costly refactoring by allowing thread-specific data access without passing variables through method calls. While it offers benefits like reduced code changes and contextual data storage, it poses challenges such as data safety and debugging complexities.
The Java clear() API removes all elements from a collection, like ArrayList, but retains the underlying Object array, which consumes memory. This post explores how clear() operates, its performance impacts compared to assigning null, and scenarios where using clear() is more appropriate, such as avoiding NullPointerExceptions.
We express our gratitude to Entwinkler.de JavaMagazin for translating our article ‘Simulating and troubleshooting deadlocks in Kotlin’ into German. It is an honor to have it published in their December 2022 issue as ‘Simulation und Fehlerbehebung von Deadlocks in Kotlin’.
This post explains Java's synchronized methods, allowing only one thread to access a method at a time. It contrasts the behavior of non-synchronized and synchronized methods using an example involving multiple threads representing boyfriends meeting a girlfriend. The synchronized method ensures sequential execution, preventing threads from entering before the current one finishes.
The post explores the behavior of synchronized methods in Java when two threads attempt to execute different synchronized methods of the same object. It demonstrates that when one thread holds a lock on an object's synchronized method, the other thread is blocked from executing another synchronized method on the same object until the first thread completes.
This post explores static synchronized methods in Java with a demonstration involving two methods in a class. It highlights how only one thread can execute a static synchronized method at a time, using a thread dump analysis to illustrate the blocking nature of synchronization. The behavior when combining static and non-static methods is also examined.