valarpirai

How to Solve Race Conditions in a Booking System

Database isolation refers to the level of isolation between concurrent transactions in a database. Isolation levels control the visibility and accessibility of data to concurrent transactions and can affect the occurrence of race conditions in a database. If your isolation level is not “serializable” - there is a possibility of race conditions.

The Serializable isolation level provides the strictest transaction isolation. This level emulates serial transaction execution for all committed transactions; as if transactions had been executed one after another, serially, rather than concurrently

Race conditions

Example of Race condition, Hotel room booking and movie ticket booking etc

valarpirai

#!/usr/bin/env python

#
# Converts any integer into a base [BASE] number. I have chosen 62
# as it is meant to represent the integers using all the alphanumeric
# characters, [no special characters] = {0..9}, {A..Z}, {a..z}
#
# I plan on using this to shorten the representation of possibly long ids,
# a la url shortenters
#

valarpirai

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Example {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newCachedThreadPool();

        int max_thread = 1000;
        Increment eg = new Increment();

valarpirai

valarpirai

Scaling your API with rate limiters

The following are examples of the four types rate limiters discussed in the accompanying blog post. In the examples below I've used pseudocode-like Ruby, so if you're unfamiliar with Ruby you should be able to easily translate this approach to other languages. Complete examples in Ruby are also provided later in this gist.

In most cases you'll want all these examples to be classes, but I've used simple functions here to keep the code samples brief.

Request rate limiter

This uses a basic token bucket algorithm and relies on the fact that Redis scripts execute atomically. No other operations can run between fetching the count and writing the new count.

valarpirai

Golden rules for System Design

👉 For a Read-Heavy System - Consider using a Cache.

👉 For a Write-Heavy System - Use Message Queues for async processing

👉 For a Low Latency Requirement - Consider using a Cache and CDN.

👉 If we need a system to be ACID complaint, we should go for RDBMS or SQL Database

valarpirai

const credentials = require('./credentials.json');

const googleAuth = require('google-oauth-jwt')
const config = {
  "private_key": credentials.private_key,
  "client_email": credentials.client_email
}
const getToken = () => {
  return new Promise((resolve) => {
    googleAuth.authenticate(

valarpirai

class TrieNode
  attr_accessor :childrens, :leaf
  def initialize
    self.childrens = {}
    self.leaf = false
  end
end

class WordDictionary

valarpirai

class TrieNode
  attr_accessor :childrens, :leaf
  def initialize
    self.childrens = {}
    self.leaf = false
  end
end

class WordDictionary

valarpirai

MAX_LINE_LENGTH = 80

# Gets long string as input
# Retruns array of splitted strings with (1/3)

def split_msg(message)
  length = message.length

  return [message] if length < MAX_LINE_LENGTH