Kotlin常用同步方法

Kotlin常用同步实现方法：
1.使用synchronized关键字
2.使用ReentrantLock
3.使用原子操作
4.使用线程安全集合
5.使用信号量Semaphore
6.使用读写锁ReentrantReadWriteLock
7.使用条件变量:Condition一般与ReentrantLock一起使用

//使用synchronized关键字
class Number1{
    private var number = 0

    @Synchronized
    fun increment(){ //自增
        number++
    }

    @Synchronized
    fun getCount():Int{
        return number
    }
}

//使用ReentrantLock
class Number2{
    private var number = 0
    private val lock = ReentrantLock();
    fun increment(){
        lock.lock()
        try {
            number++
        } finally {
            lock.unlock()
        }
    }

    fun getCount():Int{
        lock.lock()
        try {
            return number
        } finally {
            lock.unlock()
        }
    }
}

//使用原子操作
class Number3 {
    private var number = AtomicInteger(0)
    fun increment() {
        number.incrementAndGet()
    }

    fun getCount(): Int {
        return number.get()
    }

}


//使用线程安全集合
class Number4{
    private var numberMap = ConcurrentHashMap();
    fun increment(key:String){
        //ConcurrentHashMap.put方法直接将指定的值与此映射中的指定键关联。如果映射中已经存在该键，则替换其值。
        //ConcurrentHashMap.compute方法则接受一个函数作为参数，该函数用于计算新值。如果映射中已经存在该键，则使用函数计算新值并替换旧值；如果映射中不存在该键，则使用函数计算新值并将其插入映射中。
        //put和compute方法都是原子操作，因此可以在多线程环境下安全地使用。

      //  numberMap.put(key, numberMap[key]?.plus(1) ?: 1)
        numberMap.compute(key){_,value ->
            value?.plus(1) ?: 1
        }
    }

    fun getCount(key:String):Int{
        return numberMap[key] ?: 0  //?: 如果左侧表达式为null，则返回右侧表达式的值
    }

}
//使用信号量Semaphore
class Number5{
    private val semaphorore = Semaphore(1)
    private var number = 0;
    fun increment(){
        semaphorore.acquire()
        try {
            number++
        } finally {
            semaphorore.release()
        }
    }

    fun getCount():Int{
        semaphorore.acquire()
        try {
            return number
        } finally {
            semaphorore.release()
        }
    }
}

//使用读写锁ReentrantReadWriteLock
class Number6{
    private val lock = ReentrantReadWriteLock()
    private var number = 0
    fun increment(){
        lock.writeLock().lock()
        try {
            number++
        } finally {
            lock.writeLock().unlock()
        }
    }

    fun getCount():Int{
        lock.readLock().lock()
        try {
            return number
        } finally {
            lock.readLock().unlock()
        }
    }
}

// 使用条件变量:Condition一般与ReentrantLock一起使用
class   Number7{
    private val lock = ReentrantLock()
    private val condition = lock.newCondition()
    private var number = 0
    fun increment(){
        lock.lock()
        try {
            number++
            condition.signalAll()
        }  finally {
            lock.unlock()
        }
    }

    fun getCount():Int{
        lock.lock()
        try {
            while (number == 0){
                condition.await()
            }
            return number
        } finally {
            lock.unlock()
        }
    }
}

fun main() {
    val number1 = Number1()
    val number2 = Number2()
    val number3 = Number3()
    val number4 = Number4()
    val number5 = Number5()
    val number6 = Number6()
    val number7 = Number7()
    number1.apply {
        increment()
        println(getCount())
    }
    number2.apply {
        increment()
        println(getCount())
    }
    number3.apply {
        increment()
        println(getCount())
    }
    number4.apply {
        increment("number")
        println(getCount("number"))
    }
    number5.apply {
        increment()
        println(getCount())
    }
    number6.apply {
        increment()
        println(getCount())
    }
    number7.apply {
        increment()
        println(getCount())
    }

}
返回结果：
1
1
1
1
1
1
1