Suppose we are in an environment where only one instance is running in production. We want to do an account update and synchronise the transaction where we are doing the update. This can easily be achieved with the help of Reentrant Locks api\u2019s of java, as shown below.<\/p>\n
@Service<\/span>\r\n@RequiredArgsConstructor<\/span>\r\n@Slf4j<\/span>\r\npublic<\/span> class<\/span> AccountService<\/span> {\r\nprivate<\/span> final<\/span> AccountRepository accountRepository;\r\nprivate<\/span> ReentrantLock<\/span> lock<\/span> =<\/span> new<\/span> ReentrantLock<\/span>();\r\npublic<\/span> void<\/span> updateAccount<\/span>(Long id)<\/span> throws<\/span> InterruptedException {\r\nboolean<\/span> lockAquired<\/span> =<\/span> lock.tryLock();\r\nif<\/span>(lockAquired){\r\ntry<\/span>{\r\nlog.info(\"lock taken\"<\/span>);\r\nAccount<\/span> account<\/span> =<\/span> accountRepository.findById(id).get();\r\naccount.setBalance(account.getBalance() + 100L<\/span>);\r\nThread.sleep(20_000<\/span>);\r\naccountRepository.save(account);\r\n}\r\nfinally<\/span> {\r\nlock.unlock();\r\n}\r\n}\r\n}\r\n}<\/pre>\nNow consider the scenario where multiple instances of this service are running in production, which is quite common in today\u2019s microservice environment. The above method fails as lock is applicable for each instance and we want some kind of mechanism to take a lock on something common across all instances of this microservice. What could be better than a table in our database which is common across all instances. By taking this into cue, Spring has provided distributed locks. Let see how we can configure our distributed locks in Spring Boot.<\/p>\n
We would require the below dependencies in our pom.xml.<\/p>\n
<dependency<\/span>><\/span>\r\n<groupId<\/span>><\/span>org.springframework.boot<\/groupId<\/span>><\/span>\r\n<artifactId<\/span>><\/span>spring-boot-starter-integration<\/artifactId<\/span>><\/span>\r\n<\/dependency<\/span>><\/span>\r\n<dependency<\/span>><\/span>\r\n<groupId<\/span>><\/span>org.springframework.integration<\/groupId<\/span>><\/span>\r\n<artifactId<\/span>><\/span>spring-integration-jdbc<\/artifactId<\/span>><\/span>\r\n<\/dependency<\/span>><\/span>\r\n<dependency<\/span>><\/span>\r\n<groupId<\/span>><\/span>org.springframework.boot<\/groupId<\/span>><\/span>\r\n<artifactId<\/span>><\/span>spring-boot-starter-jdbc<\/artifactId<\/span>><\/span>\r\n<\/dependency<\/span>><\/span><\/pre>\nIn our configuration file, we need following beans to be setup<\/p>\n
@Bean<\/span>\r\npublic<\/span> DefaultLockRepository DefaultLockRepository<\/span>(DataSource dataSource)<\/span>{\r\nreturn<\/span> new<\/span> DefaultLockRepository<\/span>(dataSource);\r\n}\r\n\r\n@Bean<\/span>\r\npublic<\/span> JdbcLockRegistry jdbcLockRegistry<\/span>(LockRepository lockRepository)<\/span>{\r\nreturn<\/span> new<\/span> JdbcLockRegistry<\/span>(lockRepository);\r\n}\r\n\r\nNow, coming back to our service, we need to inject first LockRegistry\r\n\r\nprivate<\/span> final<\/span> LockRegistry lockRegistry; \/\/ this is injected automatically if we use @RequiredArgsConstructor of lombok<\/span>\r\n\r\nprivate<\/span> final<\/span> JdbcTemplate jdbcTemplate;\r\n\r\npublic<\/span> void<\/span> updateAccountViaDistributedLocks<\/span>(Long id)<\/span> throws<\/span> InterruptedException {\r\nvar<\/span> lock<\/span> =<\/span> lockRegistry.obtain(String.valueOf(id));\r\nboolean<\/span> lockAquired<\/span> =<\/span> lock.tryLock();\r\nif<\/span>(lockAquired){\r\ntry<\/span>{\r\nlog.info(\"lock taken\"<\/span>);\r\nAccount<\/span> account<\/span> =<\/span> accountRepository.findById(id).get();\r\naccount.setBalance(account.getBalance() + 100L<\/span>);\r\nThread.sleep(20_000<\/span>);\r\naccountRepository.save(account);\r\n}\r\nfinally<\/span> {\r\nlock.unlock();\r\n}\r\n}\r\n}\r\n\r\n<\/pre>\nWe have first got the lock on id, and this is a distributed lock which is being taken on INT_LOCK table.<\/p>\n
We need to create a table in sql database with the following script.<\/p>\n
CREATE<\/span> TABLE<\/span> `INT_LOCK` (\r\n`LOCK_KEY` char<\/span>(36<\/span>) NOT<\/span> NULL<\/span>,\r\n`REGION` varchar<\/span>(100<\/span>) NOT<\/span> NULL<\/span>,\r\n`CLIENT_ID` char<\/span>(36<\/span>) DEFAULT<\/span> NULL<\/span>,\r\n`CREATED_DATE` timestamp<\/span> NOT<\/span> NULL<\/span>,\r\nPRIMARY<\/span> KEY (`LOCK_KEY`,`REGION`)\r\n) ENGINE=<\/span>InnoDB DEFAULT<\/span> CHARSET=<\/span>utf8mb4 COLLATE<\/span>=<\/span>utf8mb4_0900_ai_ci;<\/pre>\nNow let\u2019s create the apis for demo purposes. We have created two apis one for update account via simple locks and other with distributed locks<\/p>\n
@PostMapping<\/span>(\"\/updateAccount\/{id}\"<\/span>)\r\npublic void updateAccount<\/span>(@PathVariable<\/span>(\"id\"<\/span>) Long id) throws InterruptedException {\r\naccountService<\/span>.updateAccount<\/span>(id);\r\n}\r\n\r\n@PostMapping<\/span>(\"\/updateAccountViaDistributedLocks\/{id}\"<\/span>)\r\npublic<\/span> void<\/span> updateAccountViaDistributedLocks<\/span>(@PathVariable<\/span>(\"id\"<\/span>) Long id) throws<\/span> InterruptedException<\/span> {\r\naccountService<\/span>.updateAccountViaDistributedLocks<\/span>(id);\r\n}<\/pre>\nLet\u2019s see our application.yaml<\/p>\n
spring:<\/span>\r\ndatasource:<\/span>\r\ndriver-class-name:<\/span> com.mysql.cj.jdbc.Driver<\/span>\r\nmaxIdle:<\/span> 1<\/span>\r\nurl:<\/span> jdbc:mysql:\/\/localhost:3306\/distributed_locks<\/span>\r\ntestWhileIdle:<\/span> true<\/span>\r\nusername:<\/span> root<\/span>\r\npassword:<\/span> root1234<\/span>\r\njpa:<\/span>\r\ndatabase:<\/span> mysql<\/span>\r\ngenerate-ddl:<\/span> true<\/span>\r\nproperties:<\/span>\r\nhibernate:<\/span>\r\ndialect:<\/span> org.hibernate.dialect.MySQL55Dialect<\/span>\r\njdbc:<\/span>\r\ntime_zone:<\/span> UTC<\/span>\r\nhibernate:<\/span>\r\nddl-auto:<\/span> update<\/span>\r\nshow-sql:<\/span> true<\/span>\r\nserver:<\/span>\r\nport:<\/span> 0<\/span><\/pre>\nWe have server.port as 0 so that we can have multiple instances of our service running on random ports.<\/p>\n
Testing<\/strong><\/p>\nRun the below curls which is using simple locks.<\/p>\n
curl --location --request POST 'localhost:57841\/monolith\/updateAccount\/1'<\/span>\r\ncurl --location --request POST 'localhost:57896\/monolith\/updateAccount\/1'<\/span><\/pre>\nIf we check the data in our Account table we would see that our data will be updated once only even though we have hit the apis twice. Our database is in a state we do not know(inconsistent state).<\/p>\n
Now, hit the below two curls for which are using distributed locks<\/p>\n
curl --location --request POST 'localhost:57841\/monolith\/updateAccountViaDistributedLocks\/1'<\/span>\r\ncurl --location --request POST 'localhost:57896\/monolith\/updateAccountViaDistributedLocks\/1'<\/span><\/pre>\nWe would see that our account has been updated twice properly. The database will be in a consistent state.<\/p>\n
That\u2019s all from my side. Please find the the link of this project on Github:<\/p>\n
https:\/\/github.com\/anilgola90\/distributedlock<\/p>\n
\n