Skip to content
Tagged articles

visibility

21 articles · Page 1 of 1
samdeepthink
samdeepthink
Sep 21, 2026 · Fundamentals

Java final Visibility: JMM Freeze, This Escape, and Lock-Free Guarantees

This article explains how Java's final keyword ensures cross-thread visibility of final fields through the JMM's freeze action at constructor end, provided the this reference does not escape during construction, demonstrating with a code example that shows a race condition when this escapes and the correct behavior when final fields are properly frozen.

ConcurrencyJMMJava
0 likes · 7 min read
Java final Visibility: JMM Freeze, This Escape, and Lock-Free Guarantees
Dabaoshi
Dabaoshi
Aug 13, 2026 · Fundamentals

Why Concurrency Is Hard: The Surprising Result of Two Threads Incrementing an int

The article explains why Java concurrency is difficult by showing that two threads each incrementing an int ten thousand times may not produce twenty thousand, then explores the motivations for multithreading, the differences between concurrency and parallelism, and the three core challenges of visibility, atomicity, and ordering.

ConcurrencyJavaMultithreading
0 likes · 23 min read
Why Concurrency Is Hard: The Surprising Result of Two Threads Incrementing an int
Cilantro Loves Linux
Cilantro Loves Linux
Nov 30, 2025 · R&D Management

Why Technical Skills Alone Won't Promote You: 4 Career Levers for IT Engineers

This article reveals four counterintuitive career strategies for IT engineers to break out of the 'code tool' trap: specialize deeply instead of chasing full-stack breadth, make technical value visible to decision-makers, learn from senior leaders rather than competing with peers, and continuously evolve skills to match business stages.

IT careercareer growthcontinuous learning
0 likes · 13 min read
Why Technical Skills Alone Won't Promote You: 4 Career Levers for IT Engineers
Java Tech Enthusiast
Java Tech Enthusiast
Aug 28, 2025 · Operations

How to Make Your Ops Work Visible and Worth Paying For

This article explains why operations teams must showcase their work to clients, offering practical ways to turn routine reports and meetings into compelling evidence of value, so that stability is recognized as a result of visible effort rather than taken for granted.

IT managementOperationscommunication
0 likes · 6 min read
How to Make Your Ops Work Visible and Worth Paying For
DevOps Coach
DevOps Coach
Aug 27, 2025 · Operations

How Sharing Small Wins Made My DevOps Career Visible

The author reflects on possessing solid DevOps skills yet remaining unnoticed, discovers that visibility—not just technical ability—is key, and shares practical steps like posting experiences, using GitHub as a portfolio, and embracing authentic personal branding to advance a DevOps career.

DevOpspersonal brandingvisibility
0 likes · 6 min read
How Sharing Small Wins Made My DevOps Career Visible
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.

CASConcurrent ProgrammingHappens-Before
0 likes · 25 min read
Java Memory Model and Concurrent Programming: Visibility, Ordering, and Atomicity
Sohu Tech Products
Sohu Tech Products
Dec 8, 2021 · Mobile Development

Understanding UIKIT_EXTERN and Macro Usage in iOS Development

This article explains the purpose, syntax, and underlying principles of UIKIT_EXTERN and related macros such as extern, static, and const in iOS, demonstrates how __attribute__ and visibility modifiers affect symbol linkage, and outlines practical scenarios and extensions for safer, more efficient code across dynamic libraries.

MacrosUIKIT_EXTERNconst
0 likes · 11 min read
Understanding UIKIT_EXTERN and Macro Usage in iOS Development
Wukong Talks Architecture
Wukong Talks Architecture
Oct 20, 2021 · Fundamentals

Understanding Java volatile: Usage, Memory Model, Visibility, Atomicity, and Instruction Reordering

This article provides a comprehensive guide to Java's volatile keyword, covering its pronunciation, purpose, three core properties, interaction with the Java Memory Model, visibility and atomicity examples, instruction reordering, memory barriers, and practical usage such as double‑checked locking and when to prefer volatile over heavier synchronization mechanisms.

Javaatomicityinstruction reordering
0 likes · 18 min read
Understanding Java volatile: Usage, Memory Model, Visibility, Atomicity, and Instruction Reordering
Architect
Architect
Aug 8, 2020 · Fundamentals

Understanding Java Memory Model, Volatile, Atomicity, Visibility, and Ordering

This article explains the Java memory model, how variables are stored in main and working memory, and why concurrency issues like dirty reads, non‑atomic operations, and instruction reordering occur, while detailing the roles of volatile, synchronized, locks, and atomic classes in ensuring visibility, ordering, and atomicity.

ConcurrencyJavaatomicity
0 likes · 21 min read
Understanding Java Memory Model, Volatile, Atomicity, Visibility, and Ordering
Xiaokun's Architecture Exploration Notes
Xiaokun's Architecture Exploration Notes
Jan 23, 2020 · Fundamentals

Understanding the Java Memory Model: Data Sharing, Race Conditions, and Visibility Solutions

This article explains the Java Memory Model, covering how it validates reads, the distinction between shared and exclusive memory areas, data‑race scenarios with example code, visibility challenges, and the JMM‑based solutions such as volatile, synchronized, and memory barriers to prevent harmful reordering.

Data RaceJavaReordering
0 likes · 8 min read
Understanding the Java Memory Model: Data Sharing, Race Conditions, and Visibility Solutions
Java Captain
Java Captain
Feb 27, 2019 · Fundamentals

Understanding Java volatile: Memory Visibility, Ordering, and Interview Insights

This article explains the Java volatile keyword, covering its memory‑visibility and ordering guarantees, how it interacts with the Java Memory Model, why it does not ensure atomicity, and demonstrates typical interview‑style examples and code snippets such as flag signaling and double‑checked locking.

ConcurrencyJavaatomicity
0 likes · 16 min read
Understanding Java volatile: Memory Visibility, Ordering, and Interview Insights
Programmer DD
Programmer DD
Jun 9, 2018 · Fundamentals

Unlocking Java’s Memory Model: Core Concepts and the Happens‑Before Rule

This concise summary explains the Java Memory Model’s definition of thread‑memory interaction, covering atomicity, visibility, ordering, the happens‑before principle, compiler/processor reordering constraints, and sequential consistency, while also listing key reference articles and further reading.

ConcurrencyHappens-BeforeJava
0 likes · 7 min read
Unlocking Java’s Memory Model: Core Concepts and the Happens‑Before Rule
ZhiKe AI
ZhiKe AI
Feb 23, 2017 · Fundamentals

Why volatile Is Not Thread‑Safe: A Java Increment Test

The article presents a Java program where 100 threads each increment a volatile int 1,000 times, showing that the final value may be less than the expected 100,000, and explains that volatile only guarantees visibility, not atomicity, making it unsuitable for concurrent modifications.

ConcurrencyJavaatomicity
0 likes · 2 min read
Why volatile Is Not Thread‑Safe: A Java Increment Test