diff --git a/RxSwift/Concurrency/AsyncLock.swift b/RxSwift/Concurrency/AsyncLock.swift
index 64b55ba6..86664d25 100644
--- a/RxSwift/Concurrency/AsyncLock.swift
+++ b/RxSwift/Concurrency/AsyncLock.swift
@@ -21,25 +21,25 @@ That means that enqueued work could possibly be executed later on a different th
 class AsyncLock : Disposable {
     typealias Action = () -> Void
     
-    private var lock = NSRecursiveLock()
+    private var _lock = NSRecursiveLock()
     
-    private var queue: Queue<Action> = Queue(capacity: 2)
-    private var isAcquired: Bool = false
-    private var hasFaulted: Bool = false
+    private var _queue: Queue<Action> = Queue(capacity: 2)
+    private var _isAcquired: Bool = false
+    private var _hasFaulted: Bool = false
     
     init() {
         
     }
     
     func wait(action: Action) {
-        let isOwner = lock.calculateLocked { () -> Bool in
-            if self.hasFaulted {
+        let isOwner = _lock.calculateLocked { () -> Bool in
+            if _hasFaulted {
                 return false
             }
             
-            self.queue.enqueue(action)
-            let isOwner = !self.isAcquired
-            self.isAcquired = true
+            _queue.enqueue(action)
+            let isOwner = !_isAcquired
+            _isAcquired = true
             
             return isOwner
         }
@@ -49,12 +49,12 @@ class AsyncLock : Disposable {
         }
         
         while true {
-            let nextAction = lock.calculateLocked { () -> Action? in
-                if self.queue.count > 0 {
-                    return self.queue.dequeue()
+            let nextAction = _lock.calculateLocked { () -> Action? in
+                if _queue.count > 0 {
+                    return _queue.dequeue()
                 }
                 else {
-                    self.isAcquired = false
+                    _isAcquired = false
                     return nil
                 }
             }
@@ -69,9 +69,9 @@ class AsyncLock : Disposable {
     }
     
     func dispose() {
-        lock.performLocked { oldState in
-            self.queue = Queue(capacity: 0)
-            self.hasFaulted = true
+        _lock.performLocked { oldState in
+            _queue = Queue(capacity: 0)
+            _hasFaulted = true
         }
     }
 }
\ No newline at end of file
diff --git a/RxSwift/Disposables/CompositeDisposable.swift b/RxSwift/Disposables/CompositeDisposable.swift
index ccedce97..ac772c13 100644
--- a/RxSwift/Disposables/CompositeDisposable.swift
+++ b/RxSwift/Disposables/CompositeDisposable.swift
@@ -14,14 +14,14 @@ Represents a group of disposable resources that are disposed together.
 public class CompositeDisposable : DisposeBase, Disposable, Cancelable {
     public typealias DisposeKey = Bag<Disposable>.KeyType
     
-    private var lock = SpinLock()
+    private var _lock = SpinLock()
     
     // state
     private var disposables: Bag<Disposable>? = Bag()
 
     public var disposed: Bool {
         get {
-            return self.lock.calculateLocked {
+            return _lock.calculateLocked {
                 return disposables == nil
             }
         }
@@ -34,8 +34,8 @@ public class CompositeDisposable : DisposeBase, Disposable, Cancelable {
      Initializes a new instance of composite disposable with the specified number of disposables.
     */
     public init(_ disposable1: Disposable, _ disposable2: Disposable) {
-        self.disposables!.insert(disposable1)
-        self.disposables!.insert(disposable2)
+        disposables!.insert(disposable1)
+        disposables!.insert(disposable2)
     }
     
     /**
@@ -66,7 +66,7 @@ public class CompositeDisposable : DisposeBase, Disposable, Cancelable {
     public func addDisposable(disposable: Disposable) -> DisposeKey? {
         // this should be let
         // bucause of compiler bug it's var
-        let key  = self.lock.calculateLocked { () -> DisposeKey? in
+        let key  = _lock.calculateLocked { () -> DisposeKey? in
             return disposables?.insert(disposable)
         }
         
@@ -82,7 +82,7 @@ public class CompositeDisposable : DisposeBase, Disposable, Cancelable {
     */
     public var count: Int {
         get {
-            return self.lock.calculateLocked {
+            return _lock.calculateLocked {
                 return disposables?.count ?? 0
             }
         }
@@ -94,7 +94,7 @@ public class CompositeDisposable : DisposeBase, Disposable, Cancelable {
     - parameter disposeKey: Key used to identify disposable to be removed.
     */
     public func removeDisposable(disposeKey: DisposeKey) {
-        let disposable = self.lock.calculateLocked { () -> Disposable? in
+        let disposable = _lock.calculateLocked { () -> Disposable? in
             return disposables?.removeKey(disposeKey)
         }
         
@@ -107,7 +107,7 @@ public class CompositeDisposable : DisposeBase, Disposable, Cancelable {
     Disposes all disposables in the group and removes them from the group.
     */
     public func dispose() {
-        let oldDisposables = self.lock.calculateLocked { () -> Bag<Disposable>? in
+        let oldDisposables = _lock.calculateLocked { () -> Bag<Disposable>? in
             let disposeBag = disposables
             self.disposables = nil
             
diff --git a/RxSwift/Disposables/DisposeBag.swift b/RxSwift/Disposables/DisposeBag.swift
index 867aa91e..28f6c09e 100644
--- a/RxSwift/Disposables/DisposeBag.swift
+++ b/RxSwift/Disposables/DisposeBag.swift
@@ -33,11 +33,11 @@ In case explicit disposal is necessary, there is also `CompositeDisposable`.
 */
 public class DisposeBag: DisposeBase {
     
-    private var lock = SpinLock()
+    private var _lock = SpinLock()
     
     // state
-    private var disposables = [Disposable]()
-    private var disposed = false
+    private var _disposables = [Disposable]()
+    private var _disposed = false
     
     /**
     Constructs new empty dispose bag.
@@ -52,12 +52,12 @@ public class DisposeBag: DisposeBase {
     - parameter disposable: Disposable to add.
     */
     public func addDisposable(disposable: Disposable) {
-        let dispose = lock.calculateLocked { () -> Bool in
-            if disposed {
+        let dispose = _lock.calculateLocked { () -> Bool in
+            if _disposed {
                 return true
             }
             
-            disposables.append(disposable)
+            _disposables.append(disposable)
             
             return false
         }
@@ -71,11 +71,11 @@ public class DisposeBag: DisposeBase {
     This is internal on purpose, take a look at `CompositeDisposable` instead.
     */
     func dispose() {
-        let oldDisposables = lock.calculateLocked { () -> [Disposable] in
-            let disposables = self.disposables
+        let oldDisposables = _lock.calculateLocked { () -> [Disposable] in
+            let disposables = _disposables
             
-            self.disposables.removeAll(keepCapacity: false)
-            self.disposed = true
+            _disposables.removeAll(keepCapacity: false)
+            _disposed = true
             
             return disposables
         }
diff --git a/RxSwift/Disposables/SerialDisposable.swift b/RxSwift/Disposables/SerialDisposable.swift
index 2ca4ea53..571000cf 100644
--- a/RxSwift/Disposables/SerialDisposable.swift
+++ b/RxSwift/Disposables/SerialDisposable.swift
@@ -12,7 +12,7 @@ import Foundation
 Represents a disposable resource whose underlying disposable resource can be replaced by another disposable resource, causing automatic disposal of the previous underlying disposable resource.
 */
 public class SerialDisposable : DisposeBase, Cancelable {
-    var lock = SpinLock()
+    private var _lock = SpinLock()
     
     // state
     private var _current = nil as Disposable?
@@ -43,12 +43,12 @@ public class SerialDisposable : DisposeBase, Cancelable {
     */
     public var disposable: Disposable {
         get {
-            return self.lock.calculateLocked {
+            return _lock.calculateLocked {
                 return self.disposable
             }
         }
         set (newDisposable) {
-            let disposable: Disposable? = self.lock.calculateLocked {
+            let disposable: Disposable? = _lock.calculateLocked {
                 if _disposed {
                     return newDisposable
                 }
@@ -69,7 +69,7 @@ public class SerialDisposable : DisposeBase, Cancelable {
     Disposes the underlying disposable as well as all future replacements.
     */
     public func dispose() {
-        let disposable: Disposable? = self.lock.calculateLocked {
+        let disposable: Disposable? = _lock.calculateLocked {
             if _disposed {
                 return nil
             }
diff --git a/RxSwift/Disposables/SingleAssignmentDisposable.swift b/RxSwift/Disposables/SingleAssignmentDisposable.swift
index a5a419e6..bf7e3f21 100644
--- a/RxSwift/Disposables/SingleAssignmentDisposable.swift
+++ b/RxSwift/Disposables/SingleAssignmentDisposable.swift
@@ -14,7 +14,7 @@ Represents a disposable resource which only allows a single assignment of its un
 If an underlying disposable resource has already been set, future attempts to set the underlying disposable resource will throw an exception.
 */
 public class SingleAssignmentDisposable : DisposeBase, Disposable, Cancelable {
-    private var lock = SpinLock()
+    private var _lock = SpinLock()
     
     // state
     private var _disposed = false
@@ -26,7 +26,7 @@ public class SingleAssignmentDisposable : DisposeBase, Disposable, Cancelable {
     */
     public var disposed: Bool {
         get {
-            return lock.calculateLocked {
+            return _lock.calculateLocked {
                 return _disposed
             }
         }
@@ -46,12 +46,12 @@ public class SingleAssignmentDisposable : DisposeBase, Disposable, Cancelable {
     */
     public var disposable: Disposable {
         get {
-            return lock.calculateLocked {
+            return _lock.calculateLocked {
                 return _disposable ?? NopDisposable.instance
             }
         }
         set {
-            let disposable: Disposable? = lock.calculateLocked {
+            let disposable: Disposable? = _lock.calculateLocked {
                 if _disposableSet {
                     rxFatalError("oldState.disposable != nil")
                 }
@@ -77,7 +77,7 @@ public class SingleAssignmentDisposable : DisposeBase, Disposable, Cancelable {
     Disposes the underlying disposable.
     */
     public func dispose() {
-        let disposable: Disposable? = lock.calculateLocked {
+        let disposable: Disposable? = _lock.calculateLocked {
             _disposed = true
             let dispose = _disposable
             _disposable = nil
diff --git a/RxSwift/Observables/Implementations/Sink.swift b/RxSwift/Observables/Implementations/Sink.swift
index 48ec651b..c7b16261 100644
--- a/RxSwift/Observables/Implementations/Sink.swift
+++ b/RxSwift/Observables/Implementations/Sink.swift
@@ -9,22 +9,22 @@
 import Foundation
 
 class Sink<O : ObserverType> : Disposable {
-    private var lock = SpinLock()
+    private var _lock = SpinLock()
     
     // state
-    var _observer: O?
-    var _cancel: Disposable
-    var _disposed: Bool = false
+    private var _observer: O?
+    private var _cancel: Disposable
+    private var _disposed: Bool = false
     
     var observer: O? {
         get {
-            return lock.calculateLocked { _observer }
+            return _lock.calculateLocked { _observer }
         }
     }
     
     var cancel: Disposable {
         get {
-            return lock.calculateLocked { _cancel }
+            return _lock.calculateLocked { _cancel }
         }
     }
     
@@ -37,7 +37,7 @@ class Sink<O : ObserverType> : Disposable {
     }
     
     func dispose() {
-        let cancel: Disposable? = lock.calculateLocked {
+        let cancel: Disposable? = _lock.calculateLocked {
             if _disposed {
                 return nil
             }
diff --git a/RxSwift/Subjects/PublishSubject.swift b/RxSwift/Subjects/PublishSubject.swift
index 143d1869..97440f9f 100644
--- a/RxSwift/Subjects/PublishSubject.swift
+++ b/RxSwift/Subjects/PublishSubject.swift
@@ -11,7 +11,7 @@ import Foundation
 class Subscription<Element> : Disposable {
     typealias KeyType = Bag<ObserverOf<Element>>.KeyType
     
-    private var lock = SpinLock()
+    private var _lock = SpinLock()
 
     // state
     private var subject: PublishSubject<Element>?
@@ -23,13 +23,10 @@ class Subscription<Element> : Disposable {
     }
     
     func dispose() {
-        lock.performLocked {
-            guard let subject = subject else {
-                return
-            }
-            
-            guard let key = key else {
-                return
+        _lock.performLocked {
+            guard let subject = subject,
+                let key = key else {
+                    return
             }
             
             self.subject = nil
diff --git a/RxSwift/Subjects/Variable.swift b/RxSwift/Subjects/Variable.swift
index c8f810ed..2265cf36 100644
--- a/RxSwift/Subjects/Variable.swift
+++ b/RxSwift/Subjects/Variable.swift
@@ -18,7 +18,7 @@ public class Variable<Element> : ObservableType {
     
     let subject: BehaviorSubject<Element>
     
-    private var lock = SpinLock()
+    private var _lock = SpinLock()
  
     // state
     private var _value: E
@@ -32,12 +32,12 @@ public class Variable<Element> : ObservableType {
     */
     public var value: E {
         get {
-            return lock.calculateLocked {
+            return _lock.calculateLocked {
                 return _value
             }
         }
         set(newValue) {
-            lock.performLocked {
+            _lock.performLocked {
                 _value = newValue
             }
             self.subject.on(.Next(newValue))
@@ -50,7 +50,7 @@ public class Variable<Element> : ObservableType {
     - parameter value: Initial variable value.
     */
     public init(_ value: Element) {
-        self._value = value
+        _value = value
         self.subject = BehaviorSubject(value: value)
     }