BestHub
Sign in
Tagged articles
2072 articles
Page 21 of 21
Qunar Tech Salon
Qunar Tech Salon
Dec 19, 2016 · Backend Development

Asynchronous Refactoring of an HTTP Service Using a Graph‑Based Execution Engine

This article describes how a Java‑based HTTP service was transformed from a synchronous, thread‑blocking design to a fully asynchronous architecture by evaluating coroutine, Actor model, and Rx approaches, and ultimately implementing a Graph‑Based Execution Engine integrated with Servlet 3.0 and Spring MVC to improve stability, performance, and throughput.

AsynchronousServletconcurrency
0 likes · 12 min read
Asynchronous Refactoring of an HTTP Service Using a Graph‑Based Execution Engine
Architects Research Society
Architects Research Society
Nov 23, 2016 · Databases

ScyllaDB Architecture and Performance Optimizations: Design Insights

ScyllaDB, a Cassandra‑compatible NoSQL database, achieves over tenfold performance improvements through a thread‑per‑core design, asynchronous I/O, custom caching, self‑tuning schedulers, a user‑space TCP/IP stack, and LLVM‑JIT query execution, making it a compelling study for high‑performance database engineering.

Cache DesignDatabase PerformanceNoSQL
0 likes · 5 min read
ScyllaDB Architecture and Performance Optimizations: Design Insights
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Nov 16, 2016 · Operations

Calculate System Throughput: QPS, TPS, Concurrency & Response Time

This article explains key performance testing concepts such as system throughput, QPS/TPS, concurrency, response time, and their interrelationships, provides practical calculation examples, shows how daily PV relates to TPS for different platforms, and outlines essential metrics and formulas for evaluating software performance.

Performance TestingQPSResponse Time
0 likes · 11 min read
Calculate System Throughput: QPS, TPS, Concurrency & Response Time
dbaplus Community
dbaplus Community
Nov 10, 2016 · Backend Development

Why Distributed Systems Are Essential for Scaling Modern Web Services

The article explains why distributed systems are fundamental for handling massive web traffic, detailing concepts such as high throughput, concurrency, low latency, load balancing, layered architectures, concurrency models, caching, NoSQL storage, fault tolerance, scaling, deployment, and monitoring, while highlighting practical techniques and challenges.

Distributed SystemsNoSQLScalability
0 likes · 23 min read
Why Distributed Systems Are Essential for Scaling Modern Web Services
ITPUB
ITPUB
Oct 17, 2016 · Databases

Why Some MySQL Inserts Are Blocked: Decoding Next‑Key Lock Ranges

This article examines MySQL InnoDB's next‑key lock behavior by creating a test table, running concurrent transactions, and analyzing how the lock range is determined across primary and secondary index columns, revealing why certain insert statements are blocked while others succeed.

Gap LockInnoDBNext-key Lock
0 likes · 9 min read
Why Some MySQL Inserts Are Blocked: Decoding Next‑Key Lock Ranges
ITPUB
ITPUB
Oct 11, 2016 · Databases

How a Simple MySQL UPDATE Solved a Multi‑Threaded Counting Problem

A developer recounts how a seemingly trivial MySQL UPDATE statement—‘UPDATE table_name SET sum = sum + 5 WHERE id = 1’—proved thread‑safe for aggregating file counts across a multi‑threaded module, highlighting the importance of knowledge reserves and cautious evaluation before implementing complex synchronization solutions.

SQLconcurrencydatabase
0 likes · 5 min read
How a Simple MySQL UPDATE Solved a Multi‑Threaded Counting Problem
ITPUB
ITPUB
Sep 5, 2016 · Backend Development

Why a Barrier‑Based Config Swap Still Crashed: Uncovering a Shallow Copy Bug

A seemingly safe configuration swap using barriers caused a crash because a shallow copy duplicated resource pointers, leading to premature freeing of the active configuration; the article explains the bug, shows the faulty code, and presents a corrected approach.

BarrierC programmingResource Management
0 likes · 5 min read
Why a Barrier‑Based Config Swap Still Crashed: Uncovering a Shallow Copy Bug
ITPUB
ITPUB
Aug 31, 2016 · Databases

Lock‑Free Transactions and Cache Switching: MVCC Techniques for Key‑Value Stores

This article explains how traditional ACID transactions fall short for modern large‑scale systems and presents lock‑free transaction methods, atomic and partial cache‑switch techniques, and a PostgreSQL‑style MVCC model for key‑value databases, including practical rules and trade‑offs.

CacheKey-ValueMVCC
0 likes · 10 min read
Lock‑Free Transactions and Cache Switching: MVCC Techniques for Key‑Value Stores
WeChat Client Technology Team
WeChat Client Technology Team
Aug 15, 2016 · Databases

Boosting SQLite Performance on iOS: Threading, I/O, and Busy Retry Optimizations

This article explains how WeChat's iOS client tackled SQLite performance bottlenecks by introducing multi‑handle threading, enabling WAL mode, redesigning the Busy‑Retry mechanism, and applying I/O enhancements such as preserving WAL size and mmap usage, resulting in over 90% reduction in perceived lag.

Database OptimizationSQLiteconcurrency
0 likes · 14 min read
Boosting SQLite Performance on iOS: Threading, I/O, and Busy Retry Optimizations
Qunar Tech Salon
Qunar Tech Salon
Aug 3, 2016 · Backend Development

Optimizing Write‑Heavy High‑Concurrency Cache: Lock Granularity, Horizontal Sharding, and Lock‑Free Strategies

The article analyzes write‑mostly, read‑light cache scenarios such as driver location updates and counter increments, discusses lock bottlenecks, proposes horizontal sharding and per‑record locking, explores lock‑free approaches with data‑integrity signatures, and summarizes practical optimization techniques for high‑concurrency back‑end systems.

Cacheconcurrencylock optimization
0 likes · 8 min read
Optimizing Write‑Heavy High‑Concurrency Cache: Lock Granularity, Horizontal Sharding, and Lock‑Free Strategies
Architecture Digest
Architecture Digest
Jul 11, 2016 · Backend Development

Implementing a High‑Performance RPC Server with Netty in Java

This article explains the principles of RPC, evaluates performance‑critical factors such as I/O models and transport protocols, and provides a step‑by‑step guide to building a high‑throughput, Netty‑based RPC server in Java, including design, code structure, testing, and possible enhancements.

BackendJavaNetty
0 likes · 14 min read
Implementing a High‑Performance RPC Server with Netty in Java
Architect
Architect
Jun 14, 2016 · Backend Development

Custom Rejection Policies and Blocking Strategies for Java ThreadPoolExecutor

The article explains how to design a producer‑consumer model using Java's BlockingQueue, customize ThreadPoolExecutor's rejection policies—especially replacing the default AbortPolicy with a blocking strategy via a custom RejectedExecutionHandler—to safely handle full queues and improve concurrency control.

BlockingQueueJavaProducer Consumer
0 likes · 5 min read
Custom Rejection Policies and Blocking Strategies for Java ThreadPoolExecutor
Liulishuo Tech Team
Liulishuo Tech Team
Jun 3, 2016 · Backend Development

Understanding Ruby Multithreading and Multiprocessing

This article explains the differences between Ruby threads and processes, when to use each for performance gains, illustrates practical scenarios, and provides code examples for simple multithreading, multiprocessing, and using the Parallel gem.

GILParallelRuby
0 likes · 11 min read
Understanding Ruby Multithreading and Multiprocessing
dbaplus Community
dbaplus Community
May 31, 2016 · Backend Development

How High-Watermark Throttling Saves MySQL in Flash‑Sale Scenarios

The article explains MySQL high‑watermark throttling, a technique that limits concurrent updates on hot rows to protect database performance during extreme flash‑sale traffic, and demonstrates its effectiveness with real‑world Alibaba Cloud RDS metrics.

Alibaba Cloud RDSconcurrencyflash sale
0 likes · 5 min read
How High-Watermark Throttling Saves MySQL in Flash‑Sale Scenarios
Qunar Tech Salon
Qunar Tech Salon
May 9, 2016 · Backend Development

Comprehensive Overview of Java Locks: Fair, Unfair, Spin, Reentrant, Biased, Lightweight, Heavyweight, and More

This article provides a detailed explanation of various Java lock mechanisms—including fair and unfair locks, spin locks, lock elimination, lock coarsening, reentrant, class and object locks, biased, lightweight, heavyweight, pessimistic and optimistic locks—as well as practical code examples and a lock state table to help developers understand concurrency control in the JVM.

JVMJavaLocks
0 likes · 16 min read
Comprehensive Overview of Java Locks: Fair, Unfair, Spin, Reentrant, Biased, Lightweight, Heavyweight, and More
Qunar Tech Salon
Qunar Tech Salon
May 4, 2016 · Backend Development

Proactive Cache Refresh Strategies for Memcached to Prevent Cache Stampede

This article examines various techniques for proactively refreshing Memcached entries before they expire, including dual‑key schemes, timestamp‑based checks, and lock‑based updates, and presents a preferred Java implementation that minimizes cache‑stampede and reduces memory overhead.

Cache RefreshJavaMemcached
0 likes · 7 min read
Proactive Cache Refresh Strategies for Memcached to Prevent Cache Stampede
ITPUB
ITPUB
Apr 26, 2016 · Databases

Why Deleting a Single Row by Unique Index Can Still Cause MySQL Deadlocks

This article analyzes a puzzling MySQL deadlock scenario where concurrent DELETE statements on a uniquely indexed row lead to a deadlock, explaining the lock modes, InnoDB's deadlock‑prevention strategy, and the conditions that make such deadlocks possible.

InnoDBRepeatable ReadUnique Index
0 likes · 13 min read
Why Deleting a Single Row by Unique Index Can Still Cause MySQL Deadlocks
21CTO
21CTO
Apr 23, 2016 · Databases

Mastering Transaction Isolation Levels in MySQL: From Theory to Practice

This article explains the ACID fundamentals, common concurrency anomalies such as dirty, non‑repeatable and phantom reads, the four SQL‑standard isolation levels, how MySQL implements them, and step‑by‑step command‑line tests demonstrating their effects on real transactions.

ACIDconcurrencymysql
0 likes · 10 min read
Mastering Transaction Isolation Levels in MySQL: From Theory to Practice
ITPUB
ITPUB
Apr 6, 2016 · Fundamentals

Why Python Multithreading Struggles and When to Switch to Multiprocessing

This article explains the purpose of Python’s Global Interpreter Lock, how it limits multithreaded performance on multi‑core CPUs, distinguishes CPU‑bound versus I/O‑bound scenarios, and shows why multiprocessing is usually the preferred solution for parallel execution.

GILconcurrencymultiprocessing
0 likes · 6 min read
Why Python Multithreading Struggles and When to Switch to Multiprocessing
DevOps
DevOps
Apr 3, 2016 · Fundamentals

The Life of a Thread: A Narrative on Thread Pools, Locks, and Deadlocks

A metaphorical story follows a newly created thread as it learns about extracting request parameters, performing login, handling CPU scheduling, using caches, encountering deadlocks, and ultimately witnessing a system reboot, illustrating core concepts of multithreading, concurrency control, and thread‑pool lifecycle.

CPU schedulingLocksconcurrency
0 likes · 12 min read
The Life of a Thread: A Narrative on Thread Pools, Locks, and Deadlocks
High Availability Architecture
High Availability Architecture
Mar 30, 2016 · Backend Development

Lessons Learned from Building Teamwork Desk Services with Go

This article shares practical lessons and common pitfalls encountered while developing numerous Go‑based microservices for Teamwork Desk, covering topics such as framework choices, panic handling, request body reuse, SQL handling, pointer usage, naked returns, variable shadowing, concurrent map access, and vendoring best practices.

BackendError Handlingbest-practices
0 likes · 15 min read
Lessons Learned from Building Teamwork Desk Services with Go
21CTO
21CTO
Mar 23, 2016 · Backend Development

Mastering PHP Concurrency: From Fork Processes to Swoole’s Async IO

This article explains the evolution of concurrent I/O in PHP—from traditional multi‑process and multi‑thread blocking models, through the leader‑follower pattern and I/O multiplexing with epoll, to modern asynchronous programming using the Reactor model, coroutines, and the high‑performance Swoole extension.

Async IOReactorbackend-development
0 likes · 17 min read
Mastering PHP Concurrency: From Fork Processes to Swoole’s Async IO
ITPUB
ITPUB
Mar 21, 2016 · Backend Development

How to Build a Delayed Queue with Java and Redis for High‑Concurrency Scenarios

This article explores two practical approaches to implementing a delayed queue—using a sorted‑queue with JDK's DelayQueue logic and a Redis‑based solution with ordered sets and Spring Scheduled—to handle high‑throughput order processing while discussing their trade‑offs and implementation details.

JavaSchedulingconcurrency
0 likes · 5 min read
How to Build a Delayed Queue with Java and Redis for High‑Concurrency Scenarios
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
Mar 17, 2016 · Databases

Changes in InnoDB Auto‑Increment Locking Mechanism After MySQL 5.1.22 and Configuration Options

The article explains how InnoDB’s auto‑increment handling changed after MySQL 5.1.22—from using a table lock to a lightweight mutex for predictable‑row inserts—and details the three innodb_autoinc_lock_mode settings, their impact on concurrency and replication, and related pitfalls such as non‑sequential IDs.

InnoDBauto_incrementconcurrency
0 likes · 4 min read
Changes in InnoDB Auto‑Increment Locking Mechanism After MySQL 5.1.22 and Configuration Options
High Availability Architecture
High Availability Architecture
Mar 2, 2016 · Fundamentals

Understanding Concurrency: Threads, Goroutine, Actor Model, and Thread‑Pool Strategies

This article explores the fundamentals of concurrency versus parallelism, the challenges of writing correct concurrent programs, the evolution from OS threads to green threads, Goroutine scheduling, actor‑model concepts, and modern strategies such as thread pools, async callbacks, and Rust's ownership model.

GoroutineParallelismThreads
0 likes · 20 min read
Understanding Concurrency: Threads, Goroutine, Actor Model, and Thread‑Pool Strategies
Architecture Digest
Architecture Digest
Feb 26, 2016 · Backend Development

Comprehensive Guide to Java Concurrency: Concepts, Synchronization, Thread Pools, and the Java Memory Model

This article provides an extensive overview of Java concurrency, covering synchronous vs asynchronous calls, critical sections, blocking and non‑blocking behavior, deadlock, starvation, livelock, concurrency levels, the Java Memory Model, atomicity, visibility, ordering, thread lifecycle, synchronization mechanisms, thread pools, and related utilities.

JMMJavaSynchronization
0 likes · 39 min read
Comprehensive Guide to Java Concurrency: Concepts, Synchronization, Thread Pools, and the Java Memory Model
ITPUB
ITPUB
Feb 19, 2016 · Backend Development

Rethinking 12306 Ticketing: A Domain‑Driven Design Model for High‑Concurrency Reservations

This article analyzes the unique complexities of China's 12306 train ticketing system, proposes a domain‑driven aggregate model centered on train trips, explains seat‑allocation rules and overlapping interval handling, and outlines a CQRS and event‑sourcing architecture to achieve strong consistency and high concurrency.

CQRSDomain-Driven DesignEvent Sourcing
0 likes · 25 min read
Rethinking 12306 Ticketing: A Domain‑Driven Design Model for High‑Concurrency Reservations
Architect
Architect
Feb 6, 2016 · Databases

Introduction to InnoDB Transaction Lock System

This article provides a comprehensive overview of InnoDB's transaction lock mechanisms, covering row‑level lock types, table‑level locks, lock management procedures, deadlock detection, and practical examples, all based on MySQL 5.7.10.

Database InternalsInnoDBTransaction Locks
0 likes · 30 min read
Introduction to InnoDB Transaction Lock System
21CTO
21CTO
Jan 18, 2016 · Backend Development

Designing High‑Performance Read Services: Principles, Caching, and Concurrency

This article shares practical design principles for building scalable read services, covering stateless architecture, data closed‑loop processing, multi‑layer caching strategies, concurrency optimization, degradation switches, rate limiting, traffic switching, and other operational best practices.

Scalabilitybackend-developmentcaching
0 likes · 11 min read
Designing High‑Performance Read Services: Principles, Caching, and Concurrency
Architect
Architect
Dec 11, 2015 · Backend Development

Implementing Distributed Locks with Redis: The RedLock Algorithm

This article explains how to build reliable distributed locks using Redis, introduces the official RedLock algorithm, discusses safety properties, compares it with simple failover approaches, and provides implementation details, performance considerations, and lock‑extension techniques.

Redlockconcurrencydistributed-lock
0 likes · 16 min read
Implementing Distributed Locks with Redis: The RedLock Algorithm
Qunar Tech Salon
Qunar Tech Salon
Dec 11, 2015 · Backend Development

Performance Optimization Patterns for High‑Scale Backend Systems

This article presents a pattern‑based approach to performance optimization, describing common degradation anti‑patterns and corresponding optimization patterns—such as horizontal and vertical partitioning, runtime 3NF, data locality, and degradation—to help engineers improve response time, throughput, and availability in large‑scale backend services.

Scalabilityconcurrencyoptimization
0 likes · 43 min read
Performance Optimization Patterns for High‑Scale Backend Systems
ITPUB
ITPUB
Dec 4, 2015 · Backend Development

How to Measure and Optimize System Load Capacity for High‑Concurrency Backends

This guide explains key metrics, influencing factors, and practical tuning steps—including bandwidth, hardware, OS limits, TCP parameters, and server configurations—to assess and improve a backend system's maximum request handling capacity under high concurrency.

Linux TuningLoad TestingNginx
0 likes · 19 min read
How to Measure and Optimize System Load Capacity for High‑Concurrency Backends
ITPUB
ITPUB
Nov 16, 2015 · Databases

Mastering Flash‑Sale (秒杀) Logic: Using Unique Indexes and SQL for Concurrency Control

This guide explains two flash‑sale scenarios—single‑item seckill with a unique index and multi‑item seckill with quantity tracking—detailing table structures, SQL statements, concurrency handling, advantages, drawbacks, and an optimized version without locks, illustrated with step‑by‑step diagrams.

SQLUnique Indexconcurrency
0 likes · 5 min read
Mastering Flash‑Sale (秒杀) Logic: Using Unique Indexes and SQL for Concurrency Control
21CTO
21CTO
Nov 14, 2015 · Backend Development

How WeChat’s Red Packet System Handles Millions of Claims in Real Time

This article explains the backend architecture behind WeChat’s red‑packet feature, detailing how the system stores packet data, uses cache‑level atomic operations for grabbing, separates claim and settlement steps, and ensures high‑throughput, fault‑tolerant processing during peak usage.

BackendCacheDistributed Systems
0 likes · 6 min read
How WeChat’s Red Packet System Handles Millions of Claims in Real Time
21CTO
21CTO
Nov 8, 2015 · Backend Development

Designing a Scalable Short URL Service: Key Decisions and Best Practices

This article explores the essential design considerations for building a short URL service, covering data structures, encoding algorithms, key length choices, capacity planning, sharding strategies, concurrency handling, network architecture, security measures, and a real‑world example.

backend designconcurrencysharding
0 likes · 7 min read
Designing a Scalable Short URL Service: Key Decisions and Best Practices
21CTO
21CTO
Nov 5, 2015 · Backend Development

How CAS Prevents Data Inconsistency in High‑Concurrency Transactions

This article explains why concurrent read‑write operations on a shared balance can cause inconsistencies, illustrates the problem with a purchase‑balance example, and shows how a Compare‑And‑Set (CAS) update clause guarantees atomicity and preserves data integrity.

BackendCASConsistency
0 likes · 7 min read
How CAS Prevents Data Inconsistency in High‑Concurrency Transactions
21CTO
21CTO
Sep 26, 2015 · Backend Development

Architecting High‑Traffic Web 2.0 Sites: Solving Data, Concurrency & Storage

This article examines the key challenges of building large‑scale, high‑interaction web 2.0 platforms—including massive data processing, concurrency control, file storage, indexing, distributed architecture, AJAX usage, security, synchronization, clustering, and OpenAPI integration—offering practical considerations for robust backend design.

Data ManagementDistributed Systemsconcurrency
0 likes · 8 min read
Architecting High‑Traffic Web 2.0 Sites: Solving Data, Concurrency & Storage
21CTO
21CTO
Sep 19, 2015 · Backend Development

Can PHP + Swoole Compete with C++ for High‑Concurrency Servers?

The article examines why PHP’s lack of native multithreading isn’t a fatal flaw for high‑concurrency servers when paired with Swoole, compares process‑based and thread‑based models, debunks performance myths, and highlights the productivity benefits of using PHP over C++.

Backend DevelopmentPHPSwoole
0 likes · 5 min read
Can PHP + Swoole Compete with C++ for High‑Concurrency Servers?
21CTO
21CTO
Sep 8, 2015 · Backend Development

Can PHP + Swoole Rival C++ for High‑Concurrency Servers? Myths Explained

Although many claim PHP with Swoole is unsuitable for high‑concurrency servers compared to C++, this article explains how PHP’s process model, Swoole’s Table and Atomic features, and careful design can achieve comparable performance while offering faster development, and discusses the trade‑offs of multithreading versus multiprocessing.

Backend DevelopmentPHPSwoole
0 likes · 6 min read
Can PHP + Swoole Rival C++ for High‑Concurrency Servers? Myths Explained
Architect
Architect
Sep 2, 2015 · Backend Development

Backend Architecture Refactoring with Golang: Design, Data Flow, and Performance Optimizations

The article details a backend architecture overhaul using Golang to address search inefficiencies, slow response times, and low conversion rates by introducing asynchronous data filtering, fast in‑memory computation, and performance‑tuned serialization and garbage‑collection strategies.

Backend ArchitectureGolangPerformance Optimization
0 likes · 8 min read
Backend Architecture Refactoring with Golang: Design, Data Flow, and Performance Optimizations
MaGe Linux Operations
MaGe Linux Operations
Aug 31, 2015 · Fundamentals

Master Python Multiprocessing: Processes, Locks, Queues, and More

This article explains how to use Python's multiprocessing module to achieve true parallelism, covering Process creation, inter‑process synchronization primitives such as Lock, Semaphore, Event, communication tools like Queue and Pipe, and advanced patterns with Pool, all illustrated with runnable code examples.

LockPoolQueue
0 likes · 17 min read
Master Python Multiprocessing: Processes, Locks, Queues, and More
21CTO
21CTO
Aug 18, 2015 · Databases

Understanding PostgreSQL MVCC: How It Handles Concurrency

PostgreSQL uses Multi-Version Concurrency Control (MVCC) to ensure reads never block writes and vice versa, assigning transaction IDs to rows, managing visibility with xmin/xmax, supporting isolation levels, and requiring periodic VACUUM to clean dead rows and handle XID wraparound.

MVCCPostgreSQLVacuum
0 likes · 7 min read
Understanding PostgreSQL MVCC: How It Handles Concurrency
Qunar Tech Salon
Qunar Tech Salon
Jul 14, 2015 · Fundamentals

Understanding Java volatile: Principles, Usage, and Best Practices

This article explains the Java volatile keyword, covering its definition, lightweight nature compared to synchronized, visibility guarantees, usage conditions, and practical patterns such as state flags, safe publication, volatile beans, and low‑cost read‑write lock strategies, illustrated with code examples.

JavaMemory Modelconcurrency
0 likes · 9 min read
Understanding Java volatile: Principles, Usage, and Best Practices
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
Jun 28, 2015 · Backend Development

Optimizing Asynchronous Processing in Distributed Systems: Insights from Facebook and Alibaba

The article summarizes Zhao Haiping’s 2015 QCon talk on how asynchronous processing, profiling, and dependency‑tree scheduling can dramatically improve performance and scalability of distributed backend systems, drawing lessons from Facebook’s migration to async PHP and Alibaba’s ongoing optimization efforts.

AsyncBackend PerformanceDistributed Systems
0 likes · 12 min read
Optimizing Asynchronous Processing in Distributed Systems: Insights from Facebook and Alibaba
MaGe Linux Operations
MaGe Linux Operations
May 11, 2015 · Operations

Mastering System Throughput: Key Metrics, Formulas, and Performance Testing Basics

This article explains core performance testing concepts—including QPS, concurrency, response time, and throughput calculations—illustrates how to estimate system capacity, relate traffic metrics to daily PV, and outlines the perspectives of users, administrators, developers, and test engineers for evaluating software performance.

Performance TestingQPSResponse Time
0 likes · 12 min read
Mastering System Throughput: Key Metrics, Formulas, and Performance Testing Basics
Qunar Tech Salon
Qunar Tech Salon
Apr 21, 2015 · Backend Development

Understanding Netty Pitfalls: Autoread, isWritable, and Serialization

This article explains Netty's autoread switch, isWritable back‑pressure mechanism, and serialization strategies, showing how to control read/write rates, avoid thread‑pool overload, and reduce memory copies when handling TCP byte streams in high‑performance Java network applications.

Networkingbackpressureconcurrency
0 likes · 14 min read
Understanding Netty Pitfalls: Autoread, isWritable, and Serialization
Qunar Tech Salon
Qunar Tech Salon
Apr 5, 2015 · Backend Development

Implementing Java Event Notification with the Observer Pattern: Common Pitfalls and Thread‑Safe Solutions

This article explains how to build a Java event‑notification system using the observer pattern, highlights typical mistakes such as concurrent modification and deadlocks, and presents several thread‑safe implementations ranging from synchronized blocks to CopyOnWriteArraySet and atomic primitives.

Observer PatternSynchronizationconcurrency
0 likes · 10 min read
Implementing Java Event Notification with the Observer Pattern: Common Pitfalls and Thread‑Safe Solutions
MaGe Linux Operations
MaGe Linux Operations
Mar 5, 2015 · Operations

How to Calculate Concurrency (Vu) and TPS for Linux Systems

This article explains the definitions of concurrent users (Vu) and transactions per second (TPS), provides practical methods for estimating these metrics in new and existing systems, and outlines how to calculate resource usage such as connection counts, memory, and file descriptors.

OperationsTPSconcurrency
0 likes · 4 min read
How to Calculate Concurrency (Vu) and TPS for Linux Systems
Qunar Tech Salon
Qunar Tech Salon
Nov 28, 2014 · Backend Development

Guava Cache Guide: Building, Loading, Eviction, Refresh, and Advanced Features

This article explains how to create and configure Guava LoadingCache instances, covering builder options, CacheLoader implementation, explicit insertion, callable loading, size‑based, timed, and reference‑based eviction, removal listeners, refresh strategies, statistics, asMap view, and interruption handling, with complete Java code examples.

LoadingCacheconcurrencyperformance
0 likes · 15 min read
Guava Cache Guide: Building, Loading, Eviction, Refresh, and Advanced Features
Baidu Tech Salon
Baidu Tech Salon
May 5, 2014 · Fundamentals

10 Must‑Know Java 8 Features That Transform Your Code

Java 8 introduced a suite of powerful enhancements—from default methods and the new Process API to StampedLock, improved concurrency utilities, Optional, flexible annotations, numeric overflow checks, enhanced file traversal, stronger SecureRandom, and Date.toInstant—each offering developers modern, efficient ways to write cleaner, safer code.

APIsJavaconcurrency
0 likes · 8 min read
10 Must‑Know Java 8 Features That Transform Your Code
Baidu Tech Salon
Baidu Tech Salon
Apr 25, 2014 · Frontend Development

Optimizing File Upload Performance with HTML5: Comparison with Flash, Concurrency, Chunking, and Resumable Uploads

Using HTML5 instead of Flash, the article explains how to boost file‑upload speed by compressing or merging files before transfer, employing optimal concurrency levels, splitting files into chunks for fault‑tolerant, resumable and instant uploads, and choosing appropriate chunk sizes to balance overhead and performance.

HTML5Performance OptimizationWebUploader
0 likes · 18 min read
Optimizing File Upload Performance with HTML5: Comparison with Flash, Concurrency, Chunking, and Resumable Uploads