线程的同步方式

线程的同步方式

项目中可能会遇到多个任务请求完成之后再进行界面渲染的功能。有以下几种实现很是，在这里以Kotlin的方式进行编码：

• Thread.join
• Synchronized
• ReentrantLock
• BlockingQueue
• CountDownLatch
• CyclicBarrier
• CAS
• Future
• CompletableFuture
• Rxjava
• Coroutine
• Flow

Thread.join#

fun test_join() {
    lateinit var s1: String
    lateinit var s2: String

    val t1 = Thread { s1 = task1() }
    val t2 = Thread { s2 = task2() }
    t1.start()
    t2.start()

    t1.join()
    t2.join()

    task3(s1, s2)
}

Synchronized#

fun test_synchrnoized() {
    lateinit var s1: String
    lateinit var s2: String
    Thread {
        synchronized(Unit) {
            s1 = task1()
        }
    }.start()
    s2 = task2()

    synchronized(Unit) {
        task3(s1, s2)
    }
}

ReentrantLock#

fun test_ReentrantLock() {
    lateinit var s1: String
    lateinit var s2: String

    val lock = ReentrantLock()
    Thread {
        lock.lock()
        s1 = task1()
        lock.unlock()
    }.start()
    s2 = task2()

    lock.lock()
    task3(s1, s2)
    lock.unlock()
}

BlockingQueue#

fun test_blockingQueue() {
   lateinit var s1: String
    lateinit var s2: String

    val queue = SynchronousQueue<Unit>()

    Thread {
        s1 = task1()
        queue.put(Unit)
    }.start()

    s2 = task2()

    queue.take()
    task3(s1, s2)
}

CountDownLatch#

fun test_countdownlatch() {
    lateinit var s1: String
    lateinit var s2: String
    val cd = CountDownLatch(2)
    Thread() {
        s1 = task1()
        cd.countDown()
    }.start()

    Thread() {
        s2 = task2()
        cd.countDown()
    }.start()

    cd.await()
    task3(s1, s2)
}

CyclicBarrier#

CyclicBarrier 是 JUC 提供的另一种共享锁机制，它可以让一组线程到达一个同步点后再一起继续运行，其中任意一个线程未达到同步点，其他已到达的线程均会被阻塞。与 CountDownLatch 的区别在于 CountDownLatch 是一次性的，而 CyclicBarrier 可以被重置后重复使用，这也正是 Cyclic 的命名由来，可以循环使用。

fun test_CyclicBarrier() {

    lateinit var result1: String
    lateinit var result2: String
    val cb = CyclicBarrier(3)

    Thread {
        result1 = task1()
        cb.await()
    }.start()

    Thread() {
        result2 = task1()
        cb.await()
    }.start()

    cb.await()
    task3(result1, result2)
}

CAS#

AQS 内部通过自旋锁实现同步，自旋锁的本质是利用 CompareAndSwap 避免线程阻塞的开销。因此，我们可以使用基于 CAS 的原子类计数，达到实现无锁操作的目的。

fun test_cas() {
    lateinit var s1: String
    lateinit var s2: String

    val cas = AtomicInteger(2)

    Thread {
        s1 = task1()
        cas.getAndDecrement()
    }.start()

    Thread {
        s2 = task2()
        cas.getAndDecrement()
    }.start()

    while (cas.get() != 0) {}

    task3(s1, s2)
}

volatile#

注意，这种写法是错误的volatile 能保证可见性，但是不能保证原子性，cnt-- 并非线程安全，需要加锁操作。

fun test_Volatile() {
    lateinit var s1: String
    lateinit var s2: String

    Thread {
        s1 = task1()
        cnt--
    }.start()

    Thread {
        s2 = task2()
        cnt--
    }.start()

    while (cnt != 0) {
    }
    task3(s1, s2)
}

Future#

Java 1.5 开始，提供了 Callable 和 Future ，可以在任务执行结束时通过 future.get()获得结果，可以同步等待结果返回，写起来非常方便。

fun test_future() {
    val future1 = FutureTask(Callable(task1))
    val future2 = FutureTask(Callable(task2))

    Executors.newCachedThreadPool().execute(future1)
    Executors.newCachedThreadPool().execute(future2)

    task3(future1.get(), future2.get())
}

CompletableFuture#

future.get() 虽然方便，但是会阻塞线程。Java 8 中引入了 CompletableFuture  ，他实现了 Future 接口的同时实现了 CompletionStage 接口。CompletableFuture 可以针对多个 CompletionStage 进行逻辑组合、实现复杂的异步编程。这些逻辑组合的方法以回调的形式避免了线程阻塞：

fun test_CompletableFuture() {
    CompletableFuture.supplyAsync(task1)
        .thenCombine(CompletableFuture.supplyAsync(task2)) { p1, p2 ->
             task3(p1, p2)
        }.join()
}

RxJava#

fun test_Rxjava() {
    Observable.zip(
        Observable.fromCallable(Callable(task1))
            .subscribeOn(Schedulers.newThread()),
        Observable.fromCallable(Callable(task2))
            .subscribeOn(Schedulers.newThread()),
        BiFunction(task3)
    ).test().awaitTerminalEvent()

}

Coroutine#

Coroutine 终于算得上是 Kotlin 特有的工具

fun test_coroutine() {
    runBlocking {
        val c1 = async(Dispatchers.IO) {
            task1()
        }
        val c2 = async(Dispatchers.IO) {
            task2()
        }

        task3(c1.await(), c2.await())
    }
}

Flow#

Flow 就是 Coroutine 版的 RxJava，具备很多 RxJava 的操作符，例如 zip。flowOn 使得 Task 在异步计算并发射结果。

fun test_flow() {
    val flow1 = flow<String> { emit(task1()) }
    val flow2 = flow<String> { emit(task2()) }

    runBlocking {
         flow1.zip(flow2) { t1, t2 ->
             task3(t1, t2)
        }.flowOn(Dispatchers.IO)
        .collect()
    }
}