BestHub
Sign in
Tagged articles
400 articles
Page 2 of 4
Java High-Performance Architecture
Java High-Performance Architecture
Aug 28, 2024 · Databases

NewSQL vs Sharding: Which Database Architecture Truly Wins?

This article objectively compares NewSQL distributed databases with traditional middleware‑based sharding solutions, examining their architectural differences, transaction support, scalability, HA, storage engines, and ecosystem maturity, to help readers decide which approach best fits their performance, consistency, and operational needs.

HANewSQLScalability
0 likes · 18 min read
NewSQL vs Sharding: Which Database Architecture Truly Wins?
Top Architect
Top Architect
Aug 8, 2024 · Backend Development

Design and Implementation of Payment Business Architecture

This article outlines the business background, detailed payment workflow, associated product and coupon management, and practical implementation tips for designing a robust payment system, covering process decomposition, sequence diagrams, data structures, transaction handling, and key technical considerations such as transaction management, locking, and settlement accuracy.

architecturebackendbusiness process
0 likes · 12 min read
Design and Implementation of Payment Business Architecture
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 1, 2024 · Backend Development

Backend API Design Best Practices

This article outlines comprehensive backend API design guidelines, covering parameter validation, extensibility, idempotency, logging, thread‑pool isolation, third‑party error handling, asynchronous processing, parallel queries, rate limiting, security, lock granularity, and strategies to avoid long‑running transactions.

AsynchronousIdempotencyRate Limiting
0 likes · 11 min read
Backend API Design Best Practices
Top Architect
Top Architect
Jul 30, 2024 · Backend Development

Payment System Architecture: Business Background, Process Decomposition, Sequence Design, and Structural Design

This article analyzes the complexities of payment system design, covering business background, modular process breakdown, sequence diagrams for pre‑payment, payment integration, post‑payment stages, and detailed structural design, while also highlighting related business components and practical implementation tips.

System Designarchitecturebackend
0 likes · 12 min read
Payment System Architecture: Business Background, Process Decomposition, Sequence Design, and Structural Design
Architect
Architect
Jul 29, 2024 · Databases

NewSQL vs Middleware Sharding: Which Architecture Truly Wins?

This article objectively compares NewSQL distributed databases with traditional middleware‑based sharding solutions, examining their architectures, transaction models, scalability, high‑availability mechanisms, storage engines, maturity, and offering a decision framework to help engineers choose the most suitable approach for their workloads.

CAP theoremDatabase ArchitectureNewSQL
0 likes · 20 min read
NewSQL vs Middleware Sharding: Which Architecture Truly Wins?
Top Architect
Top Architect
Jul 14, 2024 · Backend Development

Designing Complex Payment Systems: Architecture, Process Decomposition, and Best Practices

The article outlines the challenges of payment systems, detailing business background, process decomposition, flow sequencing, structural design, related product and coupon management, and summarizes key technical considerations such as transaction management, locking, retry mechanisms, and fund settlement for robust backend development.

architecturebackendpayment
0 likes · 12 min read
Designing Complex Payment Systems: Architecture, Process Decomposition, and Best Practices
Architect's Guide
Architect's Guide
Jul 11, 2024 · Backend Development

Using Spring Transaction Hooks to Send Kafka Messages After Commit

This article demonstrates how to leverage Spring's TransactionSynchronizationManager to detect active transactions and register synchronization callbacks that asynchronously push payment‑ledger messages to Kafka only after the transaction successfully commits, ensuring data consistency and minimal impact on the main business flow.

JavaKafkaTransactionSynchronizationManager
0 likes · 9 min read
Using Spring Transaction Hooks to Send Kafka Messages After Commit
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 2, 2024 · Backend Development

When Should You Send Messages in a Transaction? Real‑World Order Processing Insights

This article examines the trade‑offs of sending messages before, during, or after database persistence in order‑creation workflows, explores transaction‑message patterns, half‑message checks, and message‑table strategies, and offers practical guidance for building reliable backend messaging systems.

Message QueueMessagingReliability
0 likes · 10 min read
When Should You Send Messages in a Transaction? Real‑World Order Processing Insights
Architect
Architect
Jun 25, 2024 · Backend Development

Mastering Spring Transaction Hooks: Send Kafka Messages Only After Commit

This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions and register callbacks that asynchronously send Kafka messages after a transaction successfully commits, ensuring data consistency in payment‑system archiving scenarios.

JavaKafkaSpringBoot
0 likes · 10 min read
Mastering Spring Transaction Hooks: Send Kafka Messages Only After Commit
Top Architect
Top Architect
Jun 12, 2024 · Backend Development

Payment Business Architecture: Process Decomposition, Sequence Design, and Structural Design

The article explains how to analyze, decompose, and design a complex payment workflow by breaking it into modules, defining pre‑payment, payment‑gateway, and post‑payment sequences, and outlining the essential data structures such as account management, transaction records, and order handling, while also highlighting practical implementation considerations.

Process Designarchitecturebackend
0 likes · 10 min read
Payment Business Architecture: Process Decomposition, Sequence Design, and Structural Design
Java High-Performance Architecture
Java High-Performance Architecture
May 12, 2024 · Databases

NewSQL vs Sharding: Which Database Architecture Truly Wins?

This article objectively compares NewSQL databases with middleware‑based sharding solutions, examining their architectural differences, transaction handling, scalability, high‑availability mechanisms, storage engines, and maturity to help readers decide which approach best fits their specific workload and business requirements.

CAP theoremNewSQLScalability
0 likes · 18 min read
NewSQL vs Sharding: Which Database Architecture Truly Wins?
macrozheng
macrozheng
May 11, 2024 · Backend Development

When Does @Transactional Commit? Before or After Unlock?

This article explains the timing of Spring's @Transactional commit relative to lock release, analyzes why committing after unlock can cause overselling, shows how to trace the transaction lifecycle in the source code, and offers practical solutions to ensure atomicity in high‑concurrency scenarios.

DatabaseJavaLock
0 likes · 19 min read
When Does @Transactional Commit? Before or After Unlock?
Java Tech Enthusiast
Java Tech Enthusiast
May 3, 2024 · Databases

MySQL Data Recovery: Strategies for Handling Accidental Deletion

The article explains how to respond to accidental MySQL data deletion by analyzing loss causes, choosing recovery methods such as mysqldump backups, binary‑log point‑in‑time restores, or Percona’s InnoDB tool, provides step‑by‑step commands, and recommends preventive practices like regular backups, transactions, and strict permissions.

Data RecoveryDatabase Backupbinlog
0 likes · 3 min read
MySQL Data Recovery: Strategies for Handling Accidental Deletion
Architecture Digest
Architecture Digest
Apr 19, 2024 · Databases

Comparing NewSQL Distributed Databases with Middleware‑Based Sharding: Advantages, Trade‑offs, and Use Cases

The article objectively compares NewSQL distributed databases with traditional middleware‑based sharding solutions, examining their architectural differences, distributed transaction support, performance, scalability, high‑availability mechanisms, storage engines, and practical suitability for various application scenarios.

CAP theoremNewSQLScalability
0 likes · 18 min read
Comparing NewSQL Distributed Databases with Middleware‑Based Sharding: Advantages, Trade‑offs, and Use Cases
Code Ape Tech Column
Code Ape Tech Column
Apr 18, 2024 · Backend Development

Applying Spring Transaction Hooks for Asynchronous Kafka Message Publishing

This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions and register synchronization callbacks so that Kafka messages are sent asynchronously after transaction commit, illustrated with a payment‑system logging scenario and complete Java code examples.

AsynchronousJavaKafka
0 likes · 10 min read
Applying Spring Transaction Hooks for Asynchronous Kafka Message Publishing
MaGe Linux Operations
MaGe Linux Operations
Apr 9, 2024 · Databases

How to Simulate and Prevent SQL Server Deadlocks: A Step-by-Step Guide

This article explains what SQL Server deadlocks are, why they occur, demonstrates a reproducible deadlock scenario with T‑SQL code, and provides practical strategies such as proper schema design, indexing, query optimization, shorter transactions, appropriate isolation levels, and monitoring to minimize deadlock occurrences.

PerformanceSQL Serverdatabase locking
0 likes · 9 min read
How to Simulate and Prevent SQL Server Deadlocks: A Step-by-Step Guide
Selected Java Interview Questions
Selected Java Interview Questions
Mar 29, 2024 · Backend Development

Dynamic Multi-DataSource Management and Transaction Handling in Spring

This article explains how to dynamically manage multiple data sources and ensure transaction consistency across a master and several application databases in Spring by extending AbstractRoutingDataSource, using configuration‑file and database‑table solutions, and implementing a custom multi‑database transaction manager.

DataSourceDynamicRoutingJava
0 likes · 15 min read
Dynamic Multi-DataSource Management and Transaction Handling in Spring
Chen Tian Universe
Chen Tian Universe
Mar 26, 2024 · Fundamentals

What’s the Core Architecture Behind Modern Payment Systems?

This article breaks down the essential "kernels" of payment, transaction, settlement, accounting, and related financial processes, illustrating each layer with diagrams and explanations that reveal how businesses, platforms, and institutions collaborate to move money securely and efficiently.

Core ConceptsFinancearchitecture
0 likes · 15 min read
What’s the Core Architecture Behind Modern Payment Systems?
Selected Java Interview Questions
Selected Java Interview Questions
Mar 11, 2024 · Databases

Key MySQL Interview Questions and Answers: Joins, Indexes, Transactions, and Optimization

This article provides a comprehensive overview of essential MySQL interview topics, covering join types, differences among DROP, DELETE, TRUNCATE, UNION vs UNION ALL, CHAR vs VARCHAR, transaction properties and isolation levels, database normalization, index types and usage, query execution flow, storage engine differences, and practical SQL optimization techniques.

OptimizationSQLindex
0 likes · 20 min read
Key MySQL Interview Questions and Answers: Joins, Indexes, Transactions, and Optimization
Architect's Guide
Architect's Guide
Mar 1, 2024 · Backend Development

Ensuring Transaction Consistency in Multi‑threaded Spring Applications Using Programmatic Transactions

The article explains how to execute parallel tasks with CompletableFuture, why @Async cannot guarantee transactional integrity in a multi‑threaded Spring environment, and presents a programmatic transaction approach—including copying transaction resources between threads—to achieve consistent commit or rollback across concurrent operations.

CompletableFutureJavaProgrammaticTransaction
0 likes · 19 min read
Ensuring Transaction Consistency in Multi‑threaded Spring Applications Using Programmatic Transactions
Architect
Architect
Feb 23, 2024 · Backend Development

Mastering Spring Transaction Propagation: When and How Transactions Merge, Suspend, or Nest

This article explains the seven Spring transaction propagation levels, shows how nested @Transactional methods interact under each level, and provides concrete code‑level examples that illustrate when transactions are merged, suspended, started anew, or rolled back, helping developers choose the right strategy for reliable enterprise applications.

JavaSpring Frameworkpropagation
0 likes · 14 min read
Mastering Spring Transaction Propagation: When and How Transactions Merge, Suspend, or Nest
High Availability Architecture
High Availability Architecture
Feb 19, 2024 · Backend Development

Understanding Spring Transaction Propagation Mechanisms

This article explains Spring's seven transaction propagation behaviors—REQUIRED, SUPPORTS, MANDATORY, REQUIRES_NEW, NOT_SUPPORTED, NEVER, and NESTED—detailing how nested transactional methods interact, when new transactions are created or suspended, and how exceptions influence commit and rollback across different propagation settings.

Javapropagationspring
0 likes · 10 min read
Understanding Spring Transaction Propagation Mechanisms
Su San Talks Tech
Su San Talks Tech
Feb 15, 2024 · Backend Development

How to Ensure Transaction Rollback in Spring Multithreaded Operations

This article explains why the @Transactional annotation fails in Spring when using multithreading, demonstrates a failing example, and provides a solution using manual SqlSession management to guarantee that all database changes are rolled back if any thread encounters an exception.

JavaMyBatismultithreading
0 likes · 10 min read
How to Ensure Transaction Rollback in Spring Multithreaded Operations
Su San Talks Tech
Su San Talks Tech
Feb 13, 2024 · Backend Development

How to Ensure Transaction Consistency When Async Threads Fail in Spring

This article explains how to guarantee transactional integrity when importing a 100,000‑row Excel file with asynchronous threads in Spring, covering double‑async optimization, Future and CompletableFuture handling, @Transactional pitfalls, manual transaction control, and a complete solution for cross‑thread transaction management.

AsyncCompletableFutureExcel Import
0 likes · 18 min read
How to Ensure Transaction Consistency When Async Threads Fail in Spring
php Courses
php Courses
Jan 9, 2024 · Databases

Efficiently Inserting 10 Million Records into MySQL with PHP

This tutorial explains how to use PHP and PDO to quickly insert ten million rows into a remote MySQL database by preparing the connection, employing batch inserts, managing transactions, tuning MySQL settings, and optionally using the LOAD DATA statement for optimal performance.

Bulk InsertPDOPHP
0 likes · 6 min read
Efficiently Inserting 10 Million Records into MySQL with PHP
vivo Internet Technology
vivo Internet Technology
Jan 3, 2024 · Backend Development

Understanding Spring Transaction Propagation Mechanisms

Spring’s transaction propagation defines seven behaviors—REQUIRED, SUPPORTS, MANDATORY, REQUIRES_NEW, NOT_SUPPORTED, NEVER, and NESTED—detailing how methods join, create, suspend, or nest transactions, and the article explains each type, practical scenarios, and how proper selection ensures atomicity, consistency, and correct rollback handling.

Javapropagationspring
0 likes · 9 min read
Understanding Spring Transaction Propagation Mechanisms
IT Xianyu
IT Xianyu
Jan 2, 2024 · Backend Development

Ensuring Transaction Consistency in Multithreaded Spring Applications Using Programmatic Transactions

This article explains how to execute two dependent tasks in parallel, guarantee their successful completion before a final step, and maintain transaction consistency across multiple threads in Spring by using CompletableFuture, programmatic transaction management, and a custom transaction‑resource copying mechanism.

CompletableFutureJavaProgrammaticTransaction
0 likes · 18 min read
Ensuring Transaction Consistency in Multithreaded Spring Applications Using Programmatic Transactions
Sanyou's Java Diary
Sanyou's Java Diary
Dec 21, 2023 · Databases

What Happens Inside MySQL When You Run an UPDATE? A Deep Dive

This article explains the complete execution process of a MySQL UPDATE statement, covering InnoDB page structures, tablespaces, buffer pool caching, redo/undo logs, binlog, and the two‑phase commit mechanism, helping readers understand how MySQL ensures data consistency and durability.

InnoDBUPDATEbuffer pool
0 likes · 21 min read
What Happens Inside MySQL When You Run an UPDATE? A Deep Dive
Su San Talks Tech
Su San Talks Tech
Dec 18, 2023 · Databases

Master MySQL Transactions: ACID, Isolation Levels, and MVCC Explained

This comprehensive guide explores MySQL transaction fundamentals, the ACID properties, various isolation levels, concurrency issues like dirty, non‑repeatable, and phantom reads, and dives deep into MVCC implementation, hidden fields, undo logs, and read views to help developers write reliable, consistent database code.

ACIDDatabaseIsolation Level
0 likes · 24 min read
Master MySQL Transactions: ACID, Isolation Levels, and MVCC Explained
DataFunTalk
DataFunTalk
Dec 17, 2023 · Databases

Evolution of MatrixOne: From NewSQL/MPP Roots to a Modern HTAP Architecture

This article introduces the open‑source distributed database MatrixOne, tracing its early NewSQL/MPP architecture, the challenges that prompted a major redesign, and the resulting HTAP‑oriented three‑layer architecture with decoupled compute, transaction, and storage layers, highlighting performance, cost, and scalability improvements.

HTAPMatrixOneStorage Engine
0 likes · 22 min read
Evolution of MatrixOne: From NewSQL/MPP Roots to a Modern HTAP Architecture
政采云技术
政采云技术
Dec 14, 2023 · Databases

Understanding MySQL Locks: Types, Mechanisms, and Deadlock Resolution

This article explains the various lock types in MySQL—including global, table, row, metadata, and intent locks—how they work under InnoDB, demonstrates lock acquisition with SQL examples, and provides practical guidance for detecting and resolving deadlocks in production environments.

DatabaseInnoDBLocks
0 likes · 17 min read
Understanding MySQL Locks: Types, Mechanisms, and Deadlock Resolution
Top Architect
Top Architect
Dec 11, 2023 · Backend Development

Optimizing Large Transactions in Backend Development

The article explains why large database transactions degrade backend API performance, outlines issues such as data inconsistency, lock contention, and log overhead, and presents practical optimization techniques including avoiding RPC inside transactions, using programmatic transactions, batch processing, splitting into smaller transactions, and asynchronous parallel execution with CompletableFuture.

backendtransaction
0 likes · 10 min read
Optimizing Large Transactions in Backend Development
Efficient Ops
Efficient Ops
Dec 6, 2023 · Databases

When and How to Use MySQL Locks: A Deep Dive into Explicit and Implicit Locking

This article explains MySQL's explicit and implicit locking mechanisms, illustrates how transaction isolation levels affect lock scope, provides practical SQL examples for various scenarios, and offers guidelines on when to apply pessimistic locks versus optimistic approaches to maintain database performance.

DatabaseSQLlocking
0 likes · 13 min read
When and How to Use MySQL Locks: A Deep Dive into Explicit and Implicit Locking
Architect
Architect
Dec 2, 2023 · Backend Development

7 Common Message‑Queue Scenarios and How to Choose the Right Type

This article examines seven typical messaging scenarios—ordinary, ordered, delayed, transactional, trace, dead‑letter, and priority messages—explaining the problem each solves, the trade‑offs, and concrete implementations in RocketMQ, Pulsar, RabbitMQ and Kafka with code samples.

Message Queuebackenddead-letter
0 likes · 14 min read
7 Common Message‑Queue Scenarios and How to Choose the Right Type
Architect
Architect
Nov 21, 2023 · Backend Development

Why Large Database Transactions Slow Your API and How to Fix Them

The article explains how bundling many business‑logic steps into a single large transaction harms API performance, outlines the resulting concurrency, locking, undo‑log, and DB‑pressure issues, and then presents practical techniques—programmatic transactions, batch processing, transaction splitting, and asynchronous parallelism—to optimize and speed up backend services.

AsynchronousPerformancebatch-processing
0 likes · 10 min read
Why Large Database Transactions Slow Your API and How to Fix Them
MaGe Linux Operations
MaGe Linux Operations
Nov 18, 2023 · Databases

Understanding SQL Server Deadlocks: Causes, Detection, and Prevention

This article explains the principle of deadlocks, the four necessary conditions, how they manifest in SQL Server resources, methods for investigating deadlocks with system procedures and Profiler, and practical techniques—including isolation level changes, lock timeouts, and bound sessions—to avoid and resolve them.

PerformanceSQL Serverdeadlock
0 likes · 17 min read
Understanding SQL Server Deadlocks: Causes, Detection, and Prevention
IT Architects Alliance
IT Architects Alliance
Nov 17, 2023 · Backend Development

Design and Implementation of a Generic Asynchronous Processing SDK

This article introduces a generic asynchronous processing SDK for Java Spring applications, covering its purpose, advantages, underlying principles, component choices such as Kafka, XXL‑Job, MySQL, design patterns, database schema, configuration via Apollo, usage instructions, safety considerations, and provides code examples and a GitHub repository link.

AOPAsyncKafka
0 likes · 9 min read
Design and Implementation of a Generic Asynchronous Processing SDK
JD Tech
JD Tech
Nov 13, 2023 · Databases

Analysis of MySQL Lock Mechanisms and Deadlock Scenarios

This article examines MySQL's various lock types—including shared, exclusive, gap, next‑key, and insert‑intention locks—illustrates how they interact during concurrent transactions, analyzes a real‑world deadlock incident, and provides recommendations for preventing similar concurrency issues in high‑traffic systems.

Locksconcurrencymysql
0 likes · 19 min read
Analysis of MySQL Lock Mechanisms and Deadlock Scenarios
Architecture Digest
Architecture Digest
Nov 10, 2023 · Backend Development

Understanding Spring Boot @Async: Usage, Pitfalls, and Best Practices

This article explains how to enable and configure Spring Boot's @Async annotation, demonstrates proper thread‑pool setup, highlights common mistakes such as calling async methods within the same class or mixing with @Transactional, and provides guidance on handling blocking tasks and exceptions for robust asynchronous execution.

AsyncAsynchronousException Handling
0 likes · 10 min read
Understanding Spring Boot @Async: Usage, Pitfalls, and Best Practices
Selected Java Interview Questions
Selected Java Interview Questions
Oct 30, 2023 · Databases

Understanding SELECT ... FOR UPDATE Locks in MySQL

This article explains how MySQL's SELECT ... FOR UPDATE statement applies different lock types—row, table, or none—depending on whether the WHERE clause uses primary keys, unique indexes, regular indexes, range queries, non‑indexed fields, or returns no rows, illustrated with practical transaction examples.

SELECT FOR UPDATESQLdatabase locking
0 likes · 9 min read
Understanding SELECT ... FOR UPDATE Locks in MySQL
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Oct 25, 2023 · Databases

Optimizing Transaction SQL for High‑Concurrency Sales Events: Comparing Two Transaction Approaches

The article analyzes how to improve inventory‑update transactions during massive sales periods by comparing two SQL transaction patterns, calculating their TPS under defined latency assumptions, and suggesting that placing the row lock closer to the commit yields significantly higher throughput.

Database OptimizationSQLTPS
0 likes · 7 min read
Optimizing Transaction SQL for High‑Concurrency Sales Events: Comparing Two Transaction Approaches
Selected Java Interview Questions
Selected Java Interview Questions
Oct 11, 2023 · Databases

Understanding and Handling MySQL Deadlocks

This article explains MySQL deadlocks, describing common scenarios such as multi‑table updates, nested transactions, inconsistent index order, and concurrent index updates, provides a concrete banking transfer example, and outlines practical steps for monitoring, terminating, retrying, analyzing, and preventing deadlocks in production.

SQLtransaction
0 likes · 9 min read
Understanding and Handling MySQL Deadlocks
Su San Talks Tech
Su San Talks Tech
Oct 6, 2023 · Databases

How MySQL Executes SQL: From Connection Pools to Log Files Explained

This article walks through how a Java application interacts with MySQL, covering the driver, connection pooling, thread handling, query parsing, the optimizer, storage engine, buffer pool, undo/redo logs, binlog, and transaction commit, providing a complete end‑to‑end view of MySQL’s internal processing.

DatabaseInnoDBlog
0 likes · 22 min read
How MySQL Executes SQL: From Connection Pools to Log Files Explained
政采云技术
政采云技术
Sep 28, 2023 · Backend Development

Common Scenarios Where Spring @Transactional Fails and How to Avoid Them

This article explains the fundamentals of database transactions, introduces Spring's @Transactional annotation, and enumerates nine typical situations—such as incorrect method visibility, final methods, self‑invocation, unmanaged beans, multithreading, wrong propagation, swallowed exceptions, unsupported exception types, and non‑transactional storage engines—where transactions may not work as expected, offering guidance to prevent these pitfalls.

AOPJavabackend
0 likes · 13 min read
Common Scenarios Where Spring @Transactional Fails and How to Avoid Them
dbaplus Community
dbaplus Community
Sep 27, 2023 · Databases

Understanding MySQL Locks: Which Queries Actually Acquire Locks?

This article breaks down MySQL's complex locking mechanisms—global, table, and row locks—explaining how different SELECT statements, transaction isolation levels, and index types affect lock acquisition, and provides practical test scripts and visual examples to help developers master lock behavior.

InnoDBIsolationLevelLocks
0 likes · 14 min read
Understanding MySQL Locks: Which Queries Actually Acquire Locks?
ITPUB
ITPUB
Sep 23, 2023 · Databases

Is PostgreSQL Really the Most Popular Database? A Deep Dive into Rankings, Architecture, and Performance

This article examines why PostgreSQL appears to outrank MySQL in recent popularity surveys, explains the DB‑Engines ranking methodology, compares architectural choices such as MVCC, multi‑process vs multi‑thread models, transaction rollback behavior, licensing, and real‑world performance benchmarks like TPC‑C, ultimately revealing that MySQL still dominates many high‑throughput OLTP scenarios.

MVCCPostgreSQLdatabase comparison
0 likes · 17 min read
Is PostgreSQL Really the Most Popular Database? A Deep Dive into Rankings, Architecture, and Performance
Tencent Cloud Developer
Tencent Cloud Developer
Sep 18, 2023 · Databases

Who Is the World's Most Successful Database? An In‑Depth Technical Comparison of PostgreSQL and MySQL

The article evaluates database success by comparing PostgreSQL and MySQL across popularity, features, licensing, transaction behavior, MVCC, concurrency models, and use cases, showing PostgreSQL leads in complex queries and feature richness while MySQL remains the most widely used OLTP system, especially in China.

DB-EnginesMVCCPerformance
0 likes · 15 min read
Who Is the World's Most Successful Database? An In‑Depth Technical Comparison of PostgreSQL and MySQL
dbaplus Community
dbaplus Community
Sep 14, 2023 · Databases

Master MySQL InnoDB Locks: From Row Locks to Deadlock Prevention

This article explains why MySQL needs locking, details every InnoDB lock type—including shared, exclusive, intention, record, gap, next‑key, insert‑intention and auto‑increment locks—covers lock compatibility, deadlock causes and prevention, compares optimistic and pessimistic locking, and shows how SELECT FOR UPDATE behaves under different isolation levels.

InnoDBconcurrencydeadlock
0 likes · 20 min read
Master MySQL InnoDB Locks: From Row Locks to Deadlock Prevention
Architect
Architect
Sep 12, 2023 · Backend Development

Ensuring Transaction Consistency in Multi‑Threaded Spring Applications Using CompletableFuture and Programmatic Transactions

This article explains how to parallelize business steps with CompletableFuture, why Spring's @Async and @Transactional annotations cannot guarantee transaction consistency across threads, and presents a programmatic transaction approach—including copying Spring's transaction resources between threads—to achieve reliable multi‑threaded commits or rollbacks.

CompletableFutureJavaProgrammaticTransaction
0 likes · 19 min read
Ensuring Transaction Consistency in Multi‑Threaded Spring Applications Using CompletableFuture and Programmatic Transactions
Architect's Tech Stack
Architect's Tech Stack
Jun 24, 2023 · Backend Development

Implementing Multi‑threaded Transactions in Spring Boot with Custom Annotations and AOP

This article explains why @Transactional fails in multithreaded Spring Boot scenarios, then demonstrates how to combine @Async, a custom thread‑pool, @MainTransaction and @SonTransaction annotations with AOP logic to achieve reliable multi‑threaded transaction control, complete with code examples and usage guidelines.

AOPCustom AnnotationJava
0 likes · 12 min read
Implementing Multi‑threaded Transactions in Spring Boot with Custom Annotations and AOP
Aikesheng Open Source Community
Aikesheng Open Source Community
Jun 6, 2023 · Databases

Why Does Inserting a Record that Triggers a Unique Index Conflict Add a Next‑Key Exclusive Lock on the Primary‑Key Supremum Record?

This article reproduces a MySQL 8.0.32 InnoDB scenario where inserting a row that violates a unique index causes a next‑key exclusive lock on the primary‑key supremum record, explains the underlying implicit‑lock mechanism, walks through the relevant source‑code stack, and details the lock‑conversion and rollback steps under REPEATABLE‑READ isolation.

Database InternalsInnoDBRepeatable Read
0 likes · 25 min read
Why Does Inserting a Record that Triggers a Unique Index Conflict Add a Next‑Key Exclusive Lock on the Primary‑Key Supremum Record?
Cognitive Technology Team
Cognitive Technology Team
May 21, 2023 · Backend Development

Concurrency Safety Issues Caused by AOP Object Escape and Incorrect Advice Order in Spring

This article explains how improper use of AOP in Spring can cause object escape leading to concurrency safety problems, discusses issues such as asynchronous thread modifications, caching, and incorrect advice ordering with @Transaction, @Retryable, and dynamic datasource switching, and provides practical guidance to avoid these pitfalls.

AOPJavaObject Escape
0 likes · 5 min read
Concurrency Safety Issues Caused by AOP Object Escape and Incorrect Advice Order in Spring
Architecture Digest
Architecture Digest
Apr 25, 2023 · Backend Development

Design and Implementation of a Scalable Transaction Platform for Vivo Global Mall

This article details the design principles, architecture, multi‑tenant sharding strategy, state‑machine workflow, distributed transaction handling, and high‑availability measures of Vivo's transaction platform, illustrating how a micro‑service‑based e‑commerce system achieves low cost, extensibility, and robust performance.

State Machinee-commercetransaction
0 likes · 12 min read
Design and Implementation of a Scalable Transaction Platform for Vivo Global Mall
Code Ape Tech Column
Code Ape Tech Column
Apr 25, 2023 · Backend Development

Advanced Java Multithreading: From Fundamentals to High‑Performance Transactional Scenarios

This article explores Java multithreading concepts, JVM safety tools, thread creation methods, coordination mechanisms, and practical scenarios such as parallel data aggregation, for‑loop conversion, map‑based processing, and multi‑threaded transaction handling, providing code examples and performance tips for backend developers.

CompletableFutureJavaThreadPool
0 likes · 22 min read
Advanced Java Multithreading: From Fundamentals to High‑Performance Transactional Scenarios
Java High-Performance Architecture
Java High-Performance Architecture
Apr 17, 2023 · Backend Development

Master Dynamic Multi‑DataSource Switching and Transaction Management in Spring

This article explains how to dynamically manage multiple Spring data sources, switch between them at runtime, and implement custom multi‑database transaction handling, covering both configuration‑file and database‑table approaches, with code examples and AOP techniques for seamless integration.

DataSourceDynamic Routingmulti-database
0 likes · 16 min read
Master Dynamic Multi‑DataSource Switching and Transaction Management in Spring
Top Architect
Top Architect
Mar 2, 2023 · Backend Development

Understanding Spring Transaction Propagation and Common Pitfalls

This article explains Spring's unified transaction model, the @Transactional annotation, and the various propagation and isolation settings, then details ten typical scenarios—such as missing Spring management, final or private methods, internal calls, wrong propagation, multithreading, and unsupported databases—that cause transactions to fail, providing code examples and solutions to avoid each issue.

jpaspring-boottransaction
0 likes · 14 min read
Understanding Spring Transaction Propagation and Common Pitfalls
政采云技术
政采云技术
Feb 21, 2023 · Databases

Understanding Next-Key Lock Deadlocks in MySQL and How to Avoid Them

This article examines how common business operations using SELECT ... FOR UPDATE and INSERT can cause Next‑Key lock deadlocks in MySQL under repeatable‑read isolation, demonstrates the locking behavior with practical SQL examples, and proposes strategies such as post‑locking and primary‑key updates to prevent such deadlocks.

DatabaseIsolation LevelNext-key Lock
0 likes · 14 min read
Understanding Next-Key Lock Deadlocks in MySQL and How to Avoid Them
Liangxu Linux
Liangxu Linux
Feb 18, 2023 · Databases

Why Does One MySQL UPDATE Block While Another Doesn’t? Deep Dive into InnoDB Locks

The article explains why an UPDATE on the same row in MySQL can block in one transaction but not in another, by analyzing the types of row‑level locks (record, next‑key, gap) acquired during SELECT … FOR UPDATE, normal updates, and updates that modify primary‑key values, illustrating the lock behavior with B+‑tree examples.

B+TreeInnoDBUPDATE
0 likes · 8 min read
Why Does One MySQL UPDATE Block While Another Doesn’t? Deep Dive into InnoDB Locks
ITPUB
ITPUB
Feb 17, 2023 · Databases

Master MySQL Locking: From Row Locks to Deadlocks and How to Prevent Them

This article explains why MySQL needs locking, details every InnoDB lock type—including shared, exclusive, intention, record, gap, next‑key, insert‑intention and auto‑increment locks—shows how they interact, and provides practical guidance for avoiding deadlocks and safely updating rows.

InnoDBIsolation LevelOptimistic Lock
0 likes · 22 min read
Master MySQL Locking: From Row Locks to Deadlocks and How to Prevent Them
Top Architect
Top Architect
Dec 26, 2022 · Databases

Understanding Transaction Isolation and Concurrency Issues in MySQL

The article explains why transaction isolation is needed, describes common concurrency problems such as lost updates, dirty reads, non‑repeatable reads and phantom reads, outlines the ACID properties of a transaction, and details MySQL's four isolation levels and their impact on data consistency.

ACIDisolationmysql
0 likes · 8 min read
Understanding Transaction Isolation and Concurrency Issues in MySQL
DeWu Technology
DeWu Technology
Dec 21, 2022 · Databases

InnoDB Storage Architecture and Transaction Persistence Mechanisms

The article explains MySQL InnoDB’s internal storage hierarchy—from tablespaces, segments, and extents to pages and rows—its physical components such as buffer pool, change buffer, adaptive hash index, redo and binary logs, persistence techniques like double‑write buffering and log‑flushing policies, and how two‑phase commit and SQL execution interact, helping developers write correct, high‑performance applications.

InnoDBPersistenceStorage Engine
0 likes · 33 min read
InnoDB Storage Architecture and Transaction Persistence Mechanisms
IT Xianyu
IT Xianyu
Dec 2, 2022 · Databases

How MySQL InnoDB Implements ACID: Locks, MVCC, and Logging

This article explains how MySQL's InnoDB engine guarantees ACID properties by describing the four components of ACID, the four isolation levels, lock granularity and types, the MVCC mechanism with version chains and read views, and the roles of undo, redo, and bin logs in ensuring atomicity, consistency, isolation, and durability.

ACIDInnoDBLock
0 likes · 14 min read
How MySQL InnoDB Implements ACID: Locks, MVCC, and Logging
High Availability Architecture
High Availability Architecture
Dec 1, 2022 · Fundamentals

Extending Paxos with Partially Ordered rnd Values for Transactional Mutual Exclusion

The article explains how Paxos can be generalized by defining its round number (rnd) over any partially ordered set, enabling both forced and non‑forced conflict exclusion mechanisms similar to 2PC, and showing how this expands Paxos’s applicability to multi‑dimensional transaction ordering and simplifies distributed database architectures.

2PCConsensusDistributed Systems
0 likes · 4 min read
Extending Paxos with Partially Ordered rnd Values for Transactional Mutual Exclusion
Architecture Digest
Architecture Digest
Nov 29, 2022 · Databases

MySQL InnoDB Deadlock Analysis and Resolution for a Video‑Conference Service

The article details a step‑by‑step investigation of an intermittent deadlock occurring during session creation in a video‑conference system, explains how InnoDB lock types caused the conflict between DELETE and INSERT statements on the session and session_endpoint tables, reproduces the issue, debugs MySQL source code, and presents a simple code‑order fix to eliminate the deadlock.

DatabaseDebuggingInnoDB
0 likes · 21 min read
MySQL InnoDB Deadlock Analysis and Resolution for a Video‑Conference Service
IT Architects Alliance
IT Architects Alliance
Nov 24, 2022 · Backend Development

Transaction Consistency Strategies in Microservices: Blocking Retry, Async Queues, TCC, and Local Message Tables

The article examines common microservice transaction consistency techniques—including blocking retries, asynchronous queues, TCC compensation transactions, local message tables, and MQ transactions—explaining their mechanisms, advantages, drawbacks, and practical code examples for ensuring data integrity across distributed services.

ConsistencyMessage QueueRetry
0 likes · 13 min read
Transaction Consistency Strategies in Microservices: Blocking Retry, Async Queues, TCC, and Local Message Tables
Top Architect
Top Architect
Nov 23, 2022 · Backend Development

Transaction Consistency Strategies in Distributed Microservices: Blocking Retry, Asynchronous Queue, TCC, and Local Message Table

The article explains various techniques for ensuring data consistency in distributed microservice architectures, including blocking retries, asynchronous queues, TCC compensation transactions, local message tables, and MQ transactions, while discussing their advantages, drawbacks, and practical implementation details.

ConsistencyMessage Queuebackend
0 likes · 15 min read
Transaction Consistency Strategies in Distributed Microservices: Blocking Retry, Asynchronous Queue, TCC, and Local Message Table