Annotation-Based Microservice Locking for Consistent Resource Access
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing distributed computing systems face challenges in managing locks for microservices due to complex network latency, coordination, fault tolerance, and scalability, leading to inconsistent and inefficient resource access control.
Innovation Solution
A declarative methodology using designated annotations in Java-based programming to enforce mutual exclusion semantics, ensuring reliable and efficient locking by managing lock requests and releases through annotations applied to code segments, reducing development and management efforts.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If traditional distributed locking mechanisms are used to ensure data consistency and prevent race conditions, then reliability is improved, but device complexity and coordination overhead increase significantly
Solution Approach 1:
The patent extracts the locking logic from complex distributed coordination systems and embeds it directly into the database engine through annotations. This removes the need for external distributed locking mechanisms while maintaining data consistency, thereby reducing device complexity while preserving reliability.
Solution Approach 2:
The patent introduces an annotation-based intermediary layer that sits between the application code and the database engine. This intermediary automatically generates and manages locking semantics without requiring complex distributed coordination, simplifying the system while ensuring data consistency.
2Reliability
If distributed locks are implemented across multiple nodes to coordinate resource access, then reliability is improved, but network latency and coordination overhead increase
Solution Approach 1:
The patent extracts the coordination function from the network layer and embeds it into the database engine itself. By using annotations that generate locking logic locally at each node, the system eliminates network round-trips for lock coordination while maintaining reliable resource access control.
Solution Approach 2:
Each database node becomes self-sufficient by automatically generating locking semantics through annotations. Nodes independently manage their own locking without requiring network coordination, eliminating network latency while ensuring consistent resource access control across the distributed system.
3Reliability
If manual lock management is implemented to ensure proper locking semantics, then reliability is improved, but ease of operation and development effort decrease
Solution Approach 1:
The patent enables the system to automatically generate and manage locking semantics through annotations on data access methods. The framework itself handles lock acquisition, release, and management without requiring manual intervention, thereby maintaining reliability while significantly improving ease of operation.
Solution Approach 2:
The patent uses annotations to pre-define locking semantics at the code level before runtime. This preliminary configuration allows the system to automatically generate appropriate locking logic without requiring manual lock management during operation, ensuring correctness while reducing operational effort.
4Reliability
If distributed locking is implemented to handle fault tolerance and node failures, then reliability is improved, but device complexity and coordination overhead increase
Solution Approach 1:
The patent extracts fault tolerance handling from complex distributed coordination systems and embeds it into the database engine's annotation-based locking mechanism. This allows the system to handle node failures and maintain reliability without requiring complex external coordination systems.
Data Source
AI summary
Ephemeral distributed locking in microservice systems is disclosed, A disclosed example system to manage microservices of a shared resource system includes interface circuitry, programmable circuitry, machine readable instructions to cause the programmable circuitry to: permit a first container to lock a microservice based on an annotation of the first container, the annotation corresponding to a request for utilization of locking semantics to lock the microservice, after the microservice is locked for use by the first container, prevent a second container requesting utilization of the locking semantics to lock the microservice based on the microservice being locked to the first container, and, after expiration of a time period, release the microservice from being locked for use by the first container.