ukazap · September 27, 2018 00:44 · Aug 27, 2016 · Aug 27, 2016 · Aug 27, 2016 · Aug 27, 2016
diff --git a/rails_locking.md b/rails_locking.md
@@ -18,7 +18,7 @@ or you can also use with_lock method to select and lock the record.
 ``` ruby
 user = User.find(1)
 user.with_lock do #lock the record
-  # you can run other code herer.
+  # you can run other code here.
   user.name = 'ryan'
   user.save!
 end

diff --git a/rails_locking.md b/rails_locking.md
@@ -1,6 +1,6 @@
 **Optimistic Locking** assumes that a database transaction conflict is very rare to happen. It uses a version number of the record to track the changes. It raise an error when other user tries to update the record while it is lock.
 
-usage:
+*usage*
 
 Just add a lock_version column to the table you want to place the lock and Rails will automatically check this column before updating the record.
 

diff --git a/rails_locking.md b/rails_locking.md
@@ -18,6 +18,7 @@ or you can also use with_lock method to select and lock the record.
 ``` ruby
 user = User.find(1)
 user.with_lock do #lock the record
+  # you can run other code herer.
   user.name = 'ryan'
   user.save!
 end

diff --git a/rails_locking.md b/rails_locking.md
@@ -19,7 +19,7 @@ or you can also use with_lock method to select and lock the record.
 user = User.find(1)
 user.with_lock do #lock the record
   user.name = 'ryan'
-  user.save
+  user.save!
 end
 ```
 

diff --git a/rails_locking.md b/rails_locking.md
@@ -7,24 +7,21 @@ Just add a lock_version column to the table you want to place the lock and Rails
 **Pessimistic locking** assumes that database transaction conflict is very likely to happen. It locks the record until the transaction is done. If the record is currently lock and the other user make a transaction, that second transaction will wait until the lock in first transaction is release.
 
 *usage*
-
-`user = User.lock.find(1) #lock the record`
-
-`user.name = 'ryan'`
-
-`user.save! #release the lock`
+``` ruby
+user = User.lock.find(1) #lock the record
+user.name = 'ryan'
+user.save! #release the lock
+```
 
 or you can also use with_lock method to select and lock the record.
 
-`user = User.find(1)`
-
-`user.with_lock do #lock the record`
-
-`  user.name = 'ryan'`
-
-`  user.save`
-
-`end`
+``` ruby
+user = User.find(1)
+user.with_lock do #lock the record
+  user.name = 'ryan'
+  user.save
+end
+```
 
 ### Reference
 * https://www.ibm.com/support/knowledgecenter/SSPK3V_7.0.0/com.ibm.swg.im.soliddb.sql.doc/doc/pessimistic.vs.optimistic.concurrency.control.html

diff --git a/rails_locking.md b/rails_locking.md
@@ -9,15 +9,21 @@ Just add a lock_version column to the table you want to place the lock and Rails
 *usage*
 
 `user = User.lock.find(1) #lock the record`
+
 `user.name = 'ryan'`
+
 `user.save! #release the lock`
 
 or you can also use with_lock method to select and lock the record.
 
 `user = User.find(1)`
+
 `user.with_lock do #lock the record`
+
 `  user.name = 'ryan'`
+
 `  user.save`
+
 `end`
 
 ### Reference

diff --git a/locking.md b/locking.md
@@ -1,11 +0,0 @@
-Optimistic Locking assumes that a database transaction conflict is very rare to happen.
-
-Pessimistic locking assumes that database transaction conflict is very likely to happen.
-
-
-usage:
-
-### Reference
-* http://api.rubyonrails.org/classes/ActiveRecord/Locking/Optimistic.html
-* http://api.rubyonrails.org/classes/ActiveRecord/Locking/Pessimistic.html
-* http://thelazylog.com/understanding-locking-in-rails-activerecord/

diff --git a/rails_locking.md b/rails_locking.md
@@ -0,0 +1,27 @@
+**Optimistic Locking** assumes that a database transaction conflict is very rare to happen. It uses a version number of the record to track the changes. It raise an error when other user tries to update the record while it is lock.
+
+usage:
+
+Just add a lock_version column to the table you want to place the lock and Rails will automatically check this column before updating the record.
+
+**Pessimistic locking** assumes that database transaction conflict is very likely to happen. It locks the record until the transaction is done. If the record is currently lock and the other user make a transaction, that second transaction will wait until the lock in first transaction is release.
+
+*usage*
+
+`user = User.lock.find(1) #lock the record`
+`user.name = 'ryan'`
+`user.save! #release the lock`
+
+or you can also use with_lock method to select and lock the record.
+
+`user = User.find(1)`
+`user.with_lock do #lock the record`
+`  user.name = 'ryan'`
+`  user.save`
+`end`
+
+### Reference
+* https://www.ibm.com/support/knowledgecenter/SSPK3V_7.0.0/com.ibm.swg.im.soliddb.sql.doc/doc/pessimistic.vs.optimistic.concurrency.control.html
+* http://api.rubyonrails.org/classes/ActiveRecord/Locking/Optimistic.html
+* http://api.rubyonrails.org/classes/ActiveRecord/Locking/Pessimistic.html
+* http://thelazylog.com/understanding-locking-in-rails-activerecord/
diff --git a/gistfile1.txt → locking.md b/gistfile1.txt → locking.md
diff --git a/gistfile1.txt b/gistfile1.txt
@@ -0,0 +1,11 @@
+Optimistic Locking assumes that a database transaction conflict is very rare to happen.
+
+Pessimistic locking assumes that database transaction conflict is very likely to happen.
+
+
+usage:
+
+### Reference
+* http://api.rubyonrails.org/classes/ActiveRecord/Locking/Optimistic.html
+* http://api.rubyonrails.org/classes/ActiveRecord/Locking/Pessimistic.html
+* http://thelazylog.com/understanding-locking-in-rails-activerecord/