guard let device = device else {
    fatalError("GPU is not supported")
}

let frame = CGRect(x: 75/2.0, y: 96, width: 300, height: 300)
let view = MTKView(frame: frame, device: device)
view.clearColor = MTLClearColor(red: 1, green: 1, blue: 0.8, alpha: 1)

guard let commandQueue = device.makeCommandQueue() else { 
    fatalError("Could not create a command queue") 
}

// 1. 创建一个网格数据内存管理器
let allocator = MTKMeshBufferAllocator(device: device)
// 2. Model I/O 创建一个有着特定大小的球体
// 并且返回一个 MDLMesh 对象, buffers 中有着所有的顶点信息
let mdlMesh = MDLMesh(sphereWithExtent: [0.75, 0.75, 0.75], segments: [100, 100], inwardNormals: false, geometryType: .triangles, allocator: allocator)
// 3. 为了让 Metal 可以使用这些网格, 从一个 Model I/O mesh 转换成一个 MetalKit mesh
let mesh = try! MTKMesh(mesh: mdlMesh, device: device)

let shader = """
#include <metal_stdlib> \n
using namespace metal;

struct VertexIn {
  float4 position [[ attribute(0) ]];
};

vertex float4 vertex_main(const VertexIn vertex_in [[ stage_in ]]) {
  return vertex_in.position;
}

fragment float4 fragment_main() {
  return float4(1, 0, 0, 1);
}
"""

// 创建一个包含 shader 中两个方法的 Metal 库
let library = try device.makeLibrary(source: shader, options: nil) 
let vertexFunction = library.makeFunction(name: "vertex_main") 
let fragmentFunction = library.makeFunction(name: "fragment_main")

// 创建一个 pipeline descriptor
let descriptor = MTLRenderPipelineDescriptor()
// 设置像素格式化
// .bgra8Unorm: Ordinary format with four 8-bit normalized unsigned integer components in BGRA order.
descriptor.colorAttachments[0].pixelFormat = .bgra8Unorm
descriptor.vertexFunction = vertexFunction
descriptor.fragmentFunction = fragmentFunction
// MTKMetalVertexDescriptorFromModelIO(_:)
// 返回一个部分被转换的 Metal 顶点描述符号
descriptor.vertexDescriptor = MTKMetalVertexDescriptorFromModelIO(mesh.vertexDescriptor)

let pipelineState = try device.makeRenderPipelineState(descriptor: descriptor)

guard let commandBuffer = commandQueue.makeCommandBuffer(),

let descriptor = view.currentRenderPassDescriptor,

let renderEncoder =
  commandBuffer.makeRenderCommandEncoder(descriptor: descriptor)
  else { fatalError() }

let subject = PublishSubject<String>()

subject.onNext("Test")

let subscription1 = subject.subscribe(onNext: { (string) in
    print(string)
}, onError: nil, onCompleted: nil, onDisposed: nil)

subject.on(.next("1"))
subject.on(.next("2"))

let subject = PublishSubject<String>()

subject.onNext("Test")

let subscription1 = subject.subscribe(onNext: { (string) in
    print(string)
}, onError: nil, onCompleted: nil, onDisposed: nil)

subject.on(.next("1"))
subject.on(.next("2"))

let subscription2 = subject.subscribe({ (event) in
    print("Subscription 2: ", event.element ?? event)
})

subject.on(.next("3"))

subscription1.dispose()

subject.on(.next("4"))

subject.onCompleted()

subject.onNext("5")

subscription2.dispose()

let disposeBag = DisposeBag()
let subscription3 = subject.subscribe({
    print("subscription 3:", $0.element ?? $0)
})
    .disposed(by: disposeBag)

subject.onNext("6")

// 提供一个初始值
let subject = BehaviorSubject(value: "Init")

let disposeBag = DisposeBag()

subject.onNext("1")

subject.subscribe({ (event) in
    print("Subscription1:", (event.element ?? event.error ?? event) ?? "")
}).disposed(by: disposeBag)

Subscription1: 1

enum MyError: Error {
    case anError
    case anotherError
}

subject.onError(MyError.anError)
    subject.subscribe({ (event) in
        print("Subscription2:", (event.element ?? event.error ?? event) ?? "")
    }).disposed(by: disposeBag)

Subscription1: anError
Subscription2: anError

let subject = ReplaySubject<String>.create(bufferSize: 2)
subject.onNext("1")
subject.onNext("2")
subject.onNext("3")

let disposeBag = DisposeBag()

subject.subscribe({
    print("Subscription1:", ($0.element ?? $0.error ?? $0) ?? "")
}).disposed(by: disposeBag)

subject.subscribe({
    print("Subscription2:", ($0.element ?? $0.error ?? $0) ?? "")
}).disposed(by: disposeBag)

subject.onNext("4")
subject.subscribe({
    print("Subscription3:", ($0.element ?? $0.error ?? $0) ?? "")
}).disposed(by: disposeBag)

subject.onNext("4")
// 新添加
subject.onError(MyError.anError)
subject.subscribe({
    print("Subscription3:", ($0.element ?? $0.error ?? $0) ?? "")
}).disposed(by: disposeBag)

subject.onError(MyError.anError)
subject.dispose()
subject.subscribe({
    print("Subscription3:", ($0.element ?? $0.error ?? $0) ?? "")
}).disposed(by: disposeBag)

let variable = Variable("Init")
variable.value = "Re-init"

let disposeBag = DisposeBag()

variable.asObservable().subscribe({
    print("Subscription:", ($0.element ?? $0.error ?? $0) ?? "")
}).disposed(by: disposeBag)

variable.value = "1"
variable.asObservable().subscribe({
    print("Subscription2:", ($0.element ?? $0.error ?? $0) ?? "")
}).disposed(by: disposeBag)

variable.value = "2"

let one = 1
let two = 2
let three = 3

let observable: Observable<Int> = Observable<Int>.just(one)
// An observable of Int with 3 elements
let observable2 = Observable.of(one, two, three)
// An observable of [Int] with a single element - Array
let observable3 = Observable.of([one, two, three])
// An observable of Int
let observable4 = Observable.from([one, two, three])

observable.subscribe(onNext: { (int) in
    print("just: \(int)") 
    // just: 1
})

observable2.subscribe(onNext: { (int) in
    print("of: \(int)") 
    // of: 1
    // of: 2
    // of: 3
})

observable3.subscribe(onNext: { (int) in
    print("of array: \(int)")
    // of array: [1, 2, 3]
})

observable4.subscribe(onNext: { (int) in
    print("from: \(int)")
    // from: 1
    // from: 2
    // from: 3
})

let one = 1
let two = 2
let three = 3

let observable = Observable.of(one, two, three)
observable.subscribe { (event) in
    print("subscrib event: \(event)")
    if let element = event.element {
        print("subscrib: \(element)")
    }
}

observable.subscribe(onNext: { (element) in
    print("subscribe next on: \(element)")
})

// 控制台输出：
/**
subscrib event: next(1)
subscrib: 1
subscrib event: next(2)
subscrib: 2
subscrib event: next(3)
subscrib: 3
subscrib event: completed
subscribe next on: 1
subscribe next on: 2
subscribe next on: 3
*/

let observable = Observable<Void>.empty()
observable
    .subscribe(onNext: { (element) in
        print("empty: \(element)")
    }) {
        print("Completed")
        // Completed
}

let observable = Observable<Any>.never()
observable
    .subscribe( onNext: { element in print(element) },
                onCompleted: { print("Completed") } )
                
// 控制台什么都不会打印

let observable = Observable.range(start: 1, count: 3)
        
var n = 0
        
observable.subscribe(onNext: { (i) in
    n += i
    print(n)
})

// 1 (0+1)
// 3 (1+2)
// 6 (3+3)

let observable = Observable.of("a", "b", "c")
let subscription = observable.subscribe { (event) in
    print(event)
}
        
subscription.dispose()

// next(a)
// next(b)
// next(c)
// completed

let disposeBag = DisposeBag()
        
Observable.of("a", "b", "c")
    .subscribe {
        print($0)
    }
    .disposed(by: disposeBag)

enum MyError: Error {
    case anError
}

let disposeBag = DisposeBag()
        
Observable<String>.create { (observer) -> Disposable in
    observer.on(.next("1"))
    observer.on(.error(MyError.anError))
    observer.on(.completed)
    observer.onNext("?")
    
    // Disposables.create() 操作返回了一个空的 disposable
    return Disposables.create()
    }
    .subscribe(
        onNext: { print($0) },
        onError: { print($0) },
        onCompleted: { print("Completed") },
        onDisposed: { print("Disposed") })
    .disposed(by: disposeBag)
    
// 1
// anError
// Disposed
// observer 发出的 error 操作终止了订阅行为，completed 操作和 next("?") 操作并没有被发出

let disposeBag = DisposeBag()
        
var flip = false
        
let factory: Observable<Int> = Observable.deferred {
            
    flip = !flip
            
    if flip {
        return Observable.of(1, 2, 3)
    } else {
        return Observable.of(4, 5, 6)
    }
 }
        
for _ in 0...3 {
    factory
        .subscribe(onNext: {
            print($0, terminator:"")
        })
        .disposed(by: disposeBag)
    print()
}

// 123
// 456
// 123
// 456

func exampleOfSingle() {
    
    print("--- Example of: single --- ")
    
    let disposeBag = DisposeBag()
    loadText(from: "README", type: "md")
        .subscribe {
            //                single in
            //
            //                print(single)
            //                switch single {
            //                case.success(let string):
            //                    print(string)
            //                case.error(let error):
            //                    print(error)
            switch $0 {
            case .success(let string):
                print(string)
            case .error(let error):
                print(error)
            }
        }
        .disposed(by: disposeBag)
}

func loadText(from name: String, type: String = "txt") -> Single<String> {
    return Single.create { single in
        let disposable = Disposables.create()
        
        guard let path = Bundle.main.path(forResource: name, ofType: type) else {
            single(.error(FileReadError.fileNotFound))
            return disposable
        }
        
        guard let data = FileManager.default.contents(atPath: path) else {
            single(.error(FileReadError.unreadable))
            return disposable
        }
        
        guard let contents = String(data: data, encoding: .utf8) else {
            single(.error(FileReadError.encodingFailed))
            return disposable
        }
        
        single(.success(contents))
        
        return disposable
    }
}

enum FileReadError: Error {
    case fileNotFound, unreadable, encodingFailed
}

# LearnRxSwift

#### 项目介绍

let bag = DisposeBag()

let completable = Completable.create { (event) -> Disposable in
    
    // 模拟操作
    let flag = Int.random(in: 0..<2)
    
    var success: Bool {
        return flag == 1 ? true : false
    }
    
    guard success else {
        event(.error(FileReadError.fileNotFound))
        return Disposables.create()
    }
    
    event(.completed)
    return Disposables.create()
}

completable.subscribe(onCompleted: {
    print("Completed")
}) { (error) in
    print("An error has occurred")
    }.disposed(by: bag)
    
// An error has occurred

let maybe = Maybe<Int>.create { (event) -> Disposable in
    event(.success(1))
    event(.completed)
    event(.error(FileReadError.encodingFailed))
    return Disposables.create()
}

let bag = DisposeBag()

maybe.subscribe(onSuccess: {
    print($0)
}, onError: { (errpr) in
    print("An error has occurred")
}) {
    print("Completed")
    }.disposed(by: bag)
    
// 1

// Todo

// Todo

// Todo

public class Node<Value> {
    public var value: Value
    public var next: Node?
    
    public init(value: Value, next: Node? = nil) {
        self.value = value
        self.next = next
    }
}

extension Node: CustomStringConvertible {
    public var description: String {
        guard let next = next else { return "\(value)" }
        return "\(value) -> " + String(describing: next) + " "
    }
}

public struct LinkedList<Value> {
    public var head: Node<Value>?
    public var tail: Node<Value>?
    
    public init() {}
    
    public var isEmpty: Bool {
        return head == nil
    }
    
    // Push
    public mutating func push(_ value: Value) {
        head = Node(value: value, next: head)
        if tail == nil {
            tail = head
        }
    }
    
    // Append
    public mutating func append(_ value: Value) {
        guard !isEmpty else {
            push(value)
            return
        }
        
        tail!.next = Node(value: value)
        
        tail = tail!.next
    }
    
    public func node(at index: Int) -> Node<Value>? {
        var currentNode = head
        var currentIndex = 0
        
        // 向下遍历直到找到相应的 index, 返回 Node
        while currentNode != nil && currentIndex < index {
            currentNode = currentNode!.next
            currentIndex += 1
        }
        
        return currentNode
    }
    
    @discardableResult
    public mutating func insert(_ value: Value,
                                after node: Node<Value>) -> Node<Value> {
        
        // 如果尾部节点和 node 不是同一个节点
        guard tail !== node else {
            // 是同一个节点
            return tail!
        }
        
        node.next = Node(value: value, next: node.next)
        return node.next!
    }
}

extension LinkedList: CustomStringConvertible {
    public var description: String {
        guard let head = head else { return "Empty list" }
        return String(describing: head)
    }
}

extension LinkedList {
    /// Removes the value at the front of the list
    public mutating func pop() -> Value? {
        defer {
            head = head?.next
            print("defer head: \(head!)")
            if isEmpty {
                tail = nil
            }
        }
        print("head: \(head!)")
        return head?.value
    }
    
    public mutating func removeLast() -> Value? {
        
        guard let head = head else { return nil }
        
        // 如果这个链表只有一个节点, removeLast 就等价于 pop
        guard head.next != nil else {
            return pop()
        }
        
        // 一直搜索, 直到 current.next == nil
        // 这表明 current 是链表最后一个节点
        var prev = head
        var current = head
        
        while let next = current.next {
            prev = current
            // 第一次循环 prev === head -> true
            // 第二次循环 prev === head -> false
            // 此时 prev 的引用切换到 head.next
            current = next
        }
        
        // 这时 current 是最后一个节点
        // prev.next === current
        // 移除 prev.next 相当于移除 head.next 的 next, 更新 tail
        prev.next = nil
        tail = prev
        
        return current.value
    }
    
    @discardableResult
    public mutating func remove(after node: Node<Value>) -> Value? {
        defer {
            if node.next === tail {
                tail = node
            }
            node.next = node.next?.next
        }
        return node.next?.value
    }
}

public struct Stack<Element> {
    private var storage: [Element] = []
    public init() {}
    
    public init(_ elements: [Element]) {
        storage = elements
    }
    
    public mutating func push(_ element: Element) {
        storage.append(element)
    }
    
    // 忽略警告
    @discardableResult
    public mutating func pop() -> Element? {
        return storage.popLast()
    }
    
    public func peek() -> Element? {
        return storage.last
    }
    
    public var isEmpty: Bool {
        return peek() == nil
    }
}

extension Stack: CustomStringConvertible {
    public var description: String {
        let topDivider = "----top----\n"
        let bottomDivider = "\n----Bot----"
        
        let stackElements = storage
            .map { "\($0)" }
            .reversed()
            .joined(separator: "\n")
        
        return topDivider + stackElements + bottomDivider
    }
}

/// 用数组字面量初始化
extension Stack: ExpressibleByArrayLiteral {
    public init(arrayLiteral elements: Element...) {
        storage = elements
    }
}

public protocol Queue {
  
  associatedtype Element
  mutating func enqueue(_ element: Element) -> Bool
  mutating func dequeue() -> Element?
  var isEmpty: Bool { get }
  var peek: Element? { get }
}

public struct QueueStack<T> : Queue {
    
    private var leftStack: [T] = []
    private var rightStack: [T] = []
    public init() {}
    
    public var isEmpty: Bool {
        return leftStack.isEmpty && rightStack.isEmpty
    }
    
    public var peek: T? {
        return !leftStack.isEmpty ? leftStack.last : rightStack.first
    }
    
    /// 右栈用来插入, 左栈用来放右栈拿出来的数据
    public mutating func enqueue(_ element: T) -> Bool {
        rightStack.append(element)
        return true
    }
    
    public mutating func dequeue() -> T? {
        if leftStack.isEmpty {
            
            // 如果此时左栈是空的, 右栈是 [3, 2, 1]
            // 进栈顺序为 3 -> 2 -> 1
            // 把右栈反向填充到左栈, 此时左栈为 [1, 2, 3]
            leftStack = rightStack.reversed()
            rightStack.removeAll()
        }
        // 出队列操作, 左栈移除最后一个元素, 3, 先进先出
        return leftStack.popLast()
    }
}

public class TreeNode<T> {
    public var value: T
    public var children: [TreeNode] = []
    
    public init(_ value: T) {
        self.value = value
    }
    
    public func add(_ child: TreeNode) {
        children.append(child)
    }
}

public class BinaryNode<Element> {
    public var value: Element
    public var leftChild: BinaryNode? = nil
    public var rightChild: BinaryNode? = nil
    
    public init(value: Element) {
        self.value = value
    }
}

extension BinaryNode: CustomStringConvertible {
    
    public var description: String {
        return diagram(for: self)
    }
    
    private func diagram(for node: BinaryNode?,
                         _ top: String = "",
                         _ root: String = "",
                         _ bottom: String = "") -> String {
        guard let node = node else {
            return root + "nil\n"
        }
        if node.leftChild == nil && node.rightChild == nil {
            return root + "\(node.value)\n"
        }
        return diagram(for: node.rightChild, top + " ", top + "┌──", top + "│ ")
            + root + "\(node.value)\n"
            + diagram(for: node.leftChild, bottom + "│ ", bottom + "└──", bottom + " ")
    }
}

extension BinaryNode {
    
    public func traverseInOrder(visit: (Element) -> Void) {
        // 如果当前节点有左子节点，先递归访问这个子节点
        leftChild?.traverseInOrder(visit: visit)
        // 然后访问当前节点本身
        visit(value)
        // 如果当前节点有一个右子节点，递归访问这个子节点
        rightChild?.traverseInOrder(visit: visit)
    }
}

extension BinaryNode {
    public func traversePreOrder(visit: (Element) -> ()) {
        visit(value)
        leftChild?.traversePreOrder(visit: visit)
        rightChild?.traversePreOrder(visit: visit)
    }
}

extension BinaryNode {
    public func traversePostOrder(visit: (Element) -> ()) {
        leftChild?.traversePostOrder(visit: visit)
        rightChild?.traversePostOrder(visit: visit)
        visit(value)
    }
}

struct Heap<Element: Equatable> {
    var elements: [Element] = []
    let sort: (Element, Element) -> Bool
    
    init(sort: @escaping (Element, Element) -> Bool) {
        self.sort = sort
    }
}

var isEmpty: Bool {
    return elements.isEmpty
}

var count: Int {
    return elements.count
}

func peek() -> Element? {
    return elements.first
}

func leftChildIndex(ofParentAt index: Int) -> Int {
    return (2 * index) + 1
}

func rightChildIndex(ofParentAt index: Int) -> Int {
    return (2 * index) + 2
}

func parentIndex(ofChildAt index: Int) -> Int {
    return (index - 1) / 2
}

/// 移除根节点
mutating func remove() -> Element? {
    
    // 如果 heap 是空的就返回 空
    guard !isEmpty else {
        return nil
    }
    
    // 交换根元素和最后一个元素
    elements.swapAt(0, count - 1)
    
    /**
     在错误处理方面，guard 和新的 throw 语法之间，Swift 2.0 也鼓励用尽早返回错误（这也是 NSHipster 最喜欢的方式）来代替嵌套 if 的处理方式。尽早返回让处理更清晰了，但是已经被初始化（可能也正在被使用）的资源必须在返回前被处理干净。
     
     新的 defer 关键字为此提供了安全又简单的处理方式：声明一个 block，当前代码执行的闭包退出时会执行该 block
     */
    defer {
        // 向下筛选以确保是一个 max heap 或者 min heap
        siftDown(from: 0)
    }
    
    // 移除最后一个元素, 并返回
    return elements.removeLast()
}

/// 向下筛选
mutating func siftDown(from index: Int) {
    
    // 记录父节点 index
    var parent = index
    
    // 不断向下筛选, 直到 return
    while true {
        
        // 得到左节点和右节点的 index
        let left = leftChildIndex(ofParentAt: parent)
        let right = rightChildIndex(ofParentAt: parent)
        
        // 记录候选节点 index
        var candidate = parent
        
        // 如果有左节点, 并且左节点的值高于父节点的值, 那么替换候选节点为左节点
        if left < count && sort(elements[left], elements[candidate]) {
            candidate = left
        }
        
        // 如果有右节点, 并且右节点比左节点的值更高, 那么替换候选节点为右节点
        if right < count && sort(elements[right], elements[candidate]) {
            candidate = right
        }
        
        // 如果候选节点和父节点是一样的, 直接 return 结束循环
        if candidate == parent {
            return
        }
        
        // 替换父节点和子节点的值
        elements.swapAt(parent, candidate)
        
        // 重新赋值父节点, 进入下一次向下筛选
        parent = candidate
    }
}

mutating func insert(_ element: Element) {
    elements.append(element)
    siftUp(from: elements.count - 1)
}

mutating func siftUp(from index: Int) {
    var child = index
    var parent = parentIndex(ofChildAt: index)
    
    // 如果子节点不是根节点, 且子节点的值大于或小于父节点
    while child > 0 && sort(elements[child], elements[parent]) {
        
        // 交换两个节点的值
        elements.swapAt(child, parent)
        // 更换子节点下标
        child = parent
        // 重新查找父节点
        parent = parentIndex(ofChildAt: child)
    }
}

// Bubble sort
func bubbleSort(_ array: inout [Int]) {
    for i in (1 ..< array.count).reversed() {
        for j in 0 ..< i  {
            if array[j] > array[j+1] {
                array.swapAt(j, j + 1)
            }
        }
    }
}

// Selection sort
func selectionSort(_ array: inout [Int]) {
    for current in 0 ..< array.count - 1 {
        var lowest = current
        for other in (current + 1) ..< array.count {
            if array[lowest] > array[other] {
                lowest = other
            }
        }
        if lowest != current {
            array.swapAt(lowest, current)
        }
    }
}

// Insertion sort
func insertionSort(_ array: inout [Int]) {
    for current in 1 ..< array.count {
        for shifting in (1...current).reversed() {
            if array[shifting] < array[shifting - 1] {
                array.swapAt(shifting, shifting - 1)
            } else {
                break
            }
        }
    }
}

func mergeSort<Element>(_ array: [Element]) -> [Element] where Element: Comparable {
    
    guard array.count > 1 else {
        return array
    }
    let middle = array.count / 2
    let left = mergeSort(Array(array[..<middle]))
    let right = mergeSort(Array(array[middle...]))
    let merged = merge(left, right)
    return merged
}

func merge<Element>(_ left: [Element], _ right: [Element]) -> [Element] where Element: Comparable {
    
    var leftIndex = 0
    var rightIndex = 0
    
    var result: [Element] = []
    
    while leftIndex < left.count && rightIndex < right.count {
        let leftElement = left[leftIndex]
        let rightElement = right[rightIndex]
        
        if leftElement < rightElement {
            result.append(leftElement)
            leftIndex += 1
        } else if rightElement < leftElement {
            result.append(rightElement)
            rightIndex += 1
        } else {
            result.append(leftElement)
            leftIndex += 1
            result.append(rightElement)
            rightIndex += 1
        }
    }
    
    if leftIndex < left.count {
        result.append(contentsOf: left[leftIndex...])
    }
    if rightIndex < right.count {
        result.append(contentsOf: right[rightIndex...])
    }
    
    return result
}

// Naive
func quicksortNaive<T: Comparable>(_ a: [T]) -> [T] {
    
    guard a.count > 1 else {
        return a
    }
    
    let pivot = a[a.count / 2]
    let less = a.filter { $0 < pivot }
    let equal = a.filter { $0 == pivot }
    let greater = a.filter { (num) -> Bool in
        return num > pivot
    }
    return quicksortNaive(less) + equal + quicksortNaive(greater)
}

// Lomuto
func partitionLomuto(_ a: inout [Int], low: Int, high: Int) -> Int {
    let pivot = a[high]
    var i = low
    for j in low..<high {
        if a[j] <= pivot {
            a.swapAt(i, j)
            i += 1
        }
    }
    a.swapAt(i, high)
    
    return i
}

func quicksort(_ a: inout [Int], low: Int, high: Int) {
    if low < high {
        let pivot = partitionLomuto(&a, low: low, high: high)
        quicksort(&a, low: low, high: pivot - 1)
        quicksort(&a, low: pivot + 1, high: high)
    }
}

_staticContentLayer = [CAShapeLayer layer];
_staticContentLayer.bounds = contentLayerRect;
_staticContentLayer.fillColor = Color(clearColor).CGColor;
_staticContentLayer.strokeColor= Color(whiteColor).CGColor;
_staticContentLayer.position = position;


[self.layer addSublayer:_staticContentLayer];

_staticBallLayer = [CAShapeLayer layer];
_staticBallLayer.frame = CGRectMake(0, 0, 2 * ballLayerRadius, 2 * ballLayerRadius);
_staticBallLayer.cornerRadius = ballLayerRadius;
_staticBallLayer.backgroundColor = Color(whiteColor).CGColor;
_staticBallLayer.position = CGPointMake(contentLayerWidth / 2.0, 0);
[_staticContentLayer addSublayer:_staticBallLayer];

CPMatchingView *matchingView = [[CPMatchingView alloc] initWithFrame:CGRectMake(100, 100, 200, 200)];
[self.view addSubview:matchingView];

let lock = NSLock()
lock.lock()
// Todo
lock.unlock()

// 第一种，手动调用 start
// convenience init(target: Any, selector: Selector, object argument: Any?)
let thread = Thread(target: self, selector: #selector(thread1Action(_:)), object: "Thread1")
thread.name = "Background 1"
thread.start()

// 第二种，类方法
// class func detachNewThreadSelector(_ selector: Selector, toTarget target: Any, with argument: Any?)
Thread.detachNewThreadSelector(#selector(thread2Action(_:)), toTarget: self, with: "Thread2")

// 第三种 performSelector
performSelector(inBackground: #selector(thread3Action(_:)), with: "Thread3")

func synchronized(_ lock: AnyObject, closure:() -> ()) {
    objc_sync_enter(lock)
    closure()
    objc_sync_exit(lock)
}