BestHub
Sign in
Tagged articles

synchronized

99 articles · Page 1 of 1
Coder Trainee
Coder Trainee
Jul 12, 2026 · Backend Development

10 Must‑Know Java Concurrency Interview Questions

This article walks through ten essential Java concurrency interview topics—including the Java Memory Model, volatile semantics, synchronized lock upgrades, CAS pitfalls, AQS internals, ReentrantLock versus synchronized, ThreadPoolExecutor parameters, ThreadLocal memory‑leak issues, CountDownLatch vs CyclicBarrier, and deadlock conditions—providing code snippets, tables and detailed explanations to help candidates answer interview questions confidently.

AQSCASDeadlock
0 likes · 12 min read
10 Must‑Know Java Concurrency Interview Questions
Coder Trainee
Coder Trainee
Jul 6, 2026 · Backend Development

Deep Dive into Java Concurrency: Practical ReentrantLock and Condition Usage

This article thoroughly compares Java's synchronized keyword with ReentrantLock, explains lock implementation details, fairness, interruptibility, timeout, and Condition usage, provides practical code examples and interview tips, and offers guidance on when to choose each synchronization mechanism.

AQSConditionLock
0 likes · 8 min read
Deep Dive into Java Concurrency: Practical ReentrantLock and Condition Usage
Coder Trainee
Coder Trainee
Jul 4, 2026 · Backend Development

Deep Dive into Java Concurrency: The Source-Level Mechanics of synchronized

This article thoroughly examines Java's synchronized keyword, covering its three usage forms, the underlying bytecode instructions, how lock information is stored in the object header's Mark Word, the step‑by‑step lock upgrade process from no‑lock to heavyweight, and JVM optimizations such as lock elimination and coarsening, providing interview‑ready explanations.

JVMLockObject header
0 likes · 10 min read
Deep Dive into Java Concurrency: The Source-Level Mechanics of synchronized
Coder Trainee
Coder Trainee
Jul 3, 2026 · Fundamentals

Deep Dive into Java Concurrency Part 1: Understanding the Core via JMM

This article launches a new series on Java concurrency, explaining why concurrent programming is hard due to hardware, OS and compiler effects, detailing the Java Memory Model’s happens‑before rules, memory barriers, volatile semantics, and comparing volatile with synchronized, plus a practical double‑checked locking example.

Volatileconcurrencydouble-checked locking
0 likes · 8 min read
Deep Dive into Java Concurrency Part 1: Understanding the Core via JMM
Programmer1970
Programmer1970
May 31, 2026 · Fundamentals

Why synchronized is slower – tracing its roots from MESI cache coherence

The article demystifies why Java's synchronized keyword can be slower by tracing the full path from CPU cache‑coherence (MESI) through bus and cache locks, volatile, biased and lightweight locks, up to the heavyweight monitor implementation, revealing each layer’s impact on visibility, ordering and atomicity.

JVMVolatilecache-coherence
0 likes · 15 min read
Why synchronized is slower – tracing its roots from MESI cache coherence
samdeepthink
samdeepthink
May 21, 2026 · Fundamentals

Why Java’s wait() Must Be Called Inside a synchronized Block

Because wait() first releases the monitor, the calling thread must own the lock; the JVM enforces this with an IllegalMonitorStateException, and the synchronized block prevents the lost‑wake‑up race by atomically checking conditions and releasing the lock before waiting.

javamonitornotify
0 likes · 10 min read
Why Java’s wait() Must Be Called Inside a synchronized Block
macrozheng
macrozheng
Nov 21, 2025 · Backend Development

Master Java Concurrency: Locks, Singleton Patterns, ThreadLocal, Reflection and More

This article provides a comprehensive guide to Java concurrency and related concepts, covering synchronized lock upgrades, object vs class locks, lazy and double‑checked singleton implementations, ThreadLocal mechanics, reflection usage, annotation scopes, JVM class loading, and Redis cluster threading behavior.

JVMRedisThreadLocal
0 likes · 22 min read
Master Java Concurrency: Locks, Singleton Patterns, ThreadLocal, Reflection and More
Cognitive Technology Team
Cognitive Technology Team
Aug 17, 2025 · Backend Development

synchronized vs Lock in Java: When to Choose Each for Thread Safety

This article examines the core differences between Java's synchronized keyword and the Lock interface, covering their principles, performance, flexibility, visibility guarantees, reentrancy, interruption handling, and practical selection guidelines with code examples, tables, and real‑world scenarios to help developers choose the appropriate locking mechanism.

LockReentrantLockThread Safety
0 likes · 9 min read
synchronized vs Lock in Java: When to Choose Each for Thread Safety
The Dominant Programmer
The Dominant Programmer
Jul 9, 2025 · Fundamentals

Mastering Java Thread Communication: volatile, synchronized, wait/notify, and Piped Streams

This article explains how Java threads interact using volatile for visibility, synchronized blocks for mutual exclusion, wait/notify (and Condition) for coordination, piped streams for one‑way byte communication, as well as Thread.join and ThreadLocal utilities, providing concrete code examples, best‑practice guidelines, and performance considerations.

PipedStreamThreadLocalVolatile
0 likes · 23 min read
Mastering Java Thread Communication: volatile, synchronized, wait/notify, and Piped Streams
IT Services Circle
IT Services Circle
May 10, 2025 · Backend Development

Understanding Java synchronized: Locks, Optimizations, and Example Code

This article explains how Java's synchronized keyword works, covering object and class locks, lock upgrades such as biased, lightweight, and heavyweight locks, the underlying monitor implementation, example code for a thread‑safe counter, and performance considerations for high‑concurrency scenarios.

concurrencyjavalocking
0 likes · 7 min read
Understanding Java synchronized: Locks, Optimizations, and Example Code
Su San Talks Tech
Su San Talks Tech
Mar 28, 2025 · Backend Development

Unlocking Java’s Synchronized: How the JVM Implements Locks

This article explains the low‑level implementation of Java's synchronized keyword, covering monitorenter/monitorexit bytecode, object header structures, Mark Word layouts, and the evolution from heavyweight locks to biased and lightweight locks with lock‑upgrade mechanisms.

JVMLockconcurrency
0 likes · 11 min read
Unlocking Java’s Synchronized: How the JVM Implements Locks
Selected Java Interview Questions
Selected Java Interview Questions
Feb 18, 2025 · Backend Development

Why Java synchronized Is Insufficient in Distributed Systems and Alternative Lock Solutions

The article explains how Java's synchronized keyword works only within a single JVM, why it fails to provide mutual exclusion across multiple processes in distributed systems, and presents alternative distributed locking mechanisms such as database locks and Redis-based locks with code examples.

Redisconcurrencydatabase lock
0 likes · 8 min read
Why Java synchronized Is Insufficient in Distributed Systems and Alternative Lock Solutions
FunTester
FunTester
Dec 26, 2024 · Fundamentals

Chapter 2 – Common Java Multithreading Utilities and the synchronized Keyword

This chapter introduces advanced Java multithreading concepts, explaining thread safety, the synchronized keyword, various synchronization techniques, and practical code examples such as object‑level, class‑level, method‑level synchronization and double‑checked locking to help solve concurrency problems in performance testing.

concurrencyjavaperformance-testing
0 likes · 15 min read
Chapter 2 – Common Java Multithreading Utilities and the synchronized Keyword
Java Architect Essentials
Java Architect Essentials
Sep 12, 2023 · Fundamentals

Why volatile and synchronized Can't Prevent Instruction Reordering in Java

An in‑depth analysis of Java’s instruction reordering versus ordered execution, illustrating how volatile ensures visibility but not atomicity, how synchronized guarantees atomicity and ordering yet cannot stop bytecode‑level reordering, with detailed DCL singleton bytecode walkthrough and multithreaded examples.

BytecodeVolatileconcurrency
0 likes · 7 min read
Why volatile and synchronized Can't Prevent Instruction Reordering in Java
Tencent Cloud Developer
Tencent Cloud Developer
Aug 17, 2023 · Backend Development

Java Memory Model and Concurrent Programming: Visibility, Ordering, and Atomicity

The article explains how the Java Memory Model addresses concurrency challenges by defining visibility, ordering, and atomicity guarantees through mechanisms such as volatile, synchronized, cache coherence, memory barriers, CAS operations, and happens‑before relationships, enabling correct and portable multi‑threaded programming.

AtomicityCASConcurrent Programming
0 likes · 25 min read
Java Memory Model and Concurrent Programming: Visibility, Ordering, and Atomicity
Architecture Digest
Architecture Digest
Aug 10, 2023 · Fundamentals

Instruction Reordering and Ordering in Java Double-Checked Locking

The article explains the difference between instruction reordering and ordering, analyzes how the double‑checked locking pattern can suffer from reordering at the bytecode level, and demonstrates how synchronized provides ordering while volatile only prevents visibility issues, using Java code examples and detailed bytecode analysis.

Volatileconcurrencydouble-checked locking
0 likes · 7 min read
Instruction Reordering and Ordering in Java Double-Checked Locking
Selected Java Interview Questions
Selected Java Interview Questions
Aug 3, 2023 · Backend Development

Instruction Reordering and Ordering in Java: Analysis of Double-Checked Locking

The article explains the distinction between instruction reordering and ordering in Java, analyzes how volatile and synchronized affect memory visibility and atomicity, and demonstrates with bytecode and multithreaded examples why double‑checked locking requires both volatile and synchronized to avoid partially constructed singleton instances.

Volatileconcurrencydouble-checked locking
0 likes · 6 min read
Instruction Reordering and Ordering in Java: Analysis of Double-Checked Locking
Sanyou's Java Diary
Sanyou's Java Diary
Apr 20, 2023 · Fundamentals

Mastering Java’s synchronized: How It Works, Optimizations & Best Practices

This article explains the Java synchronized keyword, covering its purpose for thread safety, usage on methods and blocks, underlying monitor lock mechanism, JVM bytecode details, lock optimizations such as spin, bias, lightweight and heavyweight locks, and practical examples including singleton implementation and differences from volatile.

Thread Safetylock optimizationmonitor lock
0 likes · 27 min read
Mastering Java’s synchronized: How It Works, Optimizations & Best Practices
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Mar 3, 2023 · Mobile Development

Understanding Java Object Locks and Their Implementation in the Android Runtime (ART)

The article explains how Java’s synchronized keyword works by describing instance, static and block locks, the monitor‑enter/exit bytecodes, the ART object header’s lock word states (thin, fat, hash, forwarding), lock inflation mechanisms, and the internal runtime functions that implement Object.wait(), notify() and related futex handling.

Android RuntimeJVMjava
0 likes · 13 min read
Understanding Java Object Locks and Their Implementation in the Android Runtime (ART)
JD Retail Technology
JD Retail Technology
Feb 21, 2023 · Fundamentals

Understanding Java Object Memory Layout, Monitor, and Synchronization Mechanisms

This article explains the JVM object memory layout—including object header, instance data, and alignment padding—details the structure of the Mark Word and Klass Word, describes how monitors and the synchronized keyword work at the bytecode level, and covers lock states, inflation, bias revocation, and spin optimizations with practical code examples.

JVMLockObject Memory Layout
0 likes · 20 min read
Understanding Java Object Memory Layout, Monitor, and Synchronization Mechanisms
Top Architect
Top Architect
Oct 17, 2022 · Backend Development

Understanding Java Locks: volatile, synchronized, monitor, CAS, and AQS

This article explains why locks are needed in Java, describes the fundamentals of volatile and synchronized, details the monitor‑based implementation of synchronized, introduces CAS operations, and outlines advanced lock mechanisms such as biased, lightweight, lock coarsening, elimination, and the AbstractQueuedSynchronizer framework.

AQSCASLocks
0 likes · 11 min read
Understanding Java Locks: volatile, synchronized, monitor, CAS, and AQS
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 27, 2022 · Backend Development

Four Common Ways to Implement Thread Synchronization in Java

This article explains the concept of thread synchronization in Java and provides detailed examples of four implementation methods—using the synchronized keyword, ReentrantLock, atomic variables, and ThreadLocal—along with code snippets and a comparison of their advantages and usage scenarios.

ReentrantLockThread SynchronizationThreadLocal
0 likes · 6 min read
Four Common Ways to Implement Thread Synchronization in Java
Top Architect
Top Architect
Aug 26, 2022 · Backend Development

Deep Dive into Java synchronized and Lock Mechanisms: Principles, JVM Internals, and Optimizations

This article explains thread safety in Java by detailing how the synchronized keyword and various Lock implementations work, covering their underlying JVM mechanisms, lock upgrade paths, optimizations like biased and lightweight locks, and practical differences between synchronized, ReentrantLock, and ReadWriteLock.

JVMLockReadWriteLock
0 likes · 19 min read
Deep Dive into Java synchronized and Lock Mechanisms: Principles, JVM Internals, and Optimizations
Top Architect
Top Architect
Aug 23, 2022 · Backend Development

Understanding the Implementation of synchronized in Java and Its Differences with Lock

This article explains how Java's synchronized keyword works at the JVM level, detailing monitorenter/monitorexit bytecode, the role of object monitors, differences between synchronized methods and blocks, and compares its behavior and performance with explicit Lock implementations such as ReentrantLock, including code examples and practical considerations.

JVMLockReentrantLock
0 likes · 8 min read
Understanding the Implementation of synchronized in Java and Its Differences with Lock
Selected Java Interview Questions
Selected Java Interview Questions
Aug 22, 2022 · Backend Development

Understanding Java synchronized and Lock Mechanisms: From Basic Locks to Advanced Optimizations

This article explains Java thread‑safety concepts, the synchronized keyword, its underlying monitor implementation, lock‑upgrade stages, JVM optimizations such as lock elimination and coarsening, and compares explicit Lock interfaces like ReentrantLock and ReadWriteLock, helping developers choose the appropriate synchronization tool.

JVMLockReadWriteLock
0 likes · 16 min read
Understanding Java synchronized and Lock Mechanisms: From Basic Locks to Advanced Optimizations
ITPUB
ITPUB
Jul 31, 2022 · Fundamentals

What Really Happens Inside Java’s synchronized? A Deep Dive into JVM Lock Mechanisms

This article examines the inner workings of Java’s synchronized keyword by analyzing HotSpot 1.8 source code, revealing how lightweight, heavyweight, biased, and adaptive spin locks operate, how lock inflation occurs, and how the JVM manages monitor objects, CAS operations, and thread queues to implement synchronization.

JVMconcurrencyjava
0 likes · 17 min read
What Really Happens Inside Java’s synchronized? A Deep Dive into JVM Lock Mechanisms
IT Architects Alliance
IT Architects Alliance
Apr 29, 2022 · Fundamentals

Why Your Java Producer‑Consumer Code Deadlocks and How to Fix It

This article explains the root causes of thread‑safety problems in Java producer‑consumer scenarios, demonstrates how race conditions and deadlocks arise, and provides step‑by‑step solutions using synchronized blocks, wait/notify, notifyAll, and explicit Lock with Condition objects.

DeadlockLockThread Safety
0 likes · 20 min read
Why Your Java Producer‑Consumer Code Deadlocks and How to Fix It
Su San Talks Tech
Su San Talks Tech
Feb 23, 2022 · Fundamentals

Why Does synchronized Fail with Integer Locks? Deep Dive into Java Concurrency

This article examines why Java's synchronized keyword can become ineffective when locking on an Integer object, explores how autoboxing and Integer caching cause lock objects to change, and presents reliable alternatives such as class‑level locks or explicit lock maps for safe multithreaded programming.

Integerconcurrencylocking
0 likes · 18 min read
Why Does synchronized Fail with Integer Locks? Deep Dive into Java Concurrency
Selected Java Interview Questions
Selected Java Interview Questions
Jan 25, 2022 · Fundamentals

Understanding Java synchronized and ReentrantLock: When Multiple Threads Can Access Synchronized Methods

This article examines how Java's synchronized keyword and ReentrantLock behave when multiple threads invoke two synchronized methods of the same class, exploring scenarios with the same instance, different instances, and Runnable run methods, and summarizing the resulting concurrency rules.

ReentrantLockconcurrencyjava
0 likes · 15 min read
Understanding Java synchronized and ReentrantLock: When Multiple Threads Can Access Synchronized Methods
Ops Development Stories
Ops Development Stories
Sep 13, 2021 · Backend Development

Mastering Java Locks: When to Use synchronized vs ReentrantLock

This article explains how Java locks solve concurrent access problems, compares the built‑in synchronized lock with ReentrantLock, describes their upgrade mechanisms, usage patterns, and scenarios, and offers guidance on choosing the appropriate lock for different environments.

LocksReentrantLockconcurrency
0 likes · 7 min read
Mastering Java Locks: When to Use synchronized vs ReentrantLock
Youzan Coder
Youzan Coder
Jul 8, 2021 · Backend Development

Deep Dive into Java Thread States and Synchronized Lock Implementation

The article thoroughly explains Java thread states and how the synchronized keyword is implemented, detailing the mapping to OS thread states, the object header’s Mark Word, biased, lightweight and heavyweight locking, CAS‑based state transitions, bytecode monitor instructions, lock upgrades, and optimal usage scenarios.

JVM internalsjavalocking
0 likes · 39 min read
Deep Dive into Java Thread States and Synchronized Lock Implementation
TAL Education Technology
TAL Education Technology
May 13, 2021 · Backend Development

Understanding Java Concurrency: Volatile, Synchronized, JMM, and MESI

This article provides a comprehensive tutorial on Java concurrency, covering the usage and implementation principles of the volatile and synchronized keywords, the Java Memory Model, the MESI cache protocol, common visibility and reordering issues, and practical code examples for designing efficient multithreaded solutions.

Volatileconcurrencyjava
0 likes · 17 min read
Understanding Java Concurrency: Volatile, Synchronized, JMM, and MESI
Top Architect
Top Architect
May 11, 2021 · Fundamentals

Understanding Java Locks: From Synchronized to Lock Upgrade Mechanisms

This article explains how Java implements locks—from the basic use of the synchronized keyword and Lock interface to the internal object header structures, bias, lightweight, and heavyweight lock upgrades, and the role of CAS and monitor objects in JVM concurrency control.

JVMLock UpgradeLocks
0 likes · 18 min read
Understanding Java Locks: From Synchronized to Lock Upgrade Mechanisms
JavaEdge
JavaEdge
Apr 27, 2021 · Backend Development

Why Does Java Provide Both synchronized and Lock? Uncover the Real Differences

This article explains the core concepts of Java concurrency, comparing mutual exclusion and synchronization, detailing how JUC's Lock and Condition implement monitors, why Lock offers interruptible, timed, and non‑blocking acquisition, and how visibility and reentrancy are guaranteed through volatile state and Happens‑Before rules.

JUCReentrantLockjava
0 likes · 9 min read
Why Does Java Provide Both synchronized and Lock? Uncover the Real Differences
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 20, 2021 · Fundamentals

Understanding JVM Memory Structure and the Java Memory Model (JMM): volatile, synchronized and Concurrency Basics

This article explains the differences between JVM memory layout and the Java Memory Model, clarifies how volatile and synchronized guarantee visibility, atomicity and ordering, and provides practical guidelines, code examples, and diagrams for mastering Java concurrency fundamentals.

JVMMemory ModelVolatile
0 likes · 35 min read
Understanding JVM Memory Structure and the Java Memory Model (JMM): volatile, synchronized and Concurrency Basics
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Feb 19, 2021 · Fundamentals

Comprehensive Guide to Java synchronized Locks: Usage, Scenarios, and Pitfalls

This article explains the various usages of Java's synchronized keyword, including class locks, object locks, static and instance methods, code blocks, and important considerations such as non‑interruptibility, reentrancy, lack of timeout, and best‑practice performance tips, illustrated with multiple demo programs.

javalockingmultithreading
0 likes · 19 min read
Comprehensive Guide to Java synchronized Locks: Usage, Scenarios, and Pitfalls
Top Architect
Top Architect
Oct 14, 2020 · Fundamentals

Deep Dive into Java synchronized: Object Header, Lock Types, and JVM Implementation

This article provides a comprehensive analysis of the HotSpot JVM implementation of the synchronized keyword, covering object header layout, the three lock states (biased, lightweight, heavyweight), their acquisition and release processes, bytecode differences, and practical code examples to help readers understand Java concurrency internals.

JVMObject headerconcurrency
0 likes · 16 min read
Deep Dive into Java synchronized: Object Header, Lock Types, and JVM Implementation
Programmer DD
Programmer DD
Aug 20, 2020 · Fundamentals

Unlocking Java’s synchronized: When Does It Really Protect?

This article explores Java’s synchronized keyword in depth, covering its purpose, usage with object and class locks, seven multithreading scenarios, core principles like reentrancy and visibility, performance drawbacks, and best practices for choosing between synchronized and explicit Lock implementations.

concurrencylockingmultithreading
0 likes · 18 min read
Unlocking Java’s synchronized: When Does It Really Protect?
Top Architect
Top Architect
Jun 17, 2020 · Fundamentals

Understanding Java synchronized: Overview, Usage, Scenarios, Principles, Drawbacks, and FAQs

This article provides a comprehensive guide to Java's synchronized keyword, covering its purpose, object and class lock usage, seven multithreading scenarios, reentrancy and non‑interruptibility properties, underlying lock and visibility mechanisms, performance drawbacks, and common questions with detailed code examples.

javalockingmultithreading
0 likes · 20 min read
Understanding Java synchronized: Overview, Usage, Scenarios, Principles, Drawbacks, and FAQs
Youzan Coder
Youzan Coder
Jun 12, 2020 · Fundamentals

When to Use synchronized vs. Lock: Mastering Java Locks

This article explains Java's lock mechanisms, comparing synchronized and the Lock interface, detailing their usage, implementation via AQS, system‑level primitives, and providing code examples to help developers choose the appropriate synchronization tool.

AQSLockconcurrency
0 likes · 11 min read
When to Use synchronized vs. Lock: Mastering Java Locks
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 20, 2020 · Fundamentals

An Introduction to Java synchronized: Features, Implementation, and Optimizations

This article explains the Java synchronized keyword, detailing its four core properties—atomicity, visibility, ordering, and reentrancy—while illustrating its bytecode behavior, lock types, upgrade mechanisms, and JVM optimizations such as biased, lightweight, and heavyweight locks, lock elimination, and lock coarsening.

lockingmultithreadingsynchronized
0 likes · 15 min read
An Introduction to Java synchronized: Features, Implementation, and Optimizations
Selected Java Interview Questions
Selected Java Interview Questions
Apr 13, 2020 · Backend Development

Differences Between synchronized and Lock in Java with Code Examples

This article explains Java's thread synchronization mechanisms by comparing synchronized blocks with the Lock interface, detailing thread basics, lifecycle methods, lock types, code demonstrations, fairness settings, and underlying JVM implementations, helping readers understand when and how to use each construct effectively.

LockReentrantLockconcurrency
0 likes · 17 min read
Differences Between synchronized and Lock in Java with Code Examples
Programmer DD
Programmer DD
Mar 22, 2020 · Fundamentals

Why Use Locks in Java? Understanding volatile, synchronized, and CAS

This article explains why Java uses locks to prevent dirty reads and data inconsistency, compares volatile and synchronized mechanisms, details monitor-based lock implementation, lock optimizations like biased and lightweight locks, introduces CAS and AbstractQueuedSynchronizer, and illustrates these concepts with code examples and diagrams.

AQSCASLocks
0 likes · 13 min read
Why Use Locks in Java? Understanding volatile, synchronized, and CAS
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Feb 17, 2020 · Backend Development

Understanding JVM-Level Locks in Java: synchronized, ReentrantLock, ReentrantReadWriteLock, and LongAdder

This article explains the evolution and implementation of Java's JVM‑level locks—including synchronized, ReentrantLock, ReentrantReadWriteLock, and LongAdder—detailing their lock‑upgrade process, internal object layout, AQS‑based algorithms, and how they improve concurrency and performance in multithreaded applications.

LocksReadWriteLockReentrantLock
0 likes · 24 min read
Understanding JVM-Level Locks in Java: synchronized, ReentrantLock, ReentrantReadWriteLock, and LongAdder
Java Interview Crash Guide
Java Interview Crash Guide
Feb 13, 2020 · Backend Development

Java Concurrency Locks Explained: From Synchronized to ReentrantReadWriteLock

This article provides a comprehensive overview of Java concurrency locks, covering classifications such as optimistic, pessimistic, fair, unfair, reentrant, exclusive/shared, spin, and segmented locks, as well as detailed explanations of synchronized, ReentrantLock, and ReadWriteLock usage with code examples.

LocksReadWriteLockReentrantLock
0 likes · 21 min read
Java Concurrency Locks Explained: From Synchronized to ReentrantReadWriteLock
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 24, 2019 · Backend Development

Understanding Java Thread Locks: synchronized, ReentrantLock, Semaphore, and AtomicInteger

This article explains why multithreading is needed, outlines the challenges of concurrent access, and provides a detailed overview of four Java thread lock mechanisms—synchronized, ReentrantLock, Semaphore, and AtomicInteger—along with their characteristics, usage patterns, and performance considerations.

AtomicIntegerSemaphoreThread Locks
0 likes · 9 min read
Understanding Java Thread Locks: synchronized, ReentrantLock, Semaphore, and AtomicInteger
Java Captain
Java Captain
Mar 14, 2019 · Backend Development

Why Combining synchronized with @Transactional Causes Thread‑Safety Issues in Spring and How to Resolve Them

The article explains why using the synchronized keyword together with Spring's @Transactional annotation can lead to lost updates when many threads increment a database field, analyzes the underlying transaction‑proxy interaction, and presents a refactored solution that moves the lock to a separate service to ensure correct results.

SpringTransactionconcurrency
0 likes · 7 min read
Why Combining synchronized with @Transactional Causes Thread‑Safety Issues in Spring and How to Resolve Them
Java Captain
Java Captain
Nov 3, 2018 · Fundamentals

Differences Between synchronized and Lock in Java and Their Usage

This article explains the fundamental differences between Java's synchronized keyword and the Lock interface, covering thread basics, lock types, a detailed comparison table, and practical code demos that illustrate how to acquire, try, and release locks in various scenarios.

Lockconcurrencyjava-lock
0 likes · 14 min read
Differences Between synchronized and Lock in Java and Their Usage
Java Captain
Java Captain
Sep 12, 2018 · Fundamentals

Understanding Processes, Threads, Multithreading, and Thread Safety in Java

This article explains the fundamentals of processes, threads, and multithreading in Java, illustrates common thread‑safety problems with example code, and demonstrates how to achieve safe concurrent execution using synchronized blocks and the Lock API, including tryLock with timeout.

LockThread Safetyjava
0 likes · 11 min read
Understanding Processes, Threads, Multithreading, and Thread Safety in Java
Programmer DD
Programmer DD
May 28, 2018 · Backend Development

Unveiling Java’s synchronized: How the JVM Implements and Optimizes Locks

This article explains the inner workings of Java's synchronized keyword, covering its implementation via monitorenter/monitorexit, the structure of object headers and monitors, and the series of lock optimizations introduced since JDK 1.6 such as spin locks, lock elimination, lock coarsening, lightweight, biased, and heavyweight locks.

javalockingsynchronized
0 likes · 17 min read
Unveiling Java’s synchronized: How the JVM Implements and Optimizes Locks
Qunar Tech Salon
Qunar Tech Salon
May 16, 2018 · Backend Development

Performance Analysis and Optimization of Synchronized Reflection Calls in a Java Backend Service

The article investigates a high‑traffic Java backend issue caused by synchronized reflection calls, analyzes thread‑blocking stack traces, demonstrates the problematic code, and presents a compile‑time PropertyDescriptor optimization that eliminates runtime locking, resulting in significant latency improvements and a deeper understanding of JVM lock mechanisms.

JVMconcurrencyperformance
0 likes · 14 min read
Performance Analysis and Optimization of Synchronized Reflection Calls in a Java Backend Service
Java Captain
Java Captain
May 8, 2018 · Fundamentals

Understanding Java Locks: volatile, synchronized, Monitor, CAS, and AQS

This article explains why locks are needed in Java, describes the fundamentals of volatile and synchronized, details monitor-based synchronization, explores lock optimizations such as biased and lightweight locks, and covers CAS and the AbstractQueuedSynchronizer framework for building concurrent structures.

AQSCASLocks
0 likes · 12 min read
Understanding Java Locks: volatile, synchronized, Monitor, CAS, and AQS
Qunar Tech Salon
Qunar Tech Salon
Dec 27, 2017 · Backend Development

Understanding the Implementation and Optimization of Java synchronized

This article explains how Java's synchronized keyword works internally, covering its implementation via monitorenter/monitorexit, the role of object headers and monitors, and the various lock optimizations introduced in JDK 1.6 such as spin locks, biased locks, lightweight locks, lock elimination, and lock coarsening.

concurrencyjavalocking
0 likes · 17 min read
Understanding the Implementation and Optimization of Java synchronized
Java Captain
Java Captain
Aug 22, 2017 · Fundamentals

Comparison of synchronized and Lock in Java: Limitations, Advantages, and Usage

This article explains the limitations of Java's synchronized keyword, introduces the Lock framework from java.util.concurrent.locks, compares their features, and demonstrates practical usage through multiple code examples covering ReentrantLock, tryLock, lockInterruptibly, ReadWriteLock, and fairness concepts.

Lockconcurrencymultithreading
0 likes · 25 min read
Comparison of synchronized and Lock in Java: Limitations, Advantages, and Usage
21CTO
21CTO
Mar 20, 2016 · Backend Development

Mastering Thread Safety in Java: When and How to Use synchronized

Thread safety issues arise when multiple threads access shared resources like variables, objects, or databases, potentially causing duplicate data or errors; this article explains when such problems occur and demonstrates how Java’s synchronized methods, synchronized blocks, and lock mechanisms can ensure safe, serialized access.

Thread Safetyjavamultithreading
0 likes · 12 min read
Mastering Thread Safety in Java: When and How to Use synchronized