Kotlin 多线程（1）

Kotlin通过封装Java的线程类，简化了线程操作。
可以使用特定的注解，直接使用Java的同步关键字等。

Kotlin中没有 synchronized、volatile关键字；
Kotlin的Any类似于Java的Object，但是没有 wait()、notify()、notifyAll() 方法。

创建线程

1. 使用对象表达式创建线程
2. 使用Lambda表达式创建线程
3. 使用Kotlin封装的 thread() 函数创建线程

		// object 对象表达式,创建一个匿名类，并重写 run() 方法
    object : Thread() {
        override fun run() {
            sleep(200)
            val line = currentThread()
            println("使用 Thread 对象表达式: $line")
            // 输出：使用 Thread 对象表达式: Thread[Thread-0,5,main]
        }
    }.start()

    // 使用Lambda表达式,将Runnable对象传给新创建的Thread对象
    val t0 = Thread {
        Thread.sleep(800)
        val line = Thread.currentThread()
        println("使用Lambda表达式: $line")
        // 输出：使用Lambda表达式: Thread[myThread,3,main]
    }

    t0.isDaemon = false
    t0.name = "myThread"
    t0.priority = 3
    t0.start()

Kotlin将这样的操作 封装简化（简化了样板代码）：

    // 使用Kotlin封装的 thread() 函数创建线程
    thread(start = true, isDaemon = false, name = "myThread_x",priority = 3) {
        Thread.sleep(1000)
        val line = Thread.currentThread()
        println("使用Kotlin封装的 thread() 函数: $line")
        // 输出：使用Kotlin封装的 thread() 函数: Thread[myThread_x,3,main]
    }

thread() 函数的实现：

public fun thread(
    start: Boolean = true,
    isDaemon: Boolean = false,
    contextClassLoader: ClassLoader? = null,
    name: String? = null,
    priority: Int = -1,
    block: () -> Unit
): Thread {
    val thread = object : Thread() {
        public override fun run() {
            block()
        }
    }
    if (isDaemon)
        thread.isDaemon = true
    if (priority > 0)
        thread.priority = priority
    if (name != null)
        thread.name = name
    if (contextClassLoader != null)
        thread.contextClassLoader = contextClassLoader
    if (start)
        thread.start()
    return thread
}

同步方法、同步块

/**
 * 使用 @Synchronized 注解，将方法标记为同步，
 * 作用和Java的 synchronized 关键字相同。
 */
@Synchronized
fun appendFileBytesF(array: ByteArray, destFile: String): Unit {
    val f = File(destFile)
    if (!f.exists()) {
        f.createNewFile()
    }
    f.appendBytes(array)
}

/**
 * 使用 synchronized() 函数，同步代码块
 * 锁是该函数的参数
 */
fun appendFileBytesSync(array: ByteArray, destFile: String): Unit {
    val f = File(destFile)
    if (!f.exists()) {
        f.createNewFile()
    }
    synchronized(mLock) {f.appendBytes(array)}
}

可变字段

Kotlin中没有 volatile 关键字，但是有 @Volatile 注解

// 注解@Volatile 会将JVM备份字段标记为 volatile
@Volatile private var running = false

fun tStart(): Unit {
    running = true
    thread(start = true) {
        var count = 0
        while (running) {
            Thread.sleep(100)
            count++
            val line = Thread.currentThread()
            println("running: $line {$count}")
        }
    }
}

fun tStop(): Unit {
    running = false
    val line = Thread.currentThread()
    println("stopped: $line")
}

// 测试
fun testVolatile(): Unit {
    thread(start = true) {
        tStart()
        Thread.sleep(1200)
        tStop()
    }
}

---

Kotlin中还有更好用的 协程并发库。