Kotlin中的线程安全

一、背景

线程安全问题由全局变量和静态变量引起，多个线程同时对统同一对象进行写操作，就可能发生每个线程读取到的值不一样。简而言之，如果在线程中不对变量进行写操作，值进行读操作，就可以避免线程安全。

二、加锁

锁可以分为实例锁和全局锁，通用的方法有Synchronized关键字和Lock方法进行加锁

实例锁：对某一个对象加锁，如果该对象的类的单例类，将同时也和全局锁一样
全局锁：对某一类加锁，该类的所有对象都会加锁，持有类锁的线程将会同时持有全部对象的锁

三、Synchronized

我们复习一下java中的Synchronized关键字：

Synchronized关键字可以保证加锁对象在多线程环境下同时只有一个线程能够执行，在当前线程释放对象锁之后其他线程才能获取。synchronized同时能够保证共享变量的可见性。

基本规则：

• 对于普通方法，锁的是当前对象
• 对于静态方法，锁的是class类
• 对于代码块加锁，锁的是代码块内对象

一个线程访问对象的synchronized区域时，其他线程访问该对象synchronized区域将会阻塞，但是其他线程可以访问该对象的非同步区域。

1、kotlin中的synchronized使用

对方法加锁的时候只需要加上@Synchronized 注解就Ok了,比如我们定义了以下方法：

@Synchronized
private fun postResult(s: String){
    println("${System.currentTimeMillis()} ：$s" )
    sleep(5000)
}

对类加锁首先我们创建一个Result类：

class Result {

    var s : String = ""

    public fun printResult(){
        println("${System.currentTimeMillis()} ：$s" )
        Thread.sleep(5000)
    }
}

调用：

fun testClassSync() {
    val result= Result()


    Thread{
        synchronized(result){
            result.s = currentThread().name
            result.printResult()
        }
    }.apply {
        name = "first thread"
        start()
    }

    Thread{
        synchronized(result){
            result.s = currentThread().name
            result.printResult()
        }
    }.apply {
        name = "second thread"
        start()
    }

}

四、Lock

lock是一个接口，我们常用的实现类有ReentrantLock，意思是可重入锁。

我们定义一个全局变量，在两个线程中同时进行写操作，同时start两个线程

fun testLockSync() {

    var count = 0

    val thread1 = Thread{
        for (i in 0..1000){
            count += i
        }
        println("${Thread.currentThread().name} : count:${count}")
    }

    val thread2 = Thread{
        for (i in 0..1000){
            count += i
        }
        println("${Thread.currentThread().name} : count:${count}")
    }

    //同时开启两个线程
    thread1.start()
    thread2.start()
}

输出结果：会发现每次输出的结果都不一样

Thread-1 : count:505253
Thread-2 : count:1001000
---
Thread-2 : count:1001000
Thread-1 : count:1001000
---
Thread-2 : count:822155
Thread-1 : count:822155

使用ReentrantLock保证线程安全：

fun testLockSync() {

    val lock = ReentrantLock()
    var count = 0

    val thread1 = Thread{
        lock.lock()

        for (i in 0..1000){
            count += i
        }
        println("${Thread.currentThread().name} : count:${count}")

        lock.unlock()
    }

    val thread2 = Thread{
        lock.lock()

        for (i in 0..1000){
            count += i
        }
        println("${Thread.currentThread().name} : count:${count}")
        
        lock.unlock()
    }
    
    thread1.start()
    thread2.start()
}

输出结果和执行顺序每次都是一样：

Thread-1 : count:500500
Thread-2 : count:1001000

Lock常用方法

• lock() ：获取锁，获取成功设置当前线程count++，如果其他线程占有锁，则当前线程不可用，等待。
• tryLock() : 获取锁，如果锁不可用，则此方法将立即返回，线程不阻塞，可设置等待时间。
• unLock() : 尝试释放锁，当前thread count–,如果count为0，则释放锁。