CN116541402A - Database concurrent spin locking and unlocking optimization method and equipment - Google Patents
Database concurrent spin locking and unlocking optimization method and equipment Download PDFInfo
- Publication number
- CN116541402A CN116541402A CN202310400837.4A CN202310400837A CN116541402A CN 116541402 A CN116541402 A CN 116541402A CN 202310400837 A CN202310400837 A CN 202310400837A CN 116541402 A CN116541402 A CN 116541402A
- Authority
- CN
- China
- Prior art keywords
- structure body
- unlocking
- waiting
- bitmap
- pointer
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 128
- 238000005457 optimization Methods 0.000 title claims abstract description 27
- 238000004590 computer program Methods 0.000 claims description 10
- 238000009987 spinning Methods 0.000 claims description 5
- 230000003287 optical effect Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/23—Updating
- G06F16/2308—Concurrency control
- G06F16/2336—Pessimistic concurrency control approaches, e.g. locking or multiple versions without time stamps
- G06F16/2343—Locking methods, e.g. distributed locking or locking implementation details
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/466—Transaction processing
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/52—Program synchronisation; Mutual exclusion, e.g. by means of semaphores
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Data Mining & Analysis (AREA)
- Databases & Information Systems (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The application discloses a database concurrent spin locking and unlocking optimization method and equipment, comprising the following steps: pre-building a structure for spin; pre-configuring an array, the array being used as a node container for the constructed structure; a pre-configured bitmap is used for marking the position and the state of a node owned by each process in the node container; the locking process is as follows: taking out the corresponding structure from the node container according to the target position in the bitmap; judging whether a tail pointer is empty, if so, adding the structure body into a waiting linked list, and locking, wherein the tail pointer is used for pointing to the last element of the waiting linked list, and the waiting linked list is constructed based on each process needing to lock the structure body; if the structure body is not empty, adding the structure body into a waiting chain table, spin waiting and locking. The method can reduce the occurrence times of the message synchronization mechanism between the CPUs and improve the performance of the program.
Description
Technical Field
The application relates to the technical field of databases, in particular to a method and equipment for optimizing locking and unlocking of concurrent spin locks of a database.
Background
The spin lock in PostgreSQL is a conventional spin lock, and this spin lock is denoted by a lock variable clock_t, and in a high concurrency case, multiple CPUs frequently read and write the shared variable while locking and unlocking and waiting, and buffer jitter is caused during message synchronization between the CPUs, thereby causing performance loss.
The method for realizing the existing spin lock in the PostgreSQL is a method for realizing locking and unlocking by sharing a lock variable by a plurality of processes, when one CPU of the lock variable is contended for locking to modify the numerical value in the CPU cache during program operation, the CPU can send a message to other CPUs, inform the other CPUs that the numerical value of the same variable in the caches of the other CPUs is invalid, and the other CPUs can send a reply message for receiving the message to the CPU sending the message to respond, and the sending and responding of the message belong to a message synchronization mechanism among the CPUs. In the case of high concurrency, a message synchronization mechanism between the CPUs, which is accompanied by the continuous locking and unlocking of the spin lock in the running process of the program, frequently occurs, so that the performance of the program is reduced.
Disclosure of Invention
The embodiment of the application provides a database concurrent spin locking and unlocking optimization method and device, which are used for reducing the occurrence times of a message synchronization mechanism between CPUs and improving the performance of a program.
The embodiment of the application provides a database concurrent spin lock locking optimization method, which comprises the following steps:
pre-building a structure for spinning, wherein the structure comprises a first pointer and a variable, the first pointer points to another structure of the same type, and the variable is used for judging whether the structure is locked or not based on the value of the variable;
pre-configuring an array, wherein the array is used as a node container of a constructed structure body and can store a plurality of the structure bodies, each structure body is configured with a corresponding mark based on the array, the marks are used for indexing the structure bodies in the array, and the marks are in one-to-one correspondence with the positions of the corresponding structure bodies in a bitmap;
a pre-configured bitmap is used for marking the position and the state of a node owned by each process in the node container;
the locking process is as follows:
taking out the corresponding structure from the node container according to the target position in the bitmap;
judging whether a tail pointer is empty, if so, adding the structure body into a waiting linked list, and locking, wherein the tail pointer is used for pointing to the last element of the waiting linked list, and the waiting linked list is constructed based on each process needing to lock the structure body;
if the structure body is not empty, adding the structure body into a waiting chain table, spin waiting and locking.
Optionally, the variable is an int-type variable, when the defined value is 1, the process can be locked, when the defined value is 0, the process cannot be locked, and the method further comprises the following initialization flow:
the variables that initialize each structure are 0 and in the event that the tail pointer is empty, the process may lock directly.
Optionally, the spin waiting further includes the following procedures:
and (3) determining whether locking is possible or not according to the current variable of the structural body at the specified interval.
Optionally, a set value is configured according to the bitmap, so as to represent the occupied state of the node owned by each process in the node container;
the step of extracting the corresponding structure from the node container according to the target position in the bitmap comprises the following steps:
and setting the first unoccupied position in the bitmap, and taking out the corresponding structure body from the node container.
The embodiment of the application also provides a database concurrency spin lock unlocking optimization method, which comprises the following steps:
pre-building a structure for spinning, wherein the structure comprises a first pointer and a variable, the first pointer points to another structure of the same type, and the variable is used for judging whether the structure is locked or not based on the value of the variable;
pre-configuring an array, wherein the array is used as a node container of a constructed structure body and can store a plurality of the structure bodies, each structure body is configured with a corresponding mark based on the array, the marks are used for indexing the structure bodies in the array, and the marks are in one-to-one correspondence with the positions of the corresponding structure bodies in a bitmap;
a pre-configured bitmap is used for marking the position and the state of a node owned by each process in the node container;
the unlocking process is as follows:
taking out the corresponding structure from the node container according to the target position in the bitmap;
judging whether a first pointer of the structure body is empty or not, and unlocking a current process if the first pointer of the structure body is not empty;
if the tail pointer points to the structure body, judging whether the tail pointer points to the structure body, if so, setting the tail pointer to be empty, unlocking the current process, and if not, waiting for the next structure body to be successfully pointed back by the first pointer of the current structure body and then unlocking, wherein the tail pointer is used for pointing to the last element of a waiting linked list, and the waiting linked list is constructed based on each process needing to lock the structure body.
Optionally, the unlocking process further includes:
and judging whether the tail pointer points to the structural body, if not, setting the variable in the structural body pointed by the first pointer of the current structural body.
Optionally, the unlocking process further includes: and judging whether the structure body owned by the current process is the same as the structure body pointed by the tail pointer, and if so, setting the tail pointer to be empty.
The embodiment of the application also provides a computer device, which comprises a processor and a memory, wherein the computer program is stored on the processor, and the computer program realizes the steps of the database concurrent spin lock locking optimization method and/or realizes the steps of the database concurrent spin lock unlocking optimization method when being executed by the processor.
The embodiments of the present application further provide a computer readable storage medium, on which a computer program is stored, where the computer program when executed by a processor implements the steps of the foregoing database concurrent spin lock locking optimization method and/or implements the steps of the foregoing database concurrent spin lock unlocking optimization method.
Aiming at the problem that the performance of a program is reduced due to a message synchronization mechanism for locking and unlocking spin locks, which is continuously performed in the running process of the program, between CPUs under the condition of high concurrency, the embodiment of the application provides a locking and unlocking optimization method, so that the occurrence times of the message synchronization mechanism between CPUs can be reduced, and the performance of the program is improved.
The foregoing description is only an overview of the technical solutions of the present application, and may be implemented according to the content of the specification in order to make the technical means of the present application more clearly understood, and in order to make the above-mentioned and other objects, features and advantages of the present application more clearly understood, the following detailed description of the present application will be given.
Drawings
Various other advantages and benefits will become apparent to those of ordinary skill in the art upon reading the following detailed description of the preferred embodiments. The drawings are only for purposes of illustrating the preferred embodiments and are not to be construed as limiting the application. Also, like reference numerals are used to designate like parts throughout the figures. In the drawings:
FIG. 1 is an example of the relationship between node containers, nodes, lock variable structures of embodiments of the present application;
FIG. 2 is an example of relationships between process, bitmap, node containers in accordance with an embodiment of the present application;
FIG. 3 is a flowchart of an example of a spin lock locking optimization method according to an embodiment of the present application;
fig. 4 is a flowchart illustration of a spin lock unlocking optimization method according to an embodiment of the present application.
Detailed Description
Exemplary embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be embodied in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.
The embodiment of the application provides a database concurrent spin lock locking optimization method, which comprises the following steps:
a structure (node) for spin is built in advance, that is, wherein the structure contains a first pointer to another structure of the same type and a variable for judging whether the structure is locked or unlocked based on its value. As shown in fig. 1, the node is a structure, and in fig. 1, one structure is shown in each of the lowermost parts node1 to node4, and any structure includes a first pointer (e.g., next pointer) and a variable "spin" that points to a structure of the same type as the structure, and the variable "spin" is used to determine whether or not a lock can be acquired by itself. Each process has a structure body unique to the process, and when the process is in spin waiting, the process can be judged according to spin of the process.
An array is pre-configured, the array is used as a node container of the constructed structure body, a plurality of the structure bodies can be stored, corresponding identifiers are configured for each structure body based on the array, the identifiers are used for indexing the structure bodies in the array, and the identifiers are in one-to-one correspondence with the positions of the corresponding structure bodies in a bitmap. The array (node container) applies space for each member in the array in the shared memory, for example, in some specific examples, the identifier configured for each structure may be an array subscript, and other identifier modes are not limited herein. When the index of the array is used to index the structure in the array, the index corresponds to the structure in the bitmap one by one, and the bitmap is referred to as "the successive node1 to node 8" in fig. 2, which is an illustration of the node container.
A bitmap is preconfigured to mark the location and status of the node owned by each process in the node container.
As shown in fig. 3, the locking process is as follows:
taking out the corresponding structure from the node container according to the target position in the bitmap;
judging whether a tail pointer is empty, if so, adding the structure body into a waiting linked list, and locking, wherein the tail pointer is used for pointing to the last element of the waiting linked list, and the waiting linked list is constructed based on each process needing to lock the structure body;
if the structure body is not empty, adding the structure body into a waiting chain table, spin waiting and locking.
In some embodiments, the variable is an int-type variable, and if the process is in a spin wait state, the process can be locked when the value is defined as 1, and the process cannot be locked when the value is 0. In some embodiments, the spin waiting further comprises the following flow: the interval specification time may be, for example, a short time, and it is determined whether or not locking is possible based on the current variable of the structure.
The member in the structure body of the application comprises the tail pointer pointing to the tail part of the waiting linked list, and when locking is carried out, whether the tail pointer is empty or not is judged, and the lock can be obtained. Whether empty or not, will itself be added to the wait linked list. When a process is unlocked in the implementation process, if its next pointer is not null, it needs to set the spin variable contained in the node pointed to by its next pointer of its structure to 1, and the node can obtain the lock. Therefore, the process judges whether locking can be performed according to the spin of the process, judges the spin in the node of the process to avoid message synchronization, and judges a shared lock variable instead, so that cache jitter is greatly reduced.
Aiming at the problem that the performance of a program is reduced due to a message synchronization mechanism for locking and unlocking spin locks, which is continuously performed in the running process of the program, between CPUs under the condition of high concurrency, the embodiment of the application provides a locking and unlocking optimization method, so that the occurrence times of the message synchronization mechanism between CPUs can be reduced, and the performance of the program is improved.
In some embodiments, the following initialization procedure is also included: the variables that initialize each structure are 0 and in the event that the tail pointer is empty, the process may lock directly. That is, spin is initialized to 0, and each construct spin defaults to 0. In the initial state, all processes cannot acquire the lock, and if the processes want to acquire the lock by combining the tail pointer and the tail pointer is empty, the locks can be directly acquired, so that the first process can acquire the locks.
A bitmap is preconfigured to mark the location and status of the node owned by each process in the node container. In some embodiments, a set value is configured according to the bitmap to characterize the occupancy state of the node owned by each process in the node container.
In some embodiments, retrieving the corresponding structure from the node container according to the target location in the bitmap comprises: and setting the first unoccupied position in the bitmap, and taking out the corresponding structure body from the node container. In this embodiment, the bitmap is used to mark the location of the node owned by each process in the node container, for example, the 3 rd bit in the bitmap, which corresponds to the fact that the array subscript may be 3, which represents 3 nodes in the node container. When a sub-process is created, it searches for the first 0 (unset) position in the bitmap, which is assumed to be bit 4, and sets it to 1, which represents that this position is already occupied by the sub-process, then the node owned by the sub-process is the 4 th node in the node container. The first 4 bits of the "bitmap" portion in fig. 2 above are 1, indicating that the first 4 bits have been occupied by four different processes, and that the first 4 nodes in the node container are also owned by these four different processes.
In the method, the bitmap form marking process maintains the number of the independent node; constructing a node container, and distributing shared memory to all members in advance; the process obtains the self node from the node container through the position of the process in the bitmap; the process realizes the locking and unlocking operation through the shared tail pointer and the independent node. Therefore, the cache jitter frequency of the spinlock can be reduced, and the method for optimizing the performance of the database is realized.
The embodiment of the application also provides a database concurrency spin lock unlocking optimization method, which comprises the following steps:
pre-building a structure for spinning, wherein the structure comprises a first pointer and a variable, the first pointer points to another structure of the same type, and the variable is used for judging whether the structure is locked or not based on the value of the variable;
pre-configuring an array, wherein the array is used as a node container of a constructed structure body and can store a plurality of the structure bodies, each structure body is configured with a corresponding mark based on the array, the marks are used for indexing the structure bodies in the array, and the marks are in one-to-one correspondence with the positions of the corresponding structure bodies in a bitmap;
a bitmap is preconfigured to mark the location and status of the node owned by each process in the node container. Reference is made to the foregoing for the contents of the structure, array and bitmap, and no further description is given here.
As shown in fig. 4, the unlocking flow is as follows:
taking out the corresponding structure from the node container according to the target position in the bitmap;
judging whether a first pointer of the structure body is empty or not, and unlocking a current process if the first pointer of the structure body is not empty;
if the tail pointer points to the structure body, judging whether the tail pointer points to the structure body, if so, setting the tail pointer to be empty, unlocking the current process, and if not, waiting for the next structure body to be successfully pointed back by the first pointer of the current structure body and then unlocking, wherein the tail pointer is used for pointing to the last element of a waiting linked list, and the waiting linked list is constructed based on each process needing to lock the structure body.
In some embodiments, the unlocking procedure further comprises: and judging whether the tail pointer points to the structural body, if not, setting the variable in the structural body pointed by the first pointer of the current structural body.
In some embodiments, the unlocking procedure further comprises: and judging whether the structure body owned by the current process is the same as the structure body pointed by the tail pointer, and if so, setting the tail pointer to be empty. When the lock is specifically unlocked, whether the node owned by the current process is the same node as the node pointed by the tail pointer or not can be judged, and if so, the tail pointer is set to be empty.
The method can reduce CPU cache jitter frequency generated by a database such as a PostgreSQL spin lock, improves the performance of the database, and is particularly suitable for performance optimization of the PostgreSQL database.
The embodiment of the application also provides a computer device, which comprises a processor and a memory, wherein the computer program is stored on the processor, and the computer program realizes the steps of the database concurrent spin lock locking optimization method and/or realizes the steps of the database concurrent spin lock unlocking optimization method when being executed by the processor.
The embodiments of the present application further provide a computer readable storage medium, on which a computer program is stored, where the computer program when executed by a processor implements the steps of the foregoing database concurrent spin lock locking optimization method and/or implements the steps of the foregoing database concurrent spin lock unlocking optimization method.
It should be noted that, in this document, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element.
The foregoing embodiment numbers of the present application are merely for describing, and do not represent advantages or disadvantages of the embodiments.
From the above description of the embodiments, it will be clear to those skilled in the art that the above-described embodiment method may be implemented by means of software plus a necessary general hardware platform, but of course may also be implemented by means of hardware, but in many cases the former is a preferred embodiment. Based on such understanding, the technical solution of the present application may be embodied essentially or in a part contributing to the prior art in the form of a software product stored in a storage medium (such as ROM/RAM, magnetic disk, optical disk), comprising several instructions for causing a terminal (which may be a mobile phone, a computer, a server or a network device, etc.) to perform the method described in the embodiments of the present application.
The embodiments of the present application have been described above with reference to the accompanying drawings, but the present application is not limited to the above-described embodiments, which are merely illustrative and not restrictive, and many forms may be made by those of ordinary skill in the art without departing from the spirit of the present application and the scope of the protection of the claims, which fall within the protection of the present application.
Claims (9)
1. The database concurrent spin lock locking optimization method is characterized by comprising the following steps of:
pre-building a structure for spinning, wherein the structure comprises a first pointer and a variable, the first pointer points to another structure of the same type, and the variable is used for judging whether the structure is locked or not based on the value of the variable;
pre-configuring an array, wherein the array is used as a node container of a constructed structure body and can store a plurality of the structure bodies, each structure body is configured with a corresponding mark based on the array, the marks are used for indexing the structure bodies in the array, and the marks are in one-to-one correspondence with the positions of the corresponding structure bodies in a bitmap;
a pre-configured bitmap is used for marking the position and the state of a node owned by each process in the node container;
the locking process is as follows:
taking out the corresponding structure from the node container according to the target position in the bitmap;
judging whether a tail pointer is empty, if so, adding the structure body into a waiting linked list, and locking, wherein the tail pointer is used for pointing to the last element of the waiting linked list, and the waiting linked list is constructed based on each process needing to lock the structure body;
if the structure body is not empty, adding the structure body into a waiting chain table, spin waiting and locking.
2. The method for optimizing concurrent spin lock of a database according to claim 1, wherein the variable is an int-type variable, when the value is defined as 1, the process can be locked, when the value is 0, the process cannot be locked, and further comprising the following initialization process:
the variables that initialize each structure are 0 and in the event that the tail pointer is empty, the process may lock directly.
3. The database concurrent spin lock optimization method of claim 2, wherein the spin waiting further comprises the following:
and (3) determining whether locking is possible or not according to the current variable of the structural body at the specified interval.
4. The method for optimizing concurrent spin lock of claim 1, wherein a set value is configured according to the bitmap to characterize the occupancy state of nodes owned by each process in the node container;
the step of extracting the corresponding structure from the node container according to the target position in the bitmap comprises the following steps:
and setting the first unoccupied position in the bitmap, and taking out the corresponding structure body from the node container.
5. The method for optimizing the unlocking of the concurrent spin lock of the database is characterized by comprising the following steps of:
pre-building a structure for spinning, wherein the structure comprises a first pointer and a variable, the first pointer points to another structure of the same type, and the variable is used for judging whether the structure is locked or not based on the value of the variable;
pre-configuring an array, wherein the array is used as a node container of a constructed structure body and can store a plurality of the structure bodies, each structure body is configured with a corresponding mark based on the array, the marks are used for indexing the structure bodies in the array, and the marks are in one-to-one correspondence with the positions of the corresponding structure bodies in a bitmap;
a pre-configured bitmap is used for marking the position and the state of a node owned by each process in the node container;
the unlocking process is as follows:
taking out the corresponding structure from the node container according to the target position in the bitmap;
judging whether a first pointer of the structure body is empty or not, and unlocking a current process if the first pointer of the structure body is not empty;
if the tail pointer points to the structure body, judging whether the tail pointer points to the structure body, if so, setting the tail pointer to be empty, unlocking the current process, and if not, waiting for the next structure body to be successfully pointed back by the first pointer of the current structure body and then unlocking, wherein the tail pointer is used for pointing to the last element of a waiting linked list, and the waiting linked list is constructed based on each process needing to lock the structure body.
6. The method for optimizing database concurrent spin lock unlocking as claimed in claim 5, wherein the unlocking procedure further comprises:
and judging whether the tail pointer points to the structural body, if not, setting the variable in the structural body pointed by the first pointer of the current structural body.
7. The method for optimizing database concurrent spin lock unlocking as claimed in claim 5, wherein the unlocking procedure further comprises: and judging whether the structure body owned by the current process is the same as the structure body pointed by the tail pointer, and if so, setting the tail pointer to be empty.
8. A computer device, characterized in that it comprises a processor and a memory, said computer program stored thereon, which, when executed by the processor, implements the steps of the database concurrent spin lock locking optimization method according to any of claims 1 to 4, and/or implements the steps of the database concurrent spin lock unlocking optimization method according to any of claims 5 to 7.
9. A computer readable storage medium, characterized in that it has stored thereon a computer program which, when executed by a processor, implements the steps of the database concurrent spin lock locking optimization method according to any of claims 1 to 4 and/or implements the steps of the database concurrent spin lock unlocking optimization method according to any of claims 5 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310400837.4A CN116541402A (en) | 2023-04-14 | 2023-04-14 | Database concurrent spin locking and unlocking optimization method and equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310400837.4A CN116541402A (en) | 2023-04-14 | 2023-04-14 | Database concurrent spin locking and unlocking optimization method and equipment |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116541402A true CN116541402A (en) | 2023-08-04 |
Family
ID=87455229
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310400837.4A Pending CN116541402A (en) | 2023-04-14 | 2023-04-14 | Database concurrent spin locking and unlocking optimization method and equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116541402A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117539650A (en) * | 2023-10-10 | 2024-02-09 | 本原数据(北京)信息技术有限公司 | Decentralised record lock management method of data management system and related equipment |
-
2023
- 2023-04-14 CN CN202310400837.4A patent/CN116541402A/en active Pending
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117539650A (en) * | 2023-10-10 | 2024-02-09 | 本原数据(北京)信息技术有限公司 | Decentralised record lock management method of data management system and related equipment |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9658879B2 (en) | System and method for supporting buffer allocation in a shared memory queue | |
| TWI391818B (en) | Facilitating communication within shared memory environments using lock-free queues | |
| CN109117275B (en) | Account checking method and device based on data slicing, computer equipment and storage medium | |
| US7512621B2 (en) | Moving records between partitions | |
| CN116541402A (en) | Database concurrent spin locking and unlocking optimization method and equipment | |
| CN110413845B (en) | Resource storage method and device based on Internet of things operating system | |
| US20100042598A1 (en) | Coupled node tree backup/restore apparatus, backup/restore method, and program | |
| RU2585973C2 (en) | Method and apparatus for controlling locking operation of database system | |
| CN112789606A (en) | Data redistribution method, device and system | |
| US10838875B2 (en) | System and method for managing memory for large keys and values | |
| CN108139927A (en) | The routing based on action of affairs in online transaction processing system | |
| CN113778652A (en) | Task scheduling method and device, electronic equipment and storage medium | |
| CN110806942B (en) | Data processing method and device | |
| JP2010277467A (en) | Distributed data management system, data management apparatus, data management method and program | |
| CN112328632B (en) | Distributed two-level caching method and system | |
| CN117608871A (en) | Financial quotation subscription method, equipment and medium based on shared memory message queue | |
| CN113760858B (en) | Dynamic migration method and device for memory database data, computing equipment and storage equipment | |
| CN112905322B (en) | Resource locking method, computing device and computer storage medium | |
| US20070101339A1 (en) | System for and method of multi-dimensional resource management | |
| CN113742050B (en) | Method, device, computing equipment and storage medium for operating data object | |
| CN115599532A (en) | Index access method and computer cluster | |
| US20120209823A1 (en) | Method and system for managing database access contention | |
| CN117978730A (en) | Routing processing method and device | |
| CN112000695B (en) | Path query method, path query device, electronic equipment and computer readable storage medium | |
| JP5471023B2 (en) | Server, server control method, data distributed update system, and data distributed update program |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |