71 posts
Today I got GitHub's email, 'GitHub Copilot: What's in your free plan 🤖'. Copilot now has a free tier open to everyone, including two large models: OpenAI GPT-4o and Anthropic.
If you use the Flowable/Activiti process engine and the application hangs on startup with the error 'liquibase - Waiting for changelog lock....', it means a database table's lock was never released. This isn't a database-level table lock, so you won't find any locked table by querying — it's a logical lock.
In Spring Boot we commonly use @RestControllerAdvice and @ControllerAdvice to catch exceptions globally and handle them gracefully — but it can't really catch everything. A case I ran into: a custom filter extending OncePerRequestFilter validates the token, and when the token expires it throws an ExpiredJwtException that never gets caught.
A colleague on site reported that my application would periodically freeze with no response and no error logs — API requests just hung waiting. After they sent me a thread dump, I saw most threads in WAITING, stuck in com.alibaba.druid.pool.DruidDataSource.takeLast(). Solution first, root cause after.
In Spring projects we often use maven variables to switch environments — for example the @activatedProperties@ placeholder in this post, passed in at maven packaging time so the config file can switch between runtime environments.
What's a cron expression? If you're reading this, you probably already know what it's for: when setting up scheduled tasks on Linux, Spring or Quartz, you write a cron expression to define the execution cycle. Cron is pronounced /krɒn/ — like 'chron' in chronology.
Spring Boot 3.0.0 was officially released on November 25, 2022. As someone who likes chasing the new and eating crab first, I had to upgrade and try it. In the end, though, I gave up.
Before discussing volatile we need to understand JMM (Java Memory Model) first. Jumping straight to volatile without JMM feels odd, so let's cover JMM. To guarantee correctness of shared memory (visibility, ordering, atomicity), the memory model defines the rules for read/write behavior in multithreaded programs on shared memory systems.
The classic variable operation is increment: turning 1 into 2. Single-threaded, no problem. But the moment two threads operate on the same variable, trouble appears — that's related to Java's memory model, JMM, which I'll cover in the next article on volatile. If thread A already changed the variable to 2 while thread B increments at the same time without seeing that change and also sets it to 2, two increments should give 3 but give 2 instead. That's what brings CAS in.
Surely you've heard plenty of experts talk about AQS. So what is it? From the name AbstractQueuedSynchronizer we can guess it's an abstract queued synchronizer. Every character makes sense on its own; string them together and it stops making sense. Let's break it apart.
