您真的懂Kotlin里的线程同步吗？

2023-12-15 21:46:57

多线程同步在现代编程中是一个非常重要的概念，它可以确保多个线程之间的数据访问和修改是安全的。Kotlin 提供了多种多线程同步机制，可以帮助您轻松实现线程同步。本文将重点讨论 Kotlin 中的线程同步技术，以便您在面试中轻松回答相关问题。我们还提供了用于处理不同同步场景的示例代码，帮助您更好地理解并使用这些技术。

**1. synchronized **

synchronized 关键字是 Java 和 Kotlin 中最常用的线程同步机制。它可以将一个代码块或方法标记为同步，这意味着在同一时间只能有一个线程执行该代码块或方法。

class Counter {
    private var count = 0

    @Synchronized
    fun increment() {
        count++
    }
}

2. 锁

锁是一种更灵活的线程同步机制，它允许您在代码的不同部分使用相同的锁对象来同步对共享数据的访问。

class Counter {
    private var count = 0
    private val lock = Any()

    fun increment() {
        synchronized(lock) {
            count++
        }
    }
}

3. 原子变量

原子变量是一种特殊的变量，它可以在多线程环境中安全地访问和修改。

class Counter {
    private val count = AtomicInteger(0)

    fun increment() {
        count.incrementAndGet()
    }
}

4. CountDownLatch

CountDownLatch 是一个同步工具，它允许一个线程等待其他线程完成任务。

class CountDownLatch(private val count: Int) {
    private val lock = Any()
    private var remainingCount = count

    fun await() {
        synchronized(lock) {
            while (remainingCount > 0) {
                lock.wait()
            }
        }
    }

    fun countDown() {
        synchronized(lock) {
            remainingCount--
            if (remainingCount == 0) {
                lock.notifyAll()
            }
        }
    }
}

5. CyclicBarrier

CyclicBarrier 是一个同步工具，它允许一组线程等待所有线程都到达某个点。

class CyclicBarrier(private val parties: Int) {
    private val lock = Any()
    private var remainingParties = parties

    fun await() {
        synchronized(lock) {
            remainingParties--
            if (remainingParties == 0) {
                remainingParties = parties
                lock.notifyAll()
            } else {
                lock.wait()
            }
        }
    }
}

6. Semaphore

Semaphore 是一个同步工具，它允许您限制对共享资源的并发访问。

class Semaphore(private val permits: Int) {
    private val lock = Any()
    private var availablePermits = permits

    fun acquire() {
        synchronized(lock) {
            while (availablePermits == 0) {
                lock.wait()
            }
            availablePermits--
        }
    }

    fun release() {
        synchronized(lock) {
            availablePermits++
            lock.notify()
        }
    }
}

7. FutureTask

FutureTask 是一个并发任务，它允许您在任务完成之前获取其结果。

class FutureTask<V>(private val callable: Callable<V>) : Future<V> {
    private val lock = Any()
    private var result: V? = null
    private var isDone = false

    override fun get(): V {
        synchronized(lock) {
            while (!isDone) {
                lock.wait()
            }
            return result!!
        }
    }

    override fun run() {
        synchronized(lock) {
            result = callable.call()
            isDone = true
            lock.notifyAll()
        }
    }
}