public final class Synchronized<Wrapped> {
	private var _lock: Lock
	private var _value: Wrapped

	public init(_ value: Wrapped, allowConcurrentReads: Bool = true) {
		self._value = value
		self._lock = allowConcurrentReads ? ReadWriteLock() : MutexLock()
	}

	private func readSync <T> (_ perform: () throws -> T) rethrows -> T {
		guard let concurrentLock = _lock as? ConcurrentLock else {
			return try _lock.sync(perform)
		}
		return try concurrentLock.concurrentSync(perform)
	}

	public var value: Wrapped {
		get { return readSync { _value } }
		set { _lock.sync { _value = newValue } }
	}

	public func atomicallyUpdate(_ update: (inout Wrapped) throws -> Void) rethrows {
		try _lock.sync({ try update(&_value) })
	}
}

public final class Synchronized<Wrapped> {
	private var _lock: Lock
	private var _value: Wrapped

	public init(_ value: Wrapped) {
		self._value = value
	}

	public var value: Wrapped {
		get { return _lock.sync { _value } }
		set { _lock.sync { _value = newValue } }
	}

	public func atomicallyUpdate(_ update: (inout Wrapped) throws -> Void) rethrows {
		try _lock.sync({ try update(&_value) })
	}
}

--- 
+++ 
@@ -2,12 +2,20 @@
 	private var _lock: Lock
 	private var _value: Wrapped
 
-	public init(_ value: Wrapped) {
+	public init(_ value: Wrapped, allowConcurrentReads: Bool = true) {
 		self._value = value
+		self._lock = allowConcurrentReads ? ReadWriteLock() : MutexLock()
+	}
+
+	private func readSync <T> (_ perform: () throws -> T) rethrows -> T {
+		guard let concurrentLock = _lock as? ConcurrentLock else {
+			return try _lock.sync(perform)
+		}
+		return try concurrentLock.concurrentSync(perform)
 	}
 
 	public var value: Wrapped {
-		get { return _lock.sync { _value } }
+		get { return readSync { _value } }
 		set { _lock.sync { _value = newValue } }
 	}
 
Add option to allow concurrent reads

Change the type of lock internally used to allow concurrent reads when the flag
is passed.
