BestHub
Sign in
Tagged articles
58 articles
Page 1 of 1
James' Growth Diary
James' Growth Diary
Apr 25, 2026 · Artificial Intelligence

Deep Dive into LangGraph State Management: How Reducer, Annotation, and Channel Relate

LangGraph’s state management hinges on three core concepts—Channel as the storage unit, Annotation as the declarative API for Channels, and Reducer as the pure function that merges updates—understanding their interactions resolves common bugs, enables custom state schemas, and ensures correct concurrent node updates.

ChannelLangGraphReducer
0 likes · 14 min read
Deep Dive into LangGraph State Management: How Reducer, Annotation, and Channel Relate
DevOps Coach
DevOps Coach
Feb 25, 2026 · Backend Development

Why Your Go Function Returns While Goroutine Stays Alive—and How to Fix It

Even when a Go function returns cleanly, a spawned goroutine can remain blocked on an unbuffered channel after context cancellation, causing leaks that degrade performance under load; this article explains the hidden pitfall, demonstrates the faulty pattern, and provides robust fixes using buffered channels and context-aware goroutine design.

Channelcontextgoroutine-leak
0 likes · 8 min read
Why Your Go Function Returns While Goroutine Stays Alive—and How to Fix It
Code Wrench
Code Wrench
Oct 24, 2025 · Backend Development

Transforming a Simple Factorial into a Concurrent Go Engine

This article explores how a basic factorial calculation can be turned into a sophisticated concurrent system in Go, covering deadlock pitfalls, fan‑out/fan‑in pipelines, Redux‑style state management, and a controllable streaming factorial engine with pause and resume capabilities.

ChannelFan-outGo
0 likes · 9 min read
Transforming a Simple Factorial into a Concurrent Go Engine
21CTO
21CTO
Oct 13, 2025 · Backend Development

Speed Up Go Programs with Goroutines and Channels: From Seconds to Milliseconds

This article demonstrates how Go's goroutines and channels can transform a sequential task that takes seconds per operation into a highly concurrent solution that completes millions of operations in just a few seconds, complete with code examples and performance benchmarks.

ChannelGoGoroutine
0 likes · 5 min read
Speed Up Go Programs with Goroutines and Channels: From Seconds to Milliseconds
Code Wrench
Code Wrench
Sep 7, 2025 · Backend Development

Unlock Million-Scale Concurrency in Go: Goroutine, Channel & Real-World Patterns

Discover how Go transforms massive concurrency challenges into elegant communication using goroutines, channels, select, and the GMP scheduler, and learn practical patterns such as producer-consumer, pub/sub, worker pools, pipelines, and a prime sieve, complete with runnable code snippets and engineering tips for robust backend systems.

Backend DevelopmentChannelGo
0 likes · 12 min read
Unlock Million-Scale Concurrency in Go: Goroutine, Channel & Real-World Patterns
FunTester
FunTester
Jul 13, 2025 · Backend Development

Master Go Concurrency: Goroutines, Channels, and Real-World Examples

Learn how Go’s built‑in concurrency model using goroutines and channels can transform sequential code into responsive, high‑performance applications, with clear explanations of concurrency vs parallelism, practical code samples, synchronization techniques, and best practices for building scalable web servers.

ChannelGoroutineParallelism
0 likes · 10 min read
Master Go Concurrency: Goroutines, Channels, and Real-World Examples
AndroidPub
AndroidPub
Jul 8, 2025 · Mobile Development

When to Choose Kotlin Channel Over Flow? A Deep Dive with Code Samples

This article compares Kotlin Channel and Flow, explains their design differences, outlines when to prefer each tool, provides step‑by‑step usage instructions, showcases four channel types, presents real‑world Android examples, and covers advanced patterns and exception handling for robust coroutine communication.

AndroidChannelCoroutines
0 likes · 19 min read
When to Choose Kotlin Channel Over Flow? A Deep Dive with Code Samples
AndroidPub
AndroidPub
Jul 7, 2025 · Mobile Development

When to Use Kotlin Channel vs Flow: A Practical Guide

This article compares Kotlin Channel and Flow, explains their distinct characteristics, shows when to prefer each in Android coroutine programming, provides step‑by‑step usage, multiple channel implementations, real‑world examples, advanced fan‑in/fan‑out patterns, and robust exception handling.

AndroidChannelCoroutines
0 likes · 20 min read
When to Use Kotlin Channel vs Flow: A Practical Guide
php Courses
php Courses
Jun 3, 2025 · Backend Development

Understanding Go's Concurrency Model: Goroutine, Channel, Select, WaitGroup, and Context

This article explains Go's lightweight concurrency model, covering Goroutine creation, Channel communication, Select multiplexing, synchronization with WaitGroup and Context, common concurrency patterns such as worker pools and pub/sub, and provides best‑practice recommendations for building high‑performance concurrent programs.

ChannelGoGoroutine
0 likes · 7 min read
Understanding Go's Concurrency Model: Goroutine, Channel, Select, WaitGroup, and Context
FunTester
FunTester
Mar 29, 2025 · Backend Development

7 Common Go Concurrency Pitfalls and How to Avoid Them

This article examines frequent mistakes developers make when writing concurrent Go programs—such as misusing context, leaking goroutines, mishandling channels, and causing data races—and provides concrete code examples, impact analyses, and best‑practice recommendations to write safer, more efficient Go concurrency code.

ChannelGoGoroutine
0 likes · 9 min read
7 Common Go Concurrency Pitfalls and How to Avoid Them
FunTester
FunTester
Mar 26, 2025 · Backend Development

Common Go Concurrency Errors and Best Practices

This article examines frequent mistakes in Go's concurrent programming—such as confusing concurrency with parallelism, assuming concurrency always speeds up execution, misusing channels versus mutexes, overlooking workload types, and misunderstanding contexts—provides detailed explanations, potential impacts, and best‑practice solutions with improved code examples.

ChannelGoGoroutine
0 likes · 27 min read
Common Go Concurrency Errors and Best Practices
Ops Development & AI Practice
Ops Development & AI Practice
Mar 1, 2025 · Backend Development

Unlock Go’s Power: Master Goroutine Concurrency in Minutes

This article explains Go’s built‑in concurrency model, detailing what Goroutines are, their lightweight and user‑mode nature, advantages such as low resource consumption and fast scheduling, how to launch them with the `go` keyword, their M:N scheduler, interaction with channels, and important best‑practice considerations.

ChannelGoM:N scheduling
0 likes · 7 min read
Unlock Go’s Power: Master Goroutine Concurrency in Minutes
Raymond Ops
Raymond Ops
Jan 25, 2025 · Backend Development

Master Go Concurrency: Goroutines, Scheduler, and Synchronization Techniques

This article explains Go's concurrency model, detailing how goroutines are scheduled on logical processors, how to create and manage them, detect and resolve race conditions using atomic operations, mutexes, and channels, and demonstrates practical code examples for each concept.

BackendChannelatomic
0 likes · 19 min read
Master Go Concurrency: Goroutines, Scheduler, and Synchronization Techniques
Raymond Ops
Raymond Ops
Jan 4, 2025 · Backend Development

Why This Simple Go Program Deadlocks: The Hidden Goroutine Trap

The article explains why a seemingly straightforward Go program that creates an unbuffered channel, launches a goroutine to print a received value, and then sends a value deadlocks, analyzes the evaluation order of go statements, and shows how to fix the issue by moving the receive into a separate goroutine.

Channeldeadlock
0 likes · 7 min read
Why This Simple Go Program Deadlocks: The Hidden Goroutine Trap
BirdNest Tech Talk
BirdNest Tech Talk
Dec 16, 2024 · Backend Development

Five Ways to Build a Broadcast Notifier in Go

This article examines five Go implementations of a broadcast notifier—using sync.Cond, channels, context, sync.WaitGroup, and sync.RWMutex—detailing their code, execution flow, and trade‑offs so readers can understand how each primitive achieves notification broadcasting.

ChannelGobroadcast
0 likes · 9 min read
Five Ways to Build a Broadcast Notifier in Go
MaGe Linux Operations
MaGe Linux Operations
Sep 28, 2024 · Backend Development

Master Go Concurrency: Goroutines, Channels, Locks, Timers and Synchronization

This comprehensive guide explains the fundamentals of concurrent programming in Go, covering the differences between parallelism and concurrency, process and thread concepts, and detailed usage of goroutines, channels, select statements, timers, mutexes, read‑write locks, wait groups, once, sync.Map, and atomic operations with practical code examples and diagrams.

ChannelGoroutineParallelism
0 likes · 42 min read
Master Go Concurrency: Goroutines, Channels, Locks, Timers and Synchronization
Tencent Cloud Developer
Tencent Cloud Developer
Sep 10, 2024 · Fundamentals

Why Does This Go Code Block? Uncovering Channel and Select Pitfalls

This article analyzes a Go program that deadlocks due to misuse of unbuffered channels and select, explains the underlying behavior of channels, blocking conditions, and select semantics, and provides a simple fix by buffering the stop channel while also covering Go's CSP roots and best‑practice guidelines.

ChannelGoGoroutine
0 likes · 20 min read
Why Does This Go Code Block? Uncovering Channel and Select Pitfalls
Go Programming World
Go Programming World
Jun 4, 2024 · Backend Development

Understanding and Using Empty Structs (struct{}) in Go

This article explains the zero‑size nature of Go's empty struct, demonstrates how its memory address behaves, shows its impact on struct alignment, and presents multiple practical patterns such as set implementation, large arrays, signal channels, no‑op methods, interface stubs, and the noCopy identifier.

ChannelInterfaceMemory
0 likes · 17 min read
Understanding and Using Empty Structs (struct{}) in Go
MaGe Linux Operations
MaGe Linux Operations
Apr 20, 2024 · Backend Development

Mastering Go Concurrency: Goroutines, Scheduler, Race Detection & Channels

This article explains Go's concurrency model, detailing how goroutines are scheduled onto logical processors, how to create and run them, handle race conditions with atomic operations, mutexes, and the race detector, and share data safely using unbuffered and buffered channels with practical code examples.

ChannelGoGoroutine
0 likes · 19 min read
Mastering Go Concurrency: Goroutines, Scheduler, Race Detection & Channels
MaGe Linux Operations
MaGe Linux Operations
Apr 13, 2024 · Backend Development

Avoid Goroutine Leaks and Race Conditions in Go: Proven Patterns

This article explains how unbuffered channels can cause goroutine leaks, demonstrates common race pitfalls when sharing pointers across goroutines, and presents channel‑based designs that serialize access to shared state, ensuring safe and efficient concurrency in Go programs.

BackendChannelGoroutine
0 likes · 6 min read
Avoid Goroutine Leaks and Race Conditions in Go: Proven Patterns
MaGe Linux Operations
MaGe Linux Operations
Apr 1, 2024 · Backend Development

Why This Simple Go Channel Code Always Deadlocks and How to Fix It

The article explains why a minimal Go program that creates an unbuffered channel, launches a goroutine to print a received value, and then sends a value deadlocks, analyzes the evaluation order of the go statement, and shows how restructuring the code eliminates the deadlock.

ChannelGo languageGoroutine
0 likes · 7 min read
Why This Simple Go Channel Code Always Deadlocks and How to Fix It
FunTester
FunTester
Jul 28, 2023 · Fundamentals

Unveiling Go’s Channel: Deep Dive into Runtime, Memory Leaks, and Best Practices

This article explores Go's channel implementation—from its CSP‑inspired design and internal hchan structure to real‑world memory‑leak debugging, creation nuances, send/receive mechanics, and proper closing—providing developers with a comprehensive understanding of safe concurrent programming in Go.

ChannelGoGoroutine
0 likes · 31 min read
Unveiling Go’s Channel: Deep Dive into Runtime, Memory Leaks, and Best Practices
Tencent Cloud Developer
Tencent Cloud Developer
Nov 28, 2022 · Backend Development

Understanding Go Channels: Implementation, Usage, and Performance

The article explains Go’s channel implementation as a lock‑protected FIFO queue composed of a circular buffer, send and receive wait queues, detailing creation, send/receive mechanics, closing behavior, a real‑world memory‑leak example, and why this design offers safe, performant concurrency comparable to mutexes.

ChannelGoGoroutine
0 likes · 29 min read
Understanding Go Channels: Implementation, Usage, and Performance
MaGe Linux Operations
MaGe Linux Operations
Sep 16, 2022 · Backend Development

Mastering Goroutine Limits: How to Control Go Concurrency Efficiently

Learn how Go's lightweight goroutines work, why unlimited spawning can cause panics, and practical techniques—using sync.WaitGroup, buffered channels, and worker pools—to limit concurrent goroutine numbers safely and efficiently while preserving program correctness and performance.

ChannelGoroutineWorker Pool
0 likes · 4 min read
Mastering Goroutine Limits: How to Control Go Concurrency Efficiently
MaGe Linux Operations
MaGe Linux Operations
Apr 12, 2022 · Backend Development

Understanding Go’s CSP Model: Goroutine, Channel, Scheduler

This article explains Go’s concurrency fundamentals, distinguishing concurrency from parallelism, describing the CSP model built on goroutines and channels, and detailing the underlying M‑P‑G scheduler architecture—including thread models, runqueues, and load balancing—providing a comprehensive overview for developers.

CSPChannelGo
0 likes · 11 min read
Understanding Go’s CSP Model: Goroutine, Channel, Scheduler
Tencent Cloud Developer
Tencent Cloud Developer
Dec 20, 2021 · Backend Development

Go Concurrency Basics, Libraries, and Best Practices

The article explains Go’s scheduler (M, P, G), demonstrates goroutine, channel, and select usage, covers sync primitives, atomic ops, context cancellation, singleflight, common pitfalls, debugging tools, and a channel‑driven chatroom case study, offering best‑practice guidance for efficient concurrent programming.

ChannelGoSynchronization
0 likes · 21 min read
Go Concurrency Basics, Libraries, and Best Practices
ByteDance Dali Intelligent Technology Team
ByteDance Dali Intelligent Technology Team
Nov 19, 2021 · Mobile Development

Using Kotlin Flow and Channel to Solve Android Development Pain Points and Implement an MVI Architecture

This article demonstrates how Kotlin Flow and Channel can address common Android development challenges such as ViewModel‑View communication and event handling, compares alternatives like LiveData and RxJava, and presents a practical MVI architecture implementation with code examples.

AndroidChannelCoroutines
0 likes · 24 min read
Using Kotlin Flow and Channel to Solve Android Development Pain Points and Implement an MVI Architecture
New Oriental Technology
New Oriental Technology
Jul 5, 2021 · Backend Development

Introduction to Java NIO: Buffers, Channels, and Selectors

This article provides a comprehensive overview of Java NIO, explaining the differences between BIO and NIO, the concepts of synchronous/asynchronous and blocking/non‑blocking I/O, and detailing the usage and implementation of Buffers, Channels, and Selectors with code examples.

ChannelNon-blockingasynchronous-io
0 likes · 10 min read
Introduction to Java NIO: Buffers, Channels, and Selectors
Programmer DD
Programmer DD
Mar 15, 2021 · Fundamentals

Master Java NIO: From Basics to High‑Performance I/O with Real‑World Examples

This article provides a comprehensive guide to Java NIO, covering its core components—Channel, Buffer, and Selector—explaining the differences from traditional IO, demonstrating file, socket, and server implementations with detailed code samples, and illustrating advanced features such as memory‑mapped files, scatter/gather, and pipe communication.

ChannelFileChannelJava
0 likes · 31 min read
Master Java NIO: From Basics to High‑Performance I/O with Real‑World Examples
Code Ape Tech Column
Code Ape Tech Column
Mar 2, 2021 · Backend Development

A Quick Introduction to Java NIO with Practical Examples

This article explains Java NIO fundamentals—including Channels, Buffers, and Selectors—compares them with traditional IO, and provides multiple runnable code examples such as FileChannel, SocketChannel, Selector loops, memory‑mapped files, scatter/gather, transferTo/From, Pipe and DatagramChannel to illustrate non‑blocking and high‑performance I/O.

ChannelJavaNetworking
0 likes · 31 min read
A Quick Introduction to Java NIO with Practical Examples
Ctrip Technology
Ctrip Technology
Dec 3, 2020 · Mobile Development

Applying Kotlin Coroutines and Jetpack MVVM in Ctrip Flight App: Architecture, Implementation, and Production Challenges

This article explains how Ctrip's flight Android app refactored its home page using Kotlin coroutines, Jetpack AAC components, and MVVM architecture, detailing the technical and business background, code patterns, production issues, and lessons learned for large‑scale mobile development.

AndroidChannelCoroutines
0 likes · 20 min read
Applying Kotlin Coroutines and Jetpack MVVM in Ctrip Flight App: Architecture, Implementation, and Production Challenges
Programmer DD
Programmer DD
Nov 9, 2020 · Backend Development

How to Speed Up Java File Compression: From 30 Seconds to 1 Second with NIO

This article walks through a real‑world Java file‑compression task, shows why a naïve implementation takes 30 seconds for a 20 MB batch, and demonstrates five progressive optimizations—BufferedInputStream, NIO Channel, memory‑mapped files, Pipe, and code snippets—that cut the time down to about one second while explaining the underlying I/O mechanisms.

BufferedInputStreamChannelFile Compression
0 likes · 12 min read
How to Speed Up Java File Compression: From 30 Seconds to 1 Second with NIO
JavaEdge
JavaEdge
Nov 6, 2020 · Backend Development

Understanding Java NIO Channels: Read, Write, and Asynchronous I/O

Java NIO's Channel API offers bidirectional, asynchronous read/write operations using Buffers, with implementations such as FileChannel, DatagramChannel, SocketChannel, and ServerSocketChannel, and the article provides a practical FileChannel example illustrating buffer handling and the essential buf.flip() step.

AsynchronousChannelFileChannel
0 likes · 3 min read
Understanding Java NIO Channels: Read, Write, and Asynchronous I/O
Beike Product & Technology
Beike Product & Technology
Jul 16, 2020 · Fundamentals

In-depth Source Analysis of Go Channels (Go 1.14)

This article provides a comprehensive source‑level examination of Go's channel mechanism—including usage examples, the internal hchan data structure, creation, read/write operations, closing behavior, and common pitfalls—based on the Go 1.14 runtime implementation.

ChannelGoGoroutine
0 likes · 14 min read
In-depth Source Analysis of Go Channels (Go 1.14)
Ctrip Technology
Ctrip Technology
Jun 29, 2020 · Backend Development

Controlling Goroutine Concurrency in Go: Risks of Unbounded Goroutine Creation and Practical Limiting Techniques

The article explains why creating unlimited Goroutines in Go can exhaust system resources, demonstrates the problem with a sample program, and presents practical methods—including channel throttling, sync.WaitGroup, and third‑party Goroutine pools—to safely limit concurrency and improve performance.

ChannelGoGoroutine
0 likes · 10 min read
Controlling Goroutine Concurrency in Go: Risks of Unbounded Goroutine Creation and Practical Limiting Techniques
Laravel Tech Community
Laravel Tech Community
May 29, 2020 · Backend Development

Swoole Coroutine Channel: Overview, Methods, and Example Usage

This article introduces Swoole's Coroutine Channel for inter‑coroutine communication, explains its memory‑efficient implementation and key methods such as __construct, push, pop, stats, close, length, isEmpty, isFull, capacity and errCode, and provides a complete PHP example demonstrating producer‑consumer behavior.

AsyncChannelPHP
0 likes · 5 min read
Swoole Coroutine Channel: Overview, Methods, and Example Usage
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Jun 22, 2018 · Backend Development

Master Go Channels: From Basics to Advanced Patterns

This article explains Go's channel primitive in depth, covering its conceptual model, types, operations, internal queues, rule scenarios, practical code examples, and best‑practice tips for building clear and efficient concurrent programs.

ChannelGoGo Programming
0 likes · 12 min read
Master Go Channels: From Basics to Advanced Patterns
Java Captain
Java Captain
Mar 6, 2018 · Backend Development

Java NIO Basics: Channels, Buffers, and Selectors

This article introduces Java NIO fundamentals, explaining the key concepts of Channel, Buffer, and Selector, comparing them with traditional I/O streams, and providing code examples for file reading, writing with FileChannel, and illustrating how selectors enable single‑threaded multiplexed I/O handling.

BackendChannelI/O
0 likes · 8 min read
Java NIO Basics: Channels, Buffers, and Selectors
Programmer DD
Programmer DD
Jan 22, 2018 · Cloud Native

How Spring Cloud Stream Abstracts Messaging Middleware with Binders and Channels

This article explains how Spring Cloud Stream uses binders to isolate applications from messaging middleware, defines channels for input and output, demonstrates publish‑subscribe with RabbitMQ, shows how consumer groups prevent duplicate processing, and introduces message partitioning for ordered handling.

BinderChannelMessage Partitioning
0 likes · 11 min read
How Spring Cloud Stream Abstracts Messaging Middleware with Binders and Channels
Java Captain
Java Captain
Aug 22, 2017 · Backend Development

Understanding Java NIO: Channels, Buffers, Selectors and Example Code

This article explains Java NIO fundamentals—including synchronous vs asynchronous, blocking vs non‑blocking I/O—covers core components such as Channel, Buffer, and Selector, and provides complete example code for file operations and a single‑threaded server/client, comparing NIO with traditional I/O.

ChannelNon-blocking I/Obuffer
0 likes · 16 min read
Understanding Java NIO: Channels, Buffers, Selectors and Example Code
Architecture Digest
Architecture Digest
Dec 14, 2016 · Backend Development

Deep Dive into Netty: How a Server Starts and Binds a Port

This article explains the internal workflow of Netty when launching a server, covering why Netty is chosen over raw JDK NIO, the key components created during bootstrap, the step‑by‑step source‑code analysis of channel creation, initialization, registration, and the final bind operation that activates the server.

ChannelEventLoopJava NIO
0 likes · 18 min read
Deep Dive into Netty: How a Server Starts and Binds a Port