BestHub
Sign in
Tagged articles

thread

177 articles · Page 2 of 2
Top Architect
Top Architect
Aug 11, 2021 · Fundamentals

Why Thread.stop and Thread.suspend Are Deprecated and How to Gracefully Stop Threads in Java

This article explains why the Thread.stop and Thread.suspend methods were deprecated in modern Java, demonstrates the problems they cause with concrete code examples, and presents two safe alternatives—using a shared flag and the interrupt mechanism—to gracefully terminate threads without risking deadlocks or resource leaks.

DeprecatedStopSuspend
0 likes · 10 min read
Why Thread.stop and Thread.suspend Are Deprecated and How to Gracefully Stop Threads in Java
Selected Java Interview Questions
Selected Java Interview Questions
Aug 9, 2021 · Backend Development

Understanding Java Thread States and Their Transitions

This article explains Java thread states, their lifecycle transitions, and provides practical code examples demonstrating NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, and TERMINATED states, along with insights on synchronization, spurious wakeups, and best practices for using wait() within loops.

ThreadStatejavathread
0 likes · 14 min read
Understanding Java Thread States and Their Transitions
Architects' Tech Alliance
Architects' Tech Alliance
Jul 19, 2021 · Fundamentals

Understanding Processes and Threads: Definitions, Differences, Advantages, and Practical Usage

This article explains the fundamental concepts of processes and threads in operating systems, compares their characteristics, outlines their respective advantages and disadvantages, and provides practical guidelines for choosing between multi‑process and multi‑thread designs in real‑world applications.

concurrencyoperating-systemparallelism
0 likes · 20 min read
Understanding Processes and Threads: Definitions, Differences, Advantages, and Practical Usage
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 27, 2021 · Backend Development

Essential Java Concurrency Interview Topics – 12 Core Questions and Answers

This article presents twelve fundamental Java concurrency interview questions, covering thread creation methods, their pros and cons, thread states, lifecycle, start vs run, termination, thread safety, differences between threads and processes, communication, yield vs sleep, and provides concise answers to help candidates demonstrate solid multithreading knowledge.

backendconcurrencyjava
0 likes · 11 min read
Essential Java Concurrency Interview Topics – 12 Core Questions and Answers
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 25, 2021 · Backend Development

Three Ways to Create Threads in Java: Extending Thread, Implementing Runnable, and Using Callable

Through a whimsical first‑person narrative, the article explains three Java thread‑creation techniques—extending Thread, implementing Runnable (including anonymous and lambda forms), and using Callable with FutureTask—to illustrate their syntax, usage, and the ability to retrieve thread results.

Runnablebackend developmentcallable
0 likes · 7 min read
Three Ways to Create Threads in Java: Extending Thread, Implementing Runnable, and Using Callable
Top Architect
Top Architect
Mar 1, 2021 · Fundamentals

Understanding Processes, Threads, Concurrency, and Process Pools

This article explains the concepts of processes and threads, their differences, interaction methods, the three execution states of a task, synchronous and asynchronous communication, and the design and benefits of using a process pool to manage resources efficiently.

Process Pooloperating-systemprocess
0 likes · 10 min read
Understanding Processes, Threads, Concurrency, and Process Pools
Laravel Tech Community
Laravel Tech Community
Feb 27, 2021 · Fundamentals

Understanding Processes, Threads, Concurrency, and Process Pools

This article explains the concepts of processes and threads, their differences, interaction methods, the relationship between them, the three execution states of a task, the distinctions among parallel, concurrent, and serial execution, and the purpose and operation of process pools in operating systems.

Process Poolconcurrencyprocess
0 likes · 10 min read
Understanding Processes, Threads, Concurrency, and Process Pools
Liangxu Linux
Liangxu Linux
Dec 22, 2020 · Fundamentals

Mastering Processes and Threads: 19 Essential OS Concepts Explained

This comprehensive guide covers the fundamentals of processes and threads, their definitions, relationships, creation, lifecycle, scheduling strategies, context switching, inter‑process communication methods, and practical C/C++ examples, providing a deep dive into operating‑system concepts for developers and interview preparation.

C++IPCLinux
0 likes · 41 min read
Mastering Processes and Threads: 19 Essential OS Concepts Explained
Code Ape Tech Column
Code Ape Tech Column
Dec 17, 2020 · Backend Development

108 Essential Java Multithreading Interview Questions and Answers

This comprehensive guide compiles 108 common Java multithreading interview questions, covering the purpose of concurrency, thread creation methods, lifecycle nuances, synchronization utilities, memory visibility, thread safety levels, debugging techniques, executor frameworks, concurrent collections, atomic operations, lock implementations, and best‑practice recommendations.

ExecutorVolatileconcurrency
0 likes · 59 min read
108 Essential Java Multithreading Interview Questions and Answers
Qunar Tech Salon
Qunar Tech Salon
Nov 18, 2020 · Mobile Development

Understanding Android Looper, MessageQueue, and Native Message Handling

This article explains how Android drives applications through a message‑driven model by detailing the roles of Message, MessageQueue, Looper, Handler, and ThreadLocal, and walks through the native implementation of ActivityThread's main loop, including prepareMainLooper, MessageQueue initialization, epoll integration, and the polling mechanisms that power the message processing cycle.

AndroidLooperMessageQueue
0 likes · 17 min read
Understanding Android Looper, MessageQueue, and Native Message Handling
macrozheng
macrozheng
Oct 22, 2020 · Fundamentals

Can Threads Pause and Resume? A Tale of Coroutines Across Java and Go

A whimsical story depicts a GoLang envoy introducing the concept of coroutines to the proud Java empire, contrasting thread blocking, asynchronous callbacks, and cooperative scheduling, and explores how execution contexts can be saved, switched, and resumed without OS intervention.

coroutinegolangthread
0 likes · 8 min read
Can Threads Pause and Resume? A Tale of Coroutines Across Java and Go
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 14, 2020 · Fundamentals

Java Thread Lifecycle and Common Thread APIs

This article explains Java's thread lifecycle, detailing its six states—New, Runnable, Blocked, Waiting, Timed_waiting, and Terminated—and describes eleven commonly used thread APIs such as join(), wait(), notify(), yield(), sleep(), currentThread(), getName(), getId(), getPriority(), setPriority() and stop().

APIconcurrencyjava
0 likes · 9 min read
Java Thread Lifecycle and Common Thread APIs
Liangxu Linux
Liangxu Linux
Sep 3, 2020 · Fundamentals

Understanding Processes and Threads: A Factory Analogy for OS Fundamentals

This article explains core operating system concepts—CPU as a factory, the static nature of programs versus dynamic processes, how threads act as workers on production lines, and synchronization mechanisms like mutexes and semaphores, using clear analogies and diagrams.

concurrencyoperating-systemprocess
0 likes · 8 min read
Understanding Processes and Threads: A Factory Analogy for OS Fundamentals
Programmer DD
Programmer DD
Aug 25, 2020 · Fundamentals

What Does Java’s RUNNABLE State Really Mean? A Deep Dive into Thread States

This article explains the distinction between Java's RUNNABLE thread state and the operating‑system concepts of ready, running, and waiting, covering JVM‑level definitions, I/O blocking behavior, time‑slice scheduling, and includes concrete code examples to illustrate how blocked I/O still appears as RUNNABLE.

I/OJVMRunnable
0 likes · 12 min read
What Does Java’s RUNNABLE State Really Mean? A Deep Dive into Thread States
Liangxu Linux
Liangxu Linux
Aug 13, 2020 · Fundamentals

When to Use Processes, Threads, or Coroutines in Python? A Practical Guide

This article explains the operating‑system concepts of processes, threads, and coroutines, compares their performance with Python code examples, discusses the impact of the GIL and DMA, and provides clear guidelines for choosing the right concurrency model based on CPU‑bound, I/O‑bound, or mixed workloads.

concurrencycoroutineperformance
0 likes · 18 min read
When to Use Processes, Threads, or Coroutines in Python? A Practical Guide
dbaplus Community
dbaplus Community
Jul 29, 2020 · Operations

Why CPU Idle ≠ Exhausted: Uncovering IO Bottlenecks in Java Services

A real‑world incident showed that a 0% CPU idle rate can mask severe disk IO wait, leading to thread exhaustion in a SpringBoot order service, and the article explains how IO, DMA, Java thread states, and various Linux network IO models interact while offering practical mitigation tactics.

CPUIOLinux
0 likes · 14 min read
Why CPU Idle ≠ Exhausted: Uncovering IO Bottlenecks in Java Services
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Jul 24, 2020 · Mobile Development

Understanding Android Java Exception Capture and Handling Mechanism

Android captures uncaught Java exceptions using Thread.UncaughtExceptionHandler, first logging details with a system LoggingHandler then terminating the app via KillApplicationHandler, converting the Throwable into an ApplicationErrorReport sent to ActivityManagerService and stored in /data/system/dropbox, while developers can view the same FATAL EXCEPTION stack trace in logcat to diagnose and fix the root cause.

AndroidCrash analysisException Handling
0 likes · 10 min read
Understanding Android Java Exception Capture and Handling Mechanism
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 24, 2020 · Fundamentals

Understanding Java's AbstractQueuedSynchronizer (AQS): Concepts, Internal Implementation, and Resource Acquisition/Release

This article explains the core concepts of Java's AbstractQueuedSynchronizer (AQS), its internal FIFO double‑linked list structure, key code snippets, how threads acquire and release resources in exclusive and shared modes, and provides practical insights for mastering Java concurrency.

AQSAbstractQueuedSynchronizerLock
0 likes · 12 min read
Understanding Java's AbstractQueuedSynchronizer (AQS): Concepts, Internal Implementation, and Resource Acquisition/Release
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 6, 2020 · Backend Development

Analyzing JDK 1.8 FutureTask Source Code

This article provides a detailed analysis of JDK 1.8’s FutureTask implementation, explaining its purpose, usage examples, internal structure, state transitions, key methods such as run, get, cancel, and the concurrency mechanisms like volatile fields, CAS operations, and thread‑waiting queues.

FutureFutureTaskJDK
0 likes · 32 min read
Analyzing JDK 1.8 FutureTask Source Code
Selected Java Interview Questions
Selected Java Interview Questions
Jul 5, 2020 · Fundamentals

Java Concurrency Interview Questions and Answers: Wait/Notify, Locks, Volatile, AQS, Thread Pools, and More

This article provides a comprehensive overview of Java concurrency concepts for interview preparation, covering wait/notify mechanisms, atomicity, visibility, ordering, synchronized implementation, volatile semantics, Java Memory Model, AQS, lock characteristics, ReentrantLock, ReadWriteLock, thread pool configurations, and producer‑consumer patterns with code examples.

Locksconcurrencyjava
0 likes · 24 min read
Java Concurrency Interview Questions and Answers: Wait/Notify, Locks, Volatile, AQS, Thread Pools, and More
FunTester
FunTester
Jun 28, 2020 · Fundamentals

Mastering Java Thread Lifecycle: From NEW to TERMINATED Explained

This article provides a comprehensive guide to Java's thread lifecycle, detailing each of the six thread states, their meanings, how they are triggered, and practical code examples that demonstrate state transitions and logging output.

Lifecycleconcurrencyjava
0 likes · 10 min read
Mastering Java Thread Lifecycle: From NEW to TERMINATED Explained
Selected Java Interview Questions
Selected Java Interview Questions
Jun 25, 2020 · Fundamentals

Java Multithreading and Concurrency Basics: Threads, Synchronization, Thread Pools, and Common Pitfalls

This article introduces the fundamentals of Java multithreading and concurrency, covering the differences between processes and threads, the relationship between Thread and Runnable, start vs run, thread creation methods, handling return values, thread states, sleep vs wait, notify vs notifyAll, yield, interrupt, and the use of thread pools with executors.

ThreadPoolcallableconcurrency
0 likes · 21 min read
Java Multithreading and Concurrency Basics: Threads, Synchronization, Thread Pools, and Common Pitfalls
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
Architect's Tech Stack
Architect's Tech Stack
Jun 5, 2020 · Fundamentals

Introduction to Java Lambda Expressions and Common Usage Examples

This article introduces Java Lambda expressions, explains the functional interface requirements, demonstrates basic and simplified syntax, and provides numerous practical examples such as method references, constructor references, thread creation, collection iteration, element removal, sorting, and closure behavior.

CollectionsFunctionalInterfaceLambda
0 likes · 13 min read
Introduction to Java Lambda Expressions and Common Usage Examples
Selected Java Interview Questions
Selected Java Interview Questions
May 3, 2020 · Backend Development

Three Ways to Create Threads in Java: Extending Thread, Implementing Runnable, and Using Callable/Future

This article explains the three primary techniques for creating threads in Java—subclassing Thread, implementing the Runnable interface, and using Callable with Future—provides complete code examples for each method, and compares their advantages and disadvantages for practical multithreading development.

FutureRunnablecallable
0 likes · 8 min read
Three Ways to Create Threads in Java: Extending Thread, Implementing Runnable, and Using Callable/Future
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 29, 2020 · Fundamentals

Mastering Java Thread Lifecycle: States, Transitions, and Debugging Tips

This article explains Java thread lifecycle, compares OS generic thread states with Java’s six states, shows how to query thread state via getState(), and introduces debugging tools like jstack and Arthas, helping developers master state transitions and write robust concurrent code.

ArthasDebuggingLifecycle
0 likes · 12 min read
Mastering Java Thread Lifecycle: States, Transitions, and Debugging Tips
Programmer DD
Programmer DD
Feb 21, 2020 · Backend Development

Mastering Thread Termination in Java: Safe Practices and Common Pitfalls

This article explains how to properly stop a Java thread, compares deprecated Thread.stop() with interruption techniques, demonstrates checking a thread's interrupted state, shows how to use exceptions and return statements for graceful termination, and warns about the dangers of forceful stops and lock release.

ExceptionStopconcurrency
0 likes · 12 min read
Mastering Thread Termination in Java: Safe Practices and Common Pitfalls
vivo Internet Technology
vivo Internet Technology
Jan 8, 2020 · Fundamentals

Understanding Kotlin Coroutines, Go Coroutines, and JVM Threading

The article demonstrates that Kotlin coroutines on the JVM are merely a convenient API layered on traditional Java threads rather than true lightweight coroutines, contrasting them with Go’s M:N goroutine scheduling, and discusses experimental Kotlin‑Native and OpenJDK Loom projects that aim to provide genuine coroutine support.

CoroutinesGoJVM
0 likes · 20 min read
Understanding Kotlin Coroutines, Go Coroutines, and JVM Threading
政采云技术
政采云技术
Dec 29, 2019 · Backend Development

Unveiling Node.js: How Processes, Threads, and Clusters Really Work

This article explains Node.js's internal concurrency model, covering the distinction between processes and threads, debunking the single‑thread myth, and detailing how the event loop, child processes, cluster mode, and worker_threads enable high‑performance, multi‑core execution.

ClusterNode.jschild_process
0 likes · 17 min read
Unveiling Node.js: How Processes, Threads, and Clusters Really Work
Big Data Technology & Architecture
Big Data Technology & Architecture
Dec 26, 2019 · Fundamentals

Java Thread Interview Questions and Answers with Code Examples

This article provides a comprehensive guide to common Java multithreading interview questions, covering thread ordering with join, lock vs synchronized, read‑write locks, wait vs sleep, blocking queues, producer‑consumer patterns, deadlock detection, thread dumps, thread states, and immutable objects, all illustrated with runnable code samples.

DeadlockLockblockingqueue
0 likes · 33 min read
Java Thread Interview Questions and Answers with Code Examples
Selected Java Interview Questions
Selected Java Interview Questions
Dec 16, 2019 · Backend Development

How to Properly Stop a Java Thread: Methods, Examples, and Pitfalls

This article explains the various ways to terminate a running Java thread—including using exit flags, the deprecated stop() method, interrupt(), and exception handling—illustrates each approach with code samples, compares Thread.interrupted() and isInterrupted(), and discusses the dangers of forceful termination and lock release.

Stopconcurrencyinterrupt
0 likes · 12 min read
How to Properly Stop a Java Thread: Methods, Examples, and Pitfalls
Java Captain
Java Captain
Nov 22, 2019 · Fundamentals

A Fruit Store Analogy for Understanding Java Concurrency

The article uses a vivid fruit‑store story to illustrate core Java concurrency concepts such as threads, lock objects, critical sections, thread states, synchronization queues, wait/notify mechanisms, and volatile variables, helping readers grasp multithreading fundamentals through relatable scenarios.

Lockjavamultithreading
0 likes · 17 min read
A Fruit Store Analogy for Understanding Java Concurrency
Python Crawling & Data Mining
Python Crawling & Data Mining
Oct 21, 2019 · Fundamentals

Master Python Multiprocessing: From Fork to Process Pools

This article explains the concepts of processes and threads in Python, compares multi‑process, multi‑thread, and combined approaches, shows how to use fork, the multiprocessing module, process pools, subprocesses, and inter‑process communication with queues, and provides complete code examples with results.

IPCPythonconcurrency
0 likes · 15 min read
Master Python Multiprocessing: From Fork to Process Pools
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 13, 2019 · Fundamentals

Three Ways to Create Threads in Java: Extending Thread, Implementing Runnable, and Implementing Callable

This article explains three Java thread‑creation techniques—extending the Thread class, implementing the Runnable interface, and implementing the Callable interface—provides complete code examples for each, compares their advantages and disadvantages, and recommends the best practice for concurrent programming.

Runnablecallableconcurrency
0 likes · 6 min read
Three Ways to Create Threads in Java: Extending Thread, Implementing Runnable, and Implementing Callable
Java Captain
Java Captain
Sep 14, 2019 · Fundamentals

Understanding the RUNNABLE Thread State in Java

This article explains the Java RUNNABLE thread state, how it differs from traditional OS ready/running states, its relationship with time‑slicing, blocking I/O, and why the JVM reports many blocked operations as RUNNABLE, illustrated with code examples and diagrams.

JVMRunnablejava
0 likes · 12 min read
Understanding the RUNNABLE Thread State in Java
FunTester
FunTester
Aug 10, 2019 · Mobile Development

How to Capture and Gracefully Stop Android Logcat in UiAutomator

This guide explains how to use Java's Runtime API within a UiAutomator test to start, filter, and safely terminate an adb logcat process, including a complete Logcat thread implementation and tips for preventing oversized log files.

AndroidMobile TestingUIAutomator
0 likes · 8 min read
How to Capture and Gracefully Stop Android Logcat in UiAutomator
Java Captain
Java Captain
Sep 14, 2018 · Fundamentals

Java Thread States: Overview of the Six Lifecycle States

This article explains Java's six thread states—NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, and TERMINATED—detailing their meanings, transitions, related waiting and synchronization queues, and comparing key thread-control methods such as sleep, yield, join, wait, and notify.

javamultithreadingthread
0 likes · 9 min read
Java Thread States: Overview of the Six Lifecycle States
21CTO
21CTO
Aug 27, 2018 · Frontend Development

Mastering Browser Architecture: From Multi‑Process to JS Event Loop

This comprehensive guide walks experienced front‑end developers through the browser's multi‑process model, internal threading, rendering pipeline, JavaScript single‑threaded execution, event loop mechanics, Web Workers, and performance‑related concepts like macrotasks, microtasks, and hardware‑accelerated compositing.

BrowserFrontendJavaScript
0 likes · 35 min read
Mastering Browser Architecture: From Multi‑Process to JS Event Loop
MaGe Linux Operations
MaGe Linux Operations
Jul 3, 2018 · Fundamentals

Why Zombie Processes Occur in Linux and How Multithreading Works

This article explains Linux process fundamentals—including creation, the PCB, scheduling, and the emergence of zombie processes—details their causes and removal methods, and then compares processes with threads, covering multithreading implementation, issues, classifications, priorities, and synchronization techniques.

LinuxOS fundamentalsmultithreading
0 likes · 13 min read
Why Zombie Processes Occur in Linux and How Multithreading Works
Efficient Ops
Efficient Ops
Jun 18, 2018 · Fundamentals

Why Do Zombie Processes Appear in Linux and How to Prevent Them?

This article explains Linux process fundamentals, scheduling, the creation of zombie processes, their causes, and practical methods to avoid them, while also comparing processes and threads and discussing multithreading concepts and synchronization techniques.

LinuxSchedulingprocess
0 likes · 14 min read
Why Do Zombie Processes Appear in Linux and How to Prevent Them?
Programmer DD
Programmer DD
Jun 16, 2018 · Fundamentals

How Java AQS Uses CLH Queues and LockSupport to Manage Thread Blocking

This article explains the internal mechanisms of Java's AbstractQueuedSynchronizer, detailing how the CLH synchronization queue, the shouldParkAfterFailedAcquire method, and the LockSupport utility work together to decide when a thread should spin, block, or be unblocked, with full code examples and step‑by‑step analysis.

AQSCLHQueueLockSupport
0 likes · 8 min read
How Java AQS Uses CLH Queues and LockSupport to Manage Thread Blocking
Java Architect Essentials
Java Architect Essentials
Mar 19, 2018 · Backend Development

40 Common Java Multithreading Interview Questions and Answers

This article compiles and answers 40 frequently asked Java multithreading interview questions, covering thread purpose, creation methods, key APIs, synchronization mechanisms, thread safety levels, performance considerations, and practical debugging techniques for developers seeking a solid understanding of concurrent programming.

InterviewThreadPoolconcurrency
0 likes · 29 min read
40 Common Java Multithreading Interview Questions and Answers
Java Captain
Java Captain
Feb 5, 2018 · Fundamentals

Java Multithreading Basics: History, Thread States, Creation Methods, Synchronization, and Control

This article provides a comprehensive introduction to Java multithreading, covering its historical background, thread lifecycle states, two ways to create threads, code examples for shared and non‑shared data, synchronization with the synchronized keyword, thread control methods such as interrupt, sleep, suspend, yield, priority settings, and daemon threads, concluding with key takeaways.

daemoninterruptjava
0 likes · 18 min read
Java Multithreading Basics: History, Thread States, Creation Methods, Synchronization, and Control
Java Captain
Java Captain
Feb 1, 2018 · Fundamentals

Common Java Multithreading and Concurrency Interview Questions and Answers

This article compiles essential Java multithreading and concurrency interview questions, covering thread basics, lifecycle, synchronization, thread pools, executors, atomic classes, deadlocks, and related concepts, providing concise explanations and code examples for interview preparation.

InterviewThreadPooljava
0 likes · 20 min read
Common Java Multithreading and Concurrency Interview Questions and Answers
21CTO
21CTO
Nov 17, 2017 · Fundamentals

Master Java Concurrency: Threads, Thread Pools, and Synchronization

This article provides a comprehensive overview of Java concurrency, covering thread creation methods, thread pools, thread models, the Future and Fork/Join frameworks, volatile and CAS mechanisms, AQS, synchronized locks, and various concurrent queue implementations, with practical code examples and references for deeper study.

ThreadPoolconcurrencyjava
0 likes · 38 min read
Master Java Concurrency: Threads, Thread Pools, and Synchronization
Architecture Digest
Architecture Digest
Nov 17, 2017 · Backend Development

A Comprehensive Overview of Java Concurrency Programming

This article provides a high‑level summary of Java concurrency, covering thread creation methods, thread models, thread pools, Future and CompletableFuture, the Fork/Join framework, volatile, CAS, AQS, synchronized locks, and concurrent queue implementations, with code examples and reference links for deeper study.

AQSCASFuture
0 likes · 39 min read
A Comprehensive Overview of Java Concurrency Programming
Java Captain
Java Captain
Nov 3, 2017 · Fundamentals

Comprehensive Guide to Java Multithreading and Concurrency Utilities

This article provides an in‑depth overview of Java multithreading, covering thread creation, lifecycle methods, synchronization mechanisms, volatile semantics, thread‑local storage, high‑level concurrency utilities such as ReentrantLock, CountDownLatch, CyclicBarrier, Semaphore, Executors, Callable/Future, and atomic classes, with practical code examples and usage tips.

Lockexecutorservicethread
0 likes · 26 min read
Comprehensive Guide to Java Multithreading and Concurrency Utilities
21CTO
21CTO
Oct 24, 2017 · Backend Development

Mastering Java Concurrency: Key Concepts, Thread Lifecycle, and JMM Explained

This article explains essential Java concurrency concepts—including synchronous vs. asynchronous execution, concurrency vs. parallelism, critical sections, blocking and non‑blocking operations—covers thread states, creation methods, priorities, common thread APIs, and the Java Memory Model’s guarantees on atomicity, visibility, and ordering.

concurrencyjavajmm
0 likes · 22 min read
Mastering Java Concurrency: Key Concepts, Thread Lifecycle, and JMM Explained
Qunar Tech Salon
Qunar Tech Salon
Apr 12, 2016 · Fundamentals

40 Common Java Multithreading Interview Questions and Answers

This article presents a comprehensive collection of 40 Java multithreading interview questions, covering the purpose of multithreading, thread creation methods, differences between start() and run(), Runnable vs Callable, synchronization utilities, memory model, locks, thread pools, and best practices for concurrent programming.

ThreadPooljava-memory-modelthread
0 likes · 29 min read
40 Common Java Multithreading Interview Questions and Answers
21CTO
21CTO
Aug 11, 2015 · Backend Development

Top 50 Java Multithreading Interview Questions Every Developer Should Know

This article compiles 50 of the most frequently asked Java multithreading and concurrency interview questions, covering core concepts, thread creation, synchronization mechanisms, memory model, common pitfalls, and best practices, providing concise explanations to help both novice and experienced developers prepare effectively.

Interviewjava-memory-modelthread
0 likes · 34 min read
Top 50 Java Multithreading Interview Questions Every Developer Should Know