BestHub
Sign in
Tagged articles

channel

72 articles · Page 1 of 1
Golang Shines
Golang Shines
Aug 10, 2026 · Backend Development

Understanding Go Goroutine and Channel: Usage, Pitfalls, and Deadlock Diagnosis

The article explains Go's native concurrency with lightweight goroutines and channel communication, outlines common deadlock errors, details unbuffered and buffered channel behavior, proper close rules, select usage, and presents graceful shutdown techniques using channels, context, and sync.WaitGroup, plus practical code examples.

DeadlockGochannel
0 likes · 20 min read
Understanding Go Goroutine and Channel: Usage, Pitfalls, and Deadlock Diagnosis
AndroidPub
AndroidPub
Jul 23, 2026 · Mobile Development

Mastering Kotlin Asynchronous Streams: The Core of Android Reactive Programming

This article demystifies Kotlin's Flow, StateFlow, SharedFlow, and Channel by explaining their emission, storage, and loss mechanisms, illustrating common pitfalls with concrete code examples, and providing practical guidelines for choosing the right asynchronous data container in Android apps.

AndroidCoroutinesFlow
0 likes · 27 min read
Mastering Kotlin Asynchronous Streams: The Core of Android Reactive Programming
Tinker Programmer
Tinker Programmer
Jul 12, 2026 · Backend Development

Go Concurrency Interview: 5 Fatal Close Pitfalls That Crash Programs

The article dissects five common ways misusing the close operation on Go channels can cause runtime panics, explains the underlying reasons, demonstrates correct patterns such as the single‑sender rule and for‑range consumption, and provides interview‑ready takeaways.

GoInterviewchannel
0 likes · 10 min read
Go Concurrency Interview: 5 Fatal Close Pitfalls That Crash Programs
Tinker Programmer
Tinker Programmer
Jul 11, 2026 · Backend Development

Why Does Your Go Worker Pool Leak Goroutines? Common Pitfalls and Fixes

This article dissects the frequent bugs that cause Go worker‑pool implementations to panic, deadlock, or leak goroutines, explains the four core principles for correct channel and WaitGroup usage, showcases five typical error patterns with concrete code, and provides a complete, production‑ready solution.

GoWorker Poolchannel
0 likes · 14 min read
Why Does Your Go Worker Pool Leak Goroutines? Common Pitfalls and Fixes
Tinker Programmer
Tinker Programmer
Jul 9, 2026 · Backend Development

What Does This Go Channel Code Actually Print? A Step‑by‑Step Interview Guide

The article explains how to reliably predict the output of Go channel interview questions by drawing execution timelines, distinguishing synchronization points from print order, handling buffered vs unbuffered channels, and spotting deadlocks, providing four concrete heuristics backed by code examples and runtime observations.

DeadlockGoInterview
0 likes · 12 min read
What Does This Go Channel Code Actually Print? A Step‑by‑Step Interview Guide
Golang Shines
Golang Shines
Jul 6, 2026 · Backend Development

Why a Simple for‑range Over a Go Channel Can Leak Goroutines

The article explains how using a for‑range loop to read from an unclosed Go channel can cause a goroutine to block forever, demonstrates the issue with a minimal example, compares explicit receives with for‑range, and shows that closing the channel is the only reliable fix, even for buffered channels.

Gochannelclose
0 likes · 7 min read
Why a Simple for‑range Over a Go Channel Can Leak Goroutines
Golang Shines
Golang Shines
Jul 3, 2026 · Backend Development

Top Go Interview Questions: defer, GMP Scheduler, Slice Internals, Channels, and Context

This article presents a curated collection of 30 essential Go interview questions covering language characteristics, object‑orientation, inheritance, polymorphism, goroutine basics, channel usage, defer execution order, memory allocation, slice vs array, map safety, error handling, context, Go modules, the GMP scheduler, and practical code examples for testing and middleware.

GoInterview Questionschannel
0 likes · 11 min read
Top Go Interview Questions: defer, GMP Scheduler, Slice Internals, Channels, and Context
Golang Shines
Golang Shines
May 1, 2026 · Backend Development

Mastering Go Concurrency: From Basics to Advanced Patterns

The article walks readers through Go's concurrency model, explaining lightweight goroutines and channel communication, demonstrates common patterns such as worker pools and fan‑in/fan‑out with concrete code, highlights typical pitfalls like race conditions, deadlocks and memory leaks, and offers practical best‑practice recommendations for safe concurrent programming.

GoWorker Poolchannel
0 likes · 10 min read
Mastering Go Concurrency: From Basics to Advanced Patterns
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.

AnnotationLangGraphReducer
0 likes · 14 min read
Deep Dive into LangGraph State Management: How Reducer, Annotation, and Channel Relate
Golang Shines
Golang Shines
Mar 12, 2026 · Fundamentals

Why Go Requires Both new and make for Memory Allocation

Go provides two distinct constructors—new, a generic memory allocator returning a zero‑initialized pointer, and make, a specialized initializer that allocates and prepares slices, maps, and channels—explaining why both exist, how they differ, common pitfalls, and the language’s design philosophy of explicit, ready‑to‑use values.

GoReference Typeschannel
0 likes · 8 min read
Why Go Requires Both new and make for Memory Allocation
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.

Fan-outGoState Management
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.

Gochannelgoroutine
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.

GoParallel Programmingbackend development
0 likes · 12 min read
Unlock Million-Scale Concurrency in Go: Goroutine, Channel & Real-World Patterns
Go Development Architecture Practice
Go Development Architecture Practice
Jul 23, 2025 · Backend Development

Scaling Go Backend: From Simple Goroutine to Job/Worker Pools

This article walks through three Go server‑side scaling techniques—starting a goroutine per request, using a buffered channel queue, and implementing a full job/worker pool with separate task and worker channels—complete with code examples and practical considerations for high‑traffic applications.

Worker Poolbackendchannel
0 likes · 9 min read
Scaling Go Backend: From Simple Goroutine to Job/Worker Pools
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.

Web Serverchannelconcurrency
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.

AndroidAsynchronous ProgrammingCoroutines
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.

AndroidCoroutinesFlow
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.

GoSELECTchannel
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.

Gobest practiceschannel
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.

Gochannelcontext
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.

GoM:N schedulingbest practices
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.

atomicbackendchannel
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.

Deadlockchannel
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.

BroadcastGochannel
0 likes · 9 min read
Five Ways to Build a Broadcast Notifier in Go
Subtle Storm
Subtle Storm
Nov 27, 2024 · Fundamentals

Understanding Go’s new vs. make: When and Why to Use Each

This article explains the shared behavior of Go's new and make functions, highlights their key differences—including supported types, return values, and initialization details—and provides concrete code examples to show how each should be used in practice.

Gochannelmake
0 likes · 7 min read
Understanding Go’s new vs. make: When and Why to Use Each
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.

atomicchannelconcurrency
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.

DeadlockGoSELECT
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.

MemorySetchannel
0 likes · 17 min read
Understanding and Using Empty Structs (struct{}) in Go
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 4, 2024 · Backend Development

Mastering Go Concurrency: Goroutines, Scheduler, and Safe Data Sharing

This article explains Go's concurrency model, detailing how goroutines are scheduled onto logical processors, how to create and run them, detect and resolve race conditions with atomic operations, mutexes, and channels, and demonstrates buffered versus unbuffered channel communication.

GoRace Detectionatomic
0 likes · 18 min read
Mastering Go Concurrency: Goroutines, Scheduler, and Safe Data Sharing
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.

DeadlockGo languagechannel
0 likes · 7 min read
Why This Simple Go Channel Code Always Deadlocks and How to Fix It
Nullbody Notes
Nullbody Notes
Feb 29, 2024 · Backend Development

Implementing Parallel Computation in Go with a Custom MapReduce Framework

The article explains why parallel RPC calls are needed for assembling complex objects, introduces a Go‑based MapReduce framework, walks through concrete code examples for product detail retrieval and UID cleaning, and details the internal architecture—including generate, mapper, reducer, and cancellation mechanisms—while providing full source snippets and execution flow.

GoMapReducechannel
0 likes · 10 min read
Implementing Parallel Computation in Go with a Custom MapReduce Framework
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.

GoRuntimechannel
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.

GoRuntimechannel
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.

Worker Poolchannelconcurrency
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.

CSPGochannel
0 likes · 11 min read
Understanding Go’s CSP Model: Goroutine, Channel, Scheduler
Shepherd Advanced Notes
Shepherd Advanced Notes
Mar 21, 2022 · Backend Development

Deep Dive into Java NIO for High‑Concurrency Network Applications

This article explains Java NIO’s non‑blocking I/O model, compares it with traditional BIO, details zero‑copy techniques, and walks through core components such as Channel, Buffer, and Selector with concrete code examples and diagrams, then shows how Redis leverages I/O multiplexing for high performance.

BufferJava NIORedis
0 likes · 20 min read
Deep Dive into Java NIO for High‑Concurrency Network Applications
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.

Gochannelperformance
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.

AndroidCoroutinesFlow
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.

BufferNIOSelector
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.

BufferFileChannelNIO
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.

BufferIONIO
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.

AndroidCoroutinesJetpack
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.

BufferedInputStreamMemoryMappedFileNIO
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.

AsynchronousFileChannelNIO
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.

BufferGoRuntime
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.

Gochannelconcurrency
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.

PHPSwooleasync
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.

GoGo Programmingchannel
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.

BufferI/ONIO
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.

Message PartitioningSpring Cloud Streambinder
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.

BufferNIOSelector
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.

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