- Home
- The Newsletter
- Self-Study Courses
- How to Think Like a Java Programmer
- IntelliJ Wizardry 2022 Edition
- Data Structures in Java
- Bits & Bytes
- Refactoring to Java 8 Streams and Lambdas
- Java Design Patterns Course
- java.lang.reflect.*
- Mastering Java 11
- Extreme Java - Advanced Topics
- Extreme Java - Concurrency Performance
- Java Concurrency in Practice Bundle
- Java Specialists Superpack '23 (Everything)
- More...
- Classroom And Remote Courses
- Training Overview
- 1. IntelliJ Wizardry
- 2. Mastering Java 11
- 3. Mastering Java 17
- 4. Mastering Platform Threads
- 5. Mastering Virtual Threads (Loom)
- 6. Refactoring to Streams
- 7. Design Patterns
- 8. Reflection
- 9. Advanced Topics
- 10. Concurrency Performance
- 11. Concurrency Specialist
- 12. Reactive Programming
- In-house
- Self-study
- Slack
- About Us
- Contact
The JavaSpecialists' Newsletter
Celebrating 23 years of publication, enjoyed in over 155 countries by 70,000 of the world's top Java programmers and spanning over 300 specialist Java articles.
Newsletter Archive (Concurrency)
-
319 ArrayBlockingQueue: Weakly Consistent Iteration... 2024-10-25
Like many other concurrent collections, the ArrayBlockingQueue sports a weakly-consistent iterator. However, the ArrayBlockingQueue always has a maximum capacity, the length of the underlying array. In this newsletter we explore what happens to pending iterators when we wrap around the circular a... Full Article
-
311 Virtual Threads and Parallel Streams 2023-08-31
Virtual threads should not be used for CPU intensive tasks. The recommended approach is to continue using parallel streams for processing large data sets. However, we should be careful when invoking a parallel stream from a virtual thread. In this newsletter we propose a "safety valve" that can p... Full Article
-
305 Contributing BigInteger.parallelMultiply() to O... 2022-11-30
BigInteger has clever algorithms for multiplying large numbers. Unfortunately multiply() is single-threaded. Until now. In this newsletter I describe how the new parallelMultiply() method works and also how we can all contribute to the OpenJDK. Full Article
-
302 Virtual Thread Deadlocks 2022-06-30
Virtual threads can deadlock, just like platform threads. Depending on what state they are in, this might be quite challenging to analyze. In this newsletter we explore some tricks on how to find and solve them. Full Article
-
301 Gazillion Virtual Threads 2022-05-24
As from this month, Project Loom is part of the mainstream OpenJDK as a preview feature. Expect fantastical results, as bloggers around the world kick the tyres of this fantastic technology. In this newsletter we show how we can have over 36 billion parked virtual threads in just 4 gigabytes of m... Full Article
-
299 Synchronizing on Value-Based Classes 2022-03-31
Locking on Integer objects has always been a bad idea. And we now have a way to find such bad code with a runtime switch DiagnoseSyncOnValueBasedClasses. Full Article
-
296 Concurrent LinkedHashSet 2021-12-31
LinkedHashSet is a set that can also maintain order. To make this thread-safe, we can wrap it with Collections.synchronizedSet(). However, this is not a good option, because iteration would still be fast-fail. And what's the point of a thread-safe LinkedHashSet that we cannot iterate over? In thi... Full Article
-
292 StartingGun Synchronizer 2021-08-31
CountDownLatch is easy to understand, but can be hard to use, especially the await() method that throws InterruptedException. In this newsletter we show how we can create our own synchronizer based on the AbstractQueuedSynchronizer. Full Article
-
290 CopyOnWriteArrayList and Collection.toArray() 2021-06-10
When is it safe for a CopyOnWriteArrayList to accept the result from a toArray() method? In the past, the only thing that mattered was that the type was Object[]. But this was changed in 2020 to only accept the array if the source was a java.util.ArrayList. Full Article
-
282 Biased locking a goner, but better things Loom ... 2020-07-21
Biased locking has made unnecessary mutexes cheap for over a decade. However, it is disabled by default in Java 15, slated for removal. From Java 15 onwards we should be more diligent to avoid synchronized in places where we do not need it. Full Article
-
279 Upgrading ReadWriteLock 2020-05-28
The Java ReentrantReadWriteLock can never ever upgrade a read lock to a write lock. Kotlin's extension function ReentrantReadWriteLock.write() cheats a bit by letting go of the read lock before upgrading, thus opening the door for race conditions. A better solution is StampedLock, which has a met... Full Article
-
271 HttpClient Executors 2019-08-21
Java 11 added the HttpClient to give us a better way to send HTTP requests. It supports asynchronous and synchronous mode. HTTP2 comes out of the box. The threading is a bit funky though and Professor Cay Horstmann explores how things work underneath the covers. Full Article
-
266 Threading Questions in Job Interviews Part 2 2019-02-12
In our previous newsletter, we showed 14 typical questions that interviewers ask to find out if we know threading. Here are our model answers. Use them with caution. The interviewer is probably reading my newsletter. Full Article
-
265 Threading Questions in Job Interviews Part 1 2019-01-02
Asking detailed threading questions during an interview is like asking a football player to prove that he can sing well. Not necessarily relevant to their job description. And yet we see this commonly for Java jobs. In this newsletter we consider more than a dozen real questions that technical... Full Article
-
261 Concurrent Queue Sizes and Hot Fields 2018-09-20
ConcurrentLinkedQueue's size() method is not very useful in a multi-threaded environment, because it counts the number of elements in the queue, rather than relying on a "hot field" to store the size. The result might be completely incorrect, or in strange situations, never return. Full Article
-
257 CountDownLatch vs CyclicBarrier vs Phaser 2018-04-02
Java 7 gave us a brilliant new class called Phaser, which we can use to coordinate actions between threads. It replaces both CountDownLatch and CyclicBarrier, which are easier to understand, but harder to use. Full Article
-
249 @Contended @since 9 2017-08-23
Java 9 is more strict about what system internal classes we can use. So how can we use @Contended in Java 9? This article shows you how. Full Article
-
242 Concurrency Puzzle Explained, Solved With Stamp... 2016-10-31
Most programmers had a blind spot with the statement "arr[size++] = e;" We somehow think that size will be updated after the assignment. In this newsletter we look at this basic concurrency bug and also present a solution in the form of the Java 8 StampedLock. Full Article
-
241b Concurrency Puzzle Helpful Hints 2016-10-04
In the previous newsletter, we sent out a threading puzzle for you to solve. Here are some hints to help you figure out what is going on. Full Article
-
241 Concurrency Puzzle - System.arraycopy() 2016-09-29
"Friends don't let friends write low-level concurrency by themselves." -@karianna. Here is your chance to participate in a global code review puzzle to figure out what's going on in some synchronized code. Full Article
-
234 Random Code Failures - Race Conditions Between ... 2015-11-20
Most of the time our code fails because of bugs in our code. Rarely, however, bugs in the JVM ecosystem cause our systems to fail. These are insanely difficult to diagnose in production systems. In this newsletter we look at two different such race conditions between our code and the JVM. Full Article
-
220b Runtime.getRuntime().availableProcessors() (Fol... 2014-05-30
Whenever we have thread pools in our system, we need to make their size configurable. In this follow-up, we continue looking at some issues with the common fork/join pool that is used in Java 8. Full Article
-
220 Runtime.getRuntime().availableProcessors() 2014-05-28
Java 8 magically makes all our code run in parallel. If you believe that, I've got a tower in Paris that I'm trying to sell. Really good price. In this newsletter we look at how the parallism is determined and how we can influence it. Full Article
-
218 Thread Confinement 2014-02-18
One of the techniques we use to ensure that a non-threadsafe class can still be used by multiple threads is to give each thread its own instance. We call this "thread confinement". In this newsletter we look at some of the issues that can happen when this instance leaks. Full Article
-
215 StampedLock Idioms 2013-12-02
Java 8 includes a new synchronization mechanism called StampedLock. It differentiates between exclusive and non-exclusive locks, similar to the ReentrantReadWriteLock. However, it also allows for optimistic reads, which is not supported by the ReentrantReadWriteLock. In this newsletter, we loo... Full Article
-
214 CountingCompletionService 2013-10-10
CompletionService queues finished tasks, making it easier to retrieve Futures in order of completion. But it lacks some basic functionality, such as a count of how many tasks have been submitted. Full Article
-
206 Striped Executor Service 2012-11-13
We present a new type of ExecutorService that allows users to "stripe" their execution in such a way that all tasks belonging to one stripe are executed in-order. Full Article
-
202 Distributed Performance Tuning 2012-05-28
In this newsletter, it is up to you to figure out how we improved the performance of our previous Fibonacci newsletter by 25%. Full Article
-
201 Fork Join with Fibonacci and Karatsuba 2012-05-24
The new Java 7 Fork/Join Framework allows us to define our algorithms using recursion and then to easily parallelize them. In this newsletter we describe how that works using a fast Fibonacci algorithm that uses the sum of the squares rather than brute force. We also present a faster algorithm ... Full Article
-
196 Uncaught AWT Exceptions in Java 7 2011-11-29
Java 7 removes the Swing Event Dispatch Thread (EDT) hack that allowed us to specify an uncaught exception handler for the EDT using a system property sun.awt.exception.handler. Full Article
-
194 trySynchronize 2011-08-27
Did you know that it possible to "try" to synchronize a monitor? In this newsletter we demonstrate how this can be used to avoid deadlocks and to keep the wine coming. Full Article
-
192b How Does "this" Escape? 2011-06-01
A quick follow-up to the previous newsletter, to show how the ThisEscape class is compiled, causing the "this" pointer to leak. Full Article
-
192 Implicit Escape of "this" 2011-05-31
We should never allow references to our objects to escape before all the final fields have been set, otherwise we can cause race conditions. In this newsletter we explore how this is possible to do. Full Article
-
188 Interlocker - Interleaving Threads 2010-10-31
In this newsletter, we explore a question of how to call a method interleaved from two threads. We show the merits of lock-free busy wait, versus explicit locking. We also discuss an "unbreakable hard spin" that can cause the JVM to hang up. Full Article
-
184 Deadlocks Through Cyclic Dependencies 2010-06-04
A common approach to ensuring serialization consistency in thread safe classes such as Vector, Hashtable or Throwable is to include a synchronized writeObject() method. This can result in a deadlock when the object graph contain a cyclic dependency and we serialize from two threads. Whilst unli... Full Article
-
160 The Law of the Uneaten Lutefisk 2008-05-12
Imagine a very stubborn viking father insisting that his equally stubborn child eat its lutefisk before going to sleep. In real life one of the "threads" eventually will give up, but in Java, the threads become deadlocked, with neither giving an inch. In this newsletter we discover how we can s... Full Article
-
159 The Law of Sudden Riches 2008-05-05
We all expect faster hardware to make our code execute faster and better. In this newsletter we examine why this is not always true. Sometimes the code breaks on faster servers or executes slower than on worse hardware. Full Article
-
156 The Law of Cretan Driving 2008-02-26
The Law of Cretan Driving looks at what happens when we keep on breaking the rules. Eventually, we might experience a lot of pain when we migrate to a new architecture or Java Virtual Machine. Even if we decide not to obey them, we need to know what they are. In this newsletter, we point you t... Full Article
-
155 The Law of the Micromanager 2008-01-16
In good Dilbert style, we want to avoid having Pointy-Haired-Bosses (PHBs) in our code. Commonly called micromanagers, they can make a system work extremely inefficiently. My prediction is that in the next few years, as the number of cores increases per CPU, lock contention is going to be the bi... Full Article
-
152 The Law of the Corrupt Politician 2007-11-12
Corruption has a habit of creeping into system that do not have adequate controls over their threads. In this law, we look at how we can detect data races and some ideas to avoid and fix them. Full Article
-
151 The Law of the Leaked Memo 2007-10-04
In this fifth law of concurrency, we look at a deadly law where a field value is written early. Full Article
-
150 The Law of the Blind Spot 2007-09-05
In this fourth law of concurrency, we look at the problem with visibility of shared variable updates. Quite often, "clever" code that tries to avoid locking in order to remove contention, makes assumptions that may result in serious errors. Full Article
-
149 The Law of the Overstocked Haberdashery 2007-08-20
Learn how to write correct concurrent code by understanding the Secrets of Concurrency. This is the third part of a series of laws that help explain how we should be writing concurrent code in Java. In this section, we look at why we should avoid creating unnecessary threads, even if they are n... Full Article
-
147 The Law of the Distracted Spearfisherman 2007-07-20
Learn how to write correct concurrent code by understanding the Secrets of Concurrency. This is the second part of a series of laws that help explain how we should be writing concurrent code in Java. We look at how to debug a concurrent program by knowing what every thread in the system is doing. Full Article
-
146 The Secrets of Concurrency (Part 1) 2007-06-26
Learn how to write correct concurrent code by understanding the Secrets of Concurrency. This is the first part of a series of laws that help explain how we should be writing concurrent code in Java. Full Article
-
093 Automatically Detecting Thread Deadlocks 2004-07-28
Deadlocks between synchronized monitors are impossible to resolve in Java. In this newsletter we look at a new MXBean that can detect deadlocks between threads and use it to warn us. Full Article
Subscribe Now
Get: every new article, exclusive invites to live webinars, our top-10 articles ever, access to expert tutorials & more!
About the Author
Java Champion, author of the Javaspecialists Newsletter, conference speaking regular... About Heinz
Superpack '23
Our entire Java Specialists Training in one huge bundle
more...
Free Java Book
Java Training
We deliver relevant courses, by top Java developers to produce more resourceful and efficient programmers within their organisations.
Java Consulting
We can help make your Java application run faster and trouble-shoot concurrency and performance bugs...
JavaSpecialists
We deliver relevant courses, by top Java developers to produce more resourceful and efficient programmers within their organisations. Find Out More
Quick Links
Connect With Us
Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners. JavaSpecialists.eu is not connected to Oracle, Inc. and is not sponsored by Oracle, Inc.