This paper surveys and presents the state of the art in distributed database concurrency control. The concurrency control problem is decomposed into two subproblems: read-write synchronization and write-write synchronization. The paper describes synchronization techniques for solving each subproblem and shows how to combine them into algorithms for solving the entire concurrency control problem. These algorithms are called "concurrency control methods." The paper describes 48 principal methods, including all practical algorithms that have appeared in the literature plus several new ones. The focus is on the structure and correctness of concurrency control algorithms, with performance issues given secondary treatment. The paper introduces a standard terminology for describing DDBMS concurrency control algorithms and a standard model for the DDBMS environment. The concurrency control problem is decomposed into two major subproblems: read-write and write-write synchronization. Every concurrency control algorithm must include a subalgorithm to solve each subproblem. The first step toward understanding a concurrency control algorithm is to isolate the subalgorithm employed for each subproblem. After studying the large number of proposed algorithms, it is found that they are compositions of only a few subalgorithms. In fact, the subalgorithms used by all practical DDBMS concurrency control algorithms are variations of just two basic techniques: two-phase locking and timestamp ordering. Thus, the state of the art is far more coherent than a review of the literature would seem to indicate. The paper discusses two canonical examples of concurrency control anomalies: lost updates and inconsistent retrievals. These examples illustrate the problem of interference among users accessing a database simultaneously. The paper also compares database concurrency control to mutual exclusion problems in operating systems, noting that while both are concerned with controlling concurrent access to shared resources, control schemes that work for one do not necessarily work for the other. The paper presents a transaction-processing model for a DDBMS, emphasizing how the DDBMS processes user interactions. It describes a centralized and a distributed transaction-processing model. The centralized model involves one TM and one DM at one site, while the distributed model involves multiple TMs and DMs at different sites. The paper discusses two-phase locking (2PL) and timestamp ordering (T/O) as synchronization techniques. 2PL synchronizes reads and writes by explicitly detecting and preventing conflicts between concurrent operations. T/O selects a serialization order a priori and forces transaction execution to obey this order. The paper describes various implementations of 2PL and T/O, including primary copy 2PL, voting 2PL, and centralized 2PL. It also discusses deadlock detection and prevention techniques, including waits-for graphs and priority-based approaches. The paper concludes by emphasizing the importance of decomposing the concurrency control problem into read-write and write-write synchronization, and the role of two-phase locking and timestamp ordering in achieving serializability. The paper highlights the need for correct algorithms that ensure that all executions are serializable, preserving the correctness of database transactions.This paper surveys and presents the state of the art in distributed database concurrency control. The concurrency control problem is decomposed into two subproblems: read-write synchronization and write-write synchronization. The paper describes synchronization techniques for solving each subproblem and shows how to combine them into algorithms for solving the entire concurrency control problem. These algorithms are called "concurrency control methods." The paper describes 48 principal methods, including all practical algorithms that have appeared in the literature plus several new ones. The focus is on the structure and correctness of concurrency control algorithms, with performance issues given secondary treatment. The paper introduces a standard terminology for describing DDBMS concurrency control algorithms and a standard model for the DDBMS environment. The concurrency control problem is decomposed into two major subproblems: read-write and write-write synchronization. Every concurrency control algorithm must include a subalgorithm to solve each subproblem. The first step toward understanding a concurrency control algorithm is to isolate the subalgorithm employed for each subproblem. After studying the large number of proposed algorithms, it is found that they are compositions of only a few subalgorithms. In fact, the subalgorithms used by all practical DDBMS concurrency control algorithms are variations of just two basic techniques: two-phase locking and timestamp ordering. Thus, the state of the art is far more coherent than a review of the literature would seem to indicate. The paper discusses two canonical examples of concurrency control anomalies: lost updates and inconsistent retrievals. These examples illustrate the problem of interference among users accessing a database simultaneously. The paper also compares database concurrency control to mutual exclusion problems in operating systems, noting that while both are concerned with controlling concurrent access to shared resources, control schemes that work for one do not necessarily work for the other. The paper presents a transaction-processing model for a DDBMS, emphasizing how the DDBMS processes user interactions. It describes a centralized and a distributed transaction-processing model. The centralized model involves one TM and one DM at one site, while the distributed model involves multiple TMs and DMs at different sites. The paper discusses two-phase locking (2PL) and timestamp ordering (T/O) as synchronization techniques. 2PL synchronizes reads and writes by explicitly detecting and preventing conflicts between concurrent operations. T/O selects a serialization order a priori and forces transaction execution to obey this order. The paper describes various implementations of 2PL and T/O, including primary copy 2PL, voting 2PL, and centralized 2PL. It also discusses deadlock detection and prevention techniques, including waits-for graphs and priority-based approaches. The paper concludes by emphasizing the importance of decomposing the concurrency control problem into read-write and write-write synchronization, and the role of two-phase locking and timestamp ordering in achieving serializability. The paper highlights the need for correct algorithms that ensure that all executions are serializable, preserving the correctness of database transactions.