CN110764920A - Cache breakdown prevention method and annotation component thereof - Google Patents
Cache breakdown prevention method and annotation component thereof Download PDFInfo
- Publication number
- CN110764920A CN110764920A CN201910960329.5A CN201910960329A CN110764920A CN 110764920 A CN110764920 A CN 110764920A CN 201910960329 A CN201910960329 A CN 201910960329A CN 110764920 A CN110764920 A CN 110764920A
- Authority
- CN
- China
- Prior art keywords
- key
- cache
- locking
- lock
- corresponding data
- 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
Images
Classifications
-
- 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
- G06F9/524—Deadlock detection or avoidance
-
- 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/24—Querying
- G06F16/245—Query processing
- G06F16/2455—Query execution
- G06F16/24552—Database cache management
-
- 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/54—Interprogram communication
- G06F9/544—Buffers; Shared memory; Pipes
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Databases & Information Systems (AREA)
- Computational Linguistics (AREA)
- Data Mining & Analysis (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The application relates to a cache breakdown prevention method, which comprises the following steps: and (3) analyzing: analyzing the query request to obtain a key; a judging step: judging whether the cache has Key corresponding data; a reading step: if the corresponding data of Key exists in the cache, returning the corresponding data; and if not, locking the Key, executing a group of database read-write operations after the locking is successful, writing the results of the group of database read-write operations into the cache, removing the lock, and returning the results in the cache. In addition, still relate to an prevent buffer and puncture annotation subassembly, include: the analysis unit is used for analyzing the query request to obtain a key; the judging unit is used for judging whether the cache has the corresponding data of the Key; the reading unit returns the corresponding data of the Key if the corresponding data exists in the cache; and if not, locking the Key, executing a group of database read-write operations after the locking is successful, writing the results of the group of database read-write operations into the cache, removing the lock, and returning the results in the cache.
Description
Technical Field
The application belongs to the technical field of cache breakdown prevention design, and particularly relates to a cache breakdown prevention method and an annotation component thereof.
Background
The cache annotation component annotates the business method needing the cache service in a tangent plane-oriented mode, so that the reading and writing of the cache are realized, developers can transparently use the cache service without paying attention to the cache related development, and the business development can be concentrated on.
The spring3.x provides cache related annotations, and can realize a cache service in a tangent plane-oriented mode, which has the following disadvantages:
1) when the cache fails, a large number of concurrent requests are sent, and the database directly falls into the database to cause the crash of the database;
2) the functions required are various and the development and configuration are complex for all requirements;
3) and requiring version matching of relevant three-party software.
The present application is made in view of the above-mentioned drawbacks of the prior art.
Disclosure of Invention
It is an object of the present application to provide a method for preventing cache breakdown and annotation components thereof, which overcome or alleviate at least one of the disadvantages of the prior art.
The technical scheme of the application is as follows:
one aspect of the present application provides a method for preventing cache breakdown, including the following steps:
and (3) analyzing: analyzing the query request to obtain a key;
a judging step: judging whether the cache has Key corresponding data;
a reading step: if the corresponding data of Key exists in the cache, returning the corresponding data;
and if the cache does not have the data corresponding to the Key, locking the Key, executing a group of database read-write operations after the locking is successful, writing the results of the group of database read-write operations into the cache, removing the lock, and returning the results in the cache.
According to at least one embodiment of the present application, the analyzing step of the cache breakdown prevention method further includes: analyzing the query request to obtain the failure time of the Key;
and in the reading step, the result of the database reading and writing operation is written into the cache according to the Key and the failure time of the Key.
According to at least one embodiment of the present application, in the reading step of the above method for preventing cache punch-through, the lock removal specifically includes:
the lock is removed in finally.
According to at least one embodiment of the present application, in the reading step of the cache breakdown prevention method, if the Key is not successfully locked, an exception is thrown.
According to at least one embodiment of the present application, in the reading step of the above cache breakdown prevention method, the Key is locked, specifically:
and locking the Key by using Lock in the JDK.
According to at least one embodiment of the present application, in the reading step of the above cache breakdown prevention method, the Key is locked, specifically:
keys were locked using ConcurrentHashMap.
According to at least one embodiment of the present application, in the reading step of the above cache breakdown prevention method, the Key is locked, specifically:
and locking the Key by using a locking mechanism of the JVM.
Another aspect of the present application provides an annotation component for preventing cache breakdown, including:
the analysis unit is used for analyzing the query request to obtain a key;
a judging unit: the method is used for judging whether the cache has the corresponding data of Key;
a reading unit: if the corresponding data of Key exists in the cache, returning the corresponding data;
and if the cache does not have the data corresponding to the Key, locking the Key, executing a group of database read-write operations after the locking is successful, writing the results of the group of database read-write operations into the cache, removing the lock, and returning the results in the cache.
According to at least one embodiment of the present application, in the above-mentioned cache breakdown prevention annotation component, the parsing unit is further configured to parse the query request to obtain the failure time of the Key;
and the reading unit writes the result of the database read-write operation into the cache according to the Key and the failure time of the Key.
According to at least one embodiment of the present application, in the above-mentioned cache breakdown prevention annotation component, the reading unit removes the lock, specifically:
the lock is removed in finally.
According to at least one embodiment of the present application, in the above-mentioned cache breakdown prevention annotation component, if the Key is not successfully locked by the reading unit, an exception is thrown.
According to at least one embodiment of the present application, in the above-mentioned cache breakdown prevention annotation component, the reading unit locks the Key, specifically:
locking a Key by using Lock in JDK; alternatively, the first and second electrodes may be,
locking the key by using ConcurrentHashMap; alternatively, the first and second electrodes may be,
and locking the Key by using a locking mechanism of the JVM.
The application has at least the following beneficial technical effects:
the method comprises the steps of analyzing a query request to obtain a Key, locking the Key when data corresponding to the Key do not exist in a cache, executing a group of database read-write operations after the locking is successful, writing a result into the cache, removing the lock, and returning the result in the cache, so that a large number of concurrent requests can be prevented from directly falling into the cache, and the risk of cache breakdown is avoided. And if the data corresponding to the Key does not exist in the cache, locking the Key and executing a group of database read-write operations after the locking is successful, writing the result into the cache, removing the lock, and returning the result in the cache, so that a large number of concurrent requests can be prevented from directly falling into the cache, the risk of cache breakdown is avoided, and the granularity of the lock can be reduced by using the Key as the lock.
Drawings
Fig. 1 is a flowchart of a method for preventing cache breakdown according to an embodiment of the present disclosure;
fig. 2 is a schematic structural diagram of a cache breakdown prevention annotation component provided in an embodiment of the present application.
Detailed Description
The present application will be described in further detail with reference to the following drawings and examples. It is to be understood that the specific embodiments described herein are merely illustrative of the relevant application and are not limiting of the application. It should be noted that, for convenience of description, only the portions related to the present application are shown in the drawings.
The present application is described in further detail below with reference to fig. 1-2.
An embodiment of the present application provides a method for preventing cache breakdown, including the following steps:
and (3) analyzing: analyzing the query request to obtain a key;
a judging step: judging whether the cache has Key corresponding data;
a reading step: if the corresponding data of Key exists in the cache, returning the corresponding data;
and if the cache does not have the data corresponding to the Key, locking the Key, executing a group of database read-write operations after the locking is successful, writing the results of the group of database read-write operations into the cache, removing the lock, and returning the results in the cache.
For the method for preventing cache breakdown disclosed in the above embodiment, as can be understood by those skilled in the art, a Key is obtained by parsing an inquiry request, when data corresponding to the Key exists in a cache, the data is directly returned, if the data corresponding to the Key does not exist in the cache, a set of database read/write operations is executed after the Key is locked and the locking is successful, a result is written into the cache, and then the lock is removed and the result in the cache is returned, so that a large number of concurrent requests can be prevented from directly falling into the cache, and the risk of cache breakdown is avoided.
For the method for preventing cache breakdown disclosed in the above embodiment, as can be understood by those skilled in the art, when no Key corresponding data exists in the cache, only the successfully locked thread may read the database, and the other threads are in the lock waiting queue, until the locked thread releases the lock, 1 thread in the lock waiting queue can acquire the lock and enter the lock to run, and the program in the lock first queries the cache, and if the cache data is queried, it indicates that there are other threads to write data into the cache in the lock, and directly returns the data to the cache.
For the method for preventing cache breakdown disclosed in the above embodiment, those skilled in the art can also understand that keys are used as locks, so that the granularity of the locks can be reduced, and in addition, the method does not need to pay attention to the matching problem of relevant three-party software versions, can realize cache annotation and relevant tangent plane codes by itself, and directly uses jedis or other redis clients.
In some optional embodiments, the parsing step of the cache breakdown prevention method further includes: analyzing the query request to obtain the failure time of the Key;
and in the reading step, the result of the database reading and writing operation is written into the cache according to the Key and the failure time of the Key.
For the method for preventing cache breakdown disclosed in the above embodiment, as can be understood by those skilled in the art, in the reading step, the result of the database read/write operation is written into the cache according to the Key and the Key failure time, and the specific process may be that the result of the database read/write operation and the Key form a < Key, result > structure, and the structure is written into the cache, and the cache failure time is set at the same time.
In some optional embodiments, in the reading step of the above method for preventing cache breakdown, the lock removal specifically includes:
the lock is removed in finally, which guarantees removal of the lock so that other threads can acquire the lock.
For the method for preventing cache punchthrough disclosed in the above embodiments, it can be understood by those skilled in the art that finally is syntax in java, and in try { } catch () { } finally { } structure, finally indicates that execution is definitely to be performed.
In some optional embodiments, in the reading step of the cache breakdown prevention method, if the Key is not successfully locked, an exception is thrown, and a user is told to retry the locking, so that a failure caused by thread accumulation due to thread blockage is avoided.
For the method for preventing cache breakdown disclosed in the above embodiments, it can be understood by those skilled in the art that in a high concurrency scenario, a waiting mode for locking a thread queue cannot be used, so as to avoid a lot of thread accumulation, only a locked thread can perform a set of read-write operations on a database, and a thread that is not locked can directly throw an exception to terminate a program, so that only 1 thread runs a program for reading and writing a database at the same time by the same key, and there is no problem of a lot of thread accumulation.
In some optional embodiments, in the step of reading the cache breakdown prevention method, the Key is locked, specifically:
and the Lock in the JDK is used for locking the Key, so that the realization is simple and the degradation processing can be performed.
For the method for preventing cache breakdown disclosed in the above embodiment, those skilled in the art can understand that lock implementation is provided in Java language, for example, a renentratlock reentry lock, a renentratedreadwritelock, etc. lock a Key to implement degradation processing, and a part of programs can be closed and stopped in a high concurrency scenario, thereby ensuring normal execution of core services and core programs.
In some optional embodiments, in the reading step of the cache breakdown prevention method, the Key is locked, specifically:
the key is locked by using the ConcurrentHashMap, and a segmented lock is used in the key, so that higher throughput can be realized, the efficiency is high, and the degradation processing can be performed;
in some optional embodiments, in the reading step of the cache breakdown prevention method, the Key is locked, specifically:
the Key is locked by using a locking mechanism of the JVMs, and each JVM only allows one thread to perform library query.
For the method for preventing cache breakdown disclosed in the above embodiments, it can be understood by those skilled in the art that a synchronized keyword implementation lock is provided in the Java language, and the implementation is simple and convenient by modifying header information of an object to mark that the object is already locked.
In the method for preventing cache breakdown disclosed in the above embodiment, keys are locked in the reading step, and locked keys are avoided from being locked by synchronized, because the keys are only added into a queue waiting for lock taking, thread accumulation is caused in high concurrency, failure degradation processing cannot be performed, and the performance is low.
Another aspect of the embodiments of the present application provides an annotation component for preventing cache breakdown, including:
the analysis unit is used for analyzing the query request to obtain a key;
a judging unit: the method is used for judging whether the cache has the corresponding data of Key;
a reading unit: if the corresponding data of Key exists in the cache, returning the corresponding data;
and if the cache does not have the data corresponding to the Key, locking the Key, executing a group of database read-write operations after the locking is successful, writing the results of the group of database read-write operations into the cache, removing the lock, and returning the results in the cache.
For the cache breakdown prevention annotation component disclosed in the above embodiment, as can be understood by those skilled in the art, a Key is obtained by parsing an inquiry request, when data corresponding to the Key exists in a cache, the data is directly returned, if the data corresponding to the Key does not exist in the cache, a set of database read/write operations is executed after the Key is locked and the locking is successful, a result is written into the cache, and then the lock is removed and the result in the cache is returned, so that a large number of concurrent requests can be prevented from directly falling into the cache, and the risk of cache breakdown is avoided. In addition, the cache breakdown prevention annotation component does not need to pay attention to the matching problem of the relevant three software versions, and can realize cache annotation and relevant section codes by itself.
For the cache breakdown prevention annotation component disclosed in the above embodiment, it can be further understood by those skilled in the art that the component is simple and easy to use, and when the component is introduced into a project and business development is performed, a target method can have a cache service related function by simply annotating and specifying a key on a method having a cache service requirement.
According to at least one embodiment of the present application, in the above-mentioned cache breakdown prevention annotation component, the parsing unit is further configured to parse the query request to obtain the failure time of the Key;
the reading unit writes the result of the database read-write operation into the cache according to the Key and the failure time of the Key, and the specific process can be that the result of the database read-write operation and the Key form a structure of < Key, result > and are written into the cache, and the cache failure time is set at the same time.
In some optional embodiments, the reading unit removes the lock, specifically:
the lock is removed in finally, which guarantees removal of the lock so that other threads can acquire the lock.
In some optional embodiments, if the Key is not successfully locked, the reading unit in the cache breakdown prevention annotation component throws an exception termination program to tell a user to retry, so as to avoid a failure caused by thread accumulation due to thread blocking.
For the cache breakdown prevention annotation component disclosed in the above embodiment, it can be understood by those skilled in the art that in a high concurrency scenario, a waiting lock thread queue mode cannot be used, so as to avoid a large amount of thread accumulation, only a locked thread can perform a set of read-write operations on a database, and a thread that is not locked can directly throw an exception to terminate a program, so that only 1 thread runs a program for reading and writing the database at the same time in the same key, and there is no problem of large thread accumulation.
In some optional embodiments, the locking of the Key by the reading unit in the cache breakdown prevention annotation component specifically includes:
and the Lock in the JDK is used for locking the Key, so that the realization is simple and the degradation processing can be performed.
In some optional embodiments, the locking of the Key by the reading unit in the cache breakdown prevention annotation component specifically includes:
the key is locked by using the ConcurrentHashMap, and the key is internally locked by using the segmented lock, so that higher throughput can be realized, the efficiency is high, and the degradation processing can be performed.
In some optional embodiments, the locking of the Key by the reading unit in the cache breakdown prevention annotation component specifically includes:
and locking the Key by using a lock mechanism of the JVMs, wherein each JVM only allows one thread to perform a set of read-write operations on the database.
In the cache breakdown prevention annotation component disclosed in the above embodiment, the reading unit locks the Key, and locking the Key by using synchronized should be avoided, because the read unit only adds a queue waiting for lock fetching, thread accumulation is caused during high concurrency, failure degradation processing cannot be performed, and the performance is low.
So far, the technical solutions of the present application have been described in connection with the preferred embodiments shown in the drawings, but it is easily understood by those skilled in the art that the scope of the present application is obviously not limited to these specific embodiments. Equivalent changes or substitutions of related technical features can be made by those skilled in the art without departing from the principle of the present application, and the technical scheme after the changes or substitutions will fall into the protection scope of the present application.
Claims (10)
1. A method for preventing cache breakdown is characterized by comprising the following steps:
and (3) analyzing: analyzing the query request to obtain a key;
a judging step: judging whether the cache has Key corresponding data;
a reading step: if the corresponding data of Key exists in the cache, returning the corresponding data;
and if the cache does not have the data corresponding to the Key, locking the Key, executing a group of database read-write operations after the locking is successful, writing the results of the group of database read-write operations into the cache, removing the lock, and returning the results in the cache.
2. The method of claim 1,
the step of resolving further comprises: analyzing the query request to obtain the failure time of the Key;
and in the reading step, the result of the database reading and writing operation is written into a cache according to the Key and the failure time of the Key.
3. The method of claim 1,
in the reading step, the removing the lock specifically includes:
the lock is removed in finally.
4. The method of claim 1,
in the reading step, if the Key is not successfully locked, exception is thrown.
5. The method of claim 1,
in the reading step, the Key is locked, specifically:
locking a Key by using Lock in JDK; alternatively, the first and second electrodes may be,
locking the key by using ConcurrentHashMap; alternatively, the first and second electrodes may be,
and locking the Key by using a locking mechanism of the JVM.
6. An anti-cache punchthrough annotation component, comprising:
the analysis unit is used for analyzing the query request to obtain a key;
a judging unit: the method is used for judging whether the cache has the corresponding data of Key;
a reading unit: if the corresponding data of Key exists in the cache, returning the corresponding data;
and if the cache does not have the data corresponding to the Key, locking the Key, executing a group of database read-write operations after the locking is successful, writing the results of the group of database read-write operations into the cache, removing the lock, and returning the results in the cache.
7. The cache breakdown prevention annotation component of claim 6,
the analysis unit is also used for analyzing the query request to obtain the failure time of the Key;
and the reading unit writes the result of the database read-write operation into the cache according to the Key and the failure time of the Key.
8. The cache breakdown prevention annotation component of claim 6,
the reading unit removes a lock, specifically:
the lock is removed in finally.
9. The cache breakdown prevention annotation component of claim 6,
and if the Key is not successfully locked by the reading unit, throwing the exception.
10. The cache breakdown prevention annotation component of claim 6,
the reading unit locks the Key, and specifically comprises the following steps:
locking a Key by using Lock in JDK; alternatively, the first and second electrodes may be,
locking the key by using ConcurrentHashMap; alternatively, the first and second electrodes may be,
and locking the Key by using a locking mechanism of the JVM.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910960329.5A CN110764920A (en) | 2019-10-10 | 2019-10-10 | Cache breakdown prevention method and annotation component thereof |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910960329.5A CN110764920A (en) | 2019-10-10 | 2019-10-10 | Cache breakdown prevention method and annotation component thereof |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN110764920A true CN110764920A (en) | 2020-02-07 |
Family
ID=69331547
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910960329.5A Pending CN110764920A (en) | 2019-10-10 | 2019-10-10 | Cache breakdown prevention method and annotation component thereof |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110764920A (en) |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111522836A (en) * | 2020-04-22 | 2020-08-11 | 杭州海康威视系统技术有限公司 | Data query method and device, electronic equipment and storage medium |
| CN111813792A (en) * | 2020-06-22 | 2020-10-23 | 上海悦易网络信息技术有限公司 | Method and equipment for updating cache data in distributed cache system |
| CN112035509A (en) * | 2020-08-28 | 2020-12-04 | 康键信息技术（深圳）有限公司 | Medical cache data query method, device, equipment and storage medium |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| DE102006047656A1 (en) * | 2005-10-27 | 2007-05-03 | Hewlett-Packard Development Co., L.P., Houston | Storage control system e.g. for computer storage module breakdown, has cache memory with replacement or substitute storage positions |
| CN107451144A (en) * | 2016-05-31 | 2017-12-08 | 北京京东尚科信息技术有限公司 | Cache read method and device |
| CN110019359A (en) * | 2017-10-16 | 2019-07-16 | 阿里巴巴集团控股有限公司 | A kind of method, apparatus and system for preventing caching from puncturing |
-
2019
- 2019-10-10 CN CN201910960329.5A patent/CN110764920A/en active Pending
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| DE102006047656A1 (en) * | 2005-10-27 | 2007-05-03 | Hewlett-Packard Development Co., L.P., Houston | Storage control system e.g. for computer storage module breakdown, has cache memory with replacement or substitute storage positions |
| CN107451144A (en) * | 2016-05-31 | 2017-12-08 | 北京京东尚科信息技术有限公司 | Cache read method and device |
| CN110019359A (en) * | 2017-10-16 | 2019-07-16 | 阿里巴巴集团控股有限公司 | A kind of method, apparatus and system for preventing caching from puncturing |
Non-Patent Citations (3)
| Title |
|---|
| 何其小静: "Redis缓存穿透、缓存雪崩、并发问题分析与解决方案", 《HTTPS://WWW.CNBLOGS.COM/HEQIYOUJING/P/11142698.HTML》 * |
| 杨光彩-SUNNY: "Redis--缓存穿透、缓存击穿、雪崩", 《HTTPS://BLOG.CSDN.NET/SUNNY5319/ARTICLE/DETAILS/94292388》 * |
| 田玉娟等: "《ITO之路-奔跑在Java的路上》", 31 October 2010 * |
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111522836A (en) * | 2020-04-22 | 2020-08-11 | 杭州海康威视系统技术有限公司 | Data query method and device, electronic equipment and storage medium |
| CN111522836B (en) * | 2020-04-22 | 2023-10-10 | 杭州海康威视系统技术有限公司 | Data query method and device, electronic equipment and storage medium |
| CN111813792A (en) * | 2020-06-22 | 2020-10-23 | 上海悦易网络信息技术有限公司 | Method and equipment for updating cache data in distributed cache system |
| CN112035509A (en) * | 2020-08-28 | 2020-12-04 | 康键信息技术（深圳）有限公司 | Medical cache data query method, device, equipment and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7966459B2 (en) | System and method for supporting phased transactional memory modes | |
| US8396831B2 (en) | Optimistic serializable snapshot isolation | |
| US11556396B2 (en) | Structure linked native query database management system and methods | |
| JP4436036B2 (en) | Information processing apparatus, trace processing method, program, and recording medium | |
| US8051409B1 (en) | Monitoring memory accesses for multiple computer processes | |
| US8533699B2 (en) | System and method for optimizing a code section by forcing a code section to be executed atomically | |
| CN110764920A (en) | Cache breakdown prevention method and annotation component thereof | |
| US8533663B2 (en) | System and method for utilizing available best effort hardware mechanisms for supporting transactional memory | |
| US11132294B2 (en) | Real-time replicating garbage collection | |
| US20100122073A1 (en) | Handling exceptions in software transactional memory systems | |
| US8386720B2 (en) | Method for allowing exclusive access to shared data | |
| Turcu et al. | Hyflow2: A high performance distributed transactional memory framework in scala | |
| EP2507704B1 (en) | Lock resolution for distributed durable instances | |
| Artho et al. | Using block-local atomicity to detect stale-value concurrency errors | |
| US20050235120A1 (en) | System and method for performing garbage collection on a large heap | |
| Volos et al. | xCalls: Safe I/O in memory transactions | |
| US10891214B2 (en) | Transferring a debug configuration amongst carrier threads for debugging a carried thread | |
| Turcu et al. | On open nesting in distributed transactional memory | |
| Lee et al. | Unified debugging of distributed systems with recon | |
| US11269759B2 (en) | Intelligent regression fortifier | |
| US8635331B2 (en) | Distributed workflow framework | |
| KR102042304B1 (en) | Lock free streaming of executable code data | |
| CN113703831A (en) | Method, device, equipment and medium for realizing service idempotency | |
| CN115705294A (en) | Method, device, electronic equipment and medium for acquiring function call information | |
| KR20170130911A (en) | Method for Performing Real-Time Changed Data Publish Service of DDS-DBMS Integration Tool |
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 | ||
| TA01 | Transfer of patent application right |
Effective date of registration: 20211021 Address after: No. 306, floor 3, No. 1, District 5, anzhen Xili, Chaoyang District, Beijing 100029 Applicant after: BEIJING YUNSHANSHIJIE INFORMATION TECHNOLOGY Co.,Ltd. Address before: 402, floor 4, No. 1, District 5, anzhen Xili, Chaoyang District, Beijing 100029 Applicant before: Beijing Meixian Technology Co.,Ltd. |
|
| TA01 | Transfer of patent application right | ||
| RJ01 | Rejection of invention patent application after publication |
Application publication date: 20200207 |
|
| RJ01 | Rejection of invention patent application after publication |