深入浅出 Kotlin 协程

于 2023-07-20 15:29:52 发布
阅读量506 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： kotlin log4j 开发语言 java android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_41559503/article/details/131830388
本文介绍了协程的基本概念，起源和发展，以及Java和Kotlin中协程的实现。重点讨论了Kotlin协程的无栈特性、挂起函数、Job管理、协程作用域和分发器。同时，文章还涵盖了协程的取消机制、并发控制和结构化并发编程。最后，提到了协程上下文中的ThreadLocal和分发器的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1. 协程的出现

协程最早诞生于 1958 年，被应用于汇编语言中（距今已有 60 多年了），对它的完整定义发表于 1963 年，协程是一种通过代码执行的恢复与暂停来实现协作式的多任务的程序组件。而与此同时，线程的出现则要晚一些，伴随着操作系统的出现，线程大概在 1967 年被提出。

2. JAVA 对协程的支持

OpenJDK – Loom：其中引入了轻量级和高效的虚拟线程，而且是有栈协程

  • JDK 引入一个新类：java.lang.Fiber。此类与 java.lang.Thread 一起，都成为了 java.lang.Strand 的子类

3. Kotlin 协程

在 JVM 平台上，Kotlin 协程是无栈协程，所谓无栈协程，是指协程在 suspend 状态时不需要保存调用栈。

入门

Hello World

fun main() {
    GlobalScope.launch {
        delay(1000)
        println("Kotlin Coroutine: ${Thread.currentThread().name}")
    }
    println("Hello: ${Thread.currentThread().name}")
    Thread.sleep(2000)
    println("World: ${Thread.currentThread().name}")
}

执行结果：
Hello: main
Kotlin Coroutine: DefaultDispatcher-worker-1
World: main

代码解释：
如果不调用 Thread.sleep，那么 launch 里的代码不会执行，程序就退出了
至于为什么，先不做解释，读到后面自然就找到答案了

runBlocking

fun main() = runBlocking {
    GlobalScope.launch {
        delay(1000)
        println("Kotlin Coroutines")
    }
    println("Hello")
    delay(2000)
    println("World")
}

执行结果：
Hello
Kotlin Coroutines
World

runBlocking 的官方 doc：
运行新的协程并中断阻塞当前线程，直到其完成
不应从协程使用此函数
桥接协程代码和非协程代码，通常用在 main 函数和单元测试

runBlocking 的思考

fun main() = runBlocking {
    GlobalScope.launch {
        delay(2000)
        println("Kotlin Coroutines")
    }
    println("Hello")
    delay(1000)
    println("World")
}

执行结果：
Hello
World

原因分析：
GlobalScope 的 launch 函数返回一个 Job 对象
先来阅读一下 Job 的官方 doc

Job

核心作业接口 – 后台作业

  • 后台作业是一个可以取消的东西，其生命周期最终以 completion 为终点

  • 后台作业可以被安排到父子层次结构中，其中取消父级会导致立即递归取消其 children 所有作业。

  • 另外，产生异常的子协程的失败（CancellationException 除外），将立即取消其父协程，从而取消其所有其他子协程。

  • Job 的最基本的实例接口是这样创建的：

    • Coroutine job 是通过 CoroutineScope 的 launch 构建器创建的，它运行指定的代码块，并在完成此块时完成
    • CompletableJob 是使用 Job（）工厂函数创建的。它通过调用 CompletableJob.complete 来完成。

  • Job states
    在这里插入图片描述

    • 通常，Job 是在 Active state 下创建的。
    • 然而，如果协程构建器提供了可选的启动参数会使协程在新的状态下，当使用 CoroutineStart.LAZY 的时候。此时可以通过调用 start 或者 join 来激活（active） Job
    • 当协程处于工作状态时，Job 是激活状态的，直到其 Completed 或者它失败或者取消
    • CompletableJob.complete 会将 Job 转换为 Completing 状态
    • Completing 状态是 Job 的内部状态，对于外部观察者来说仍然是 Active 状态，而在内部，他正在等待他的子项
      在这里插入图片描述

  • Job 接口及其所有派生接口对于第三方库中的继承并不稳定，因为将来可能会向此接口添加新方法，但可以使用稳定。

协程作用域 - GlobalScope

  • 未绑定到任何 Job 的全局协程作用域
  • 全局作用域用于启动顶级协程，这些协程在整个应用程序生命周期内运行，并且不会过早取消
  • 它启动的协程不会使进程保持活动状态，类似守护线程
  • 这个 API 被声明为微妙的，因为使用时很容易意外创建资源或内存泄漏
  • 在有限的情况下，可以合法且安全地使用它，例如必须在应用程序的整个生命期内保持活跃的任务
  • 那么如何解决上述不执行的问题，本质上是因为 runBlocking 和 GlobalScope.launch 是启动了两个独立的协程作用域，可以通过 Job.join 将两个作用域关联
// runBlocking 作用域
fun main() = runBlocking {
    // GlobalScope.launch 作用域
    val job: Job = GlobalScope.launch {
        delay(1000)
        println("Kotlin Coroutines")
    }
    println("Hello")
    // 同一作用域下, 所有启动的协程全部完成后才会完成
    // 但是, 此处是不同的作用域, 所以一定要 join
    job.join()
    println("World")
}

执行结果：
Hello
Kotlin Coroutines
World
  • 每一个协程构建器都会向其代码块作用域中添加一个 CoroutineScope 实例
  • 在同一个作用域下无需使用 join 函数，直接使用 launch 函数即可
fun main() = runBlocking {
  launch {
    delay(1000)
    println("Kotlin Coroutines")
  }
  println("Hello")
}

执行结果：
Hello
Kotlin Coroutines

coroutineScope 函数

  • 创建一个协程作用域，并且调用具有此作用域的挂起代码块
  • 此函数设计用于并行分解工作。当此作用域中的任何子协程失败时，此作用域将失败，所有其他子项都将被取消
  • 一旦给定块及其所有子协程完成，此函数就会返回
fun main() = runBlocking {
    println(Thread.currentThread().name)
    launch {
        delay(1000)
        println("my job1 -> ${Thread.currentThread().name}")
    }
    println("person -> ${Thread.currentThread().name}")
    coroutineScope {
        launch {
            delay(10 * 1000)
            println("my job2 -> ${Thread.currentThread().name}")
        }
        delay(5 * 1000)
        println("hello world -> ${Thread.currentThread().name}")
    }
    launch {
        println("block? -> ${Thread.currentThread().name}")
    }
    println("welcome -> ${Thread.currentThread().name}")
}

执行结果：
main
person -> main
my job1 -> main
hello world -> main
my job2 -> main
welcome -> main
block? -> main

协程的取消

fun main() = runBlocking {
  val job = GlobalScope.launch {
    repeat(200) {
      println("hello: $it")
      delay(500)
    }
  }

  delay(1100)
  println("Hello World")

  //    job.cancel()
  //    job.join()
  job.cancelAndJoin()

  println("welcome")
}

通过 cancelAndJoin 是 cancel 和 join 两个函数的结合

执行 job.cancelAndJoin()，执行结果为：
hello: 0
hello: 1
hello: 2
Hello World
welcome

执行 job.cancel(), 执行结果为：
hello: 0
hello: 1
hello: 2
Hello World
welcome
#执行结果和上述一致，虽然是不同的作用域

执行 job.join(), 执行结果为：
hello: 0
hello: 1
hello: 2
Hello World
hello: 3
hello: 4
hello: 5
···
hello: 199
  • 协程在执行挂起函数前会检查当前是否是取消状态，如果是，则抛出 CancellationException，例外：如果协程正在处于某个计算过程中，并且没有检查取消状态，那么他是无法被取消的
  • CancellationException
    • 如果协程的作业在挂起时被取消，则由可取消的挂起函数抛出
    • 它表示协程的正常取消
    • 默认情况下，它不会打印到控制台日志中未捕获的异常处理程序
  • CoroutineExceptionHandler：暂不展开
    对于上述例外情况的举例
fun main() = runBlocking {
  val startTime = System.currentTimeMillis()

  val job = launch(Dispatchers.Default) {
    var nextPrintTime = startTime

    var i = 0

    while (i < 20) { // 此处就是处于计算过程中，而且没有检查取消状态，无法取消
      if (System.currentTimeMillis() >= nextPrintTime) {
        println("job: I am sleeping ${i++}")
        nextPrintTime += 500L
      }
    }
  }

  delay(1300)
  println("hello wworld")

  job.cancelAndJoin()
  println("welcome")
}

执行结果：
job: I am sleeping 0
job: I am sleeping 1
job: I am sleeping 2
hello wworld
job: I am sleeping 3
···
job: I am sleeping 19
welcome
  • 有两种方式可以解决上述问题
    1. 周期性的调用一个挂起函数，该挂起函数会检查取消状态，比如使用 yield 函数
    2. 显示的检查取消状态
fun main() = runBlocking {
    val startTime = System.currentTimeMillis()

    val job = launch(Dispatchers.Default) {
        var nextPrintTime = startTime

        var i = 0

        /*while (i < 20) { // 方式1
            if (System.currentTimeMillis() >= nextPrintTime) {
                println("job: I am sleeping ${i++}")
                nextPrintTime += 500L
            }
            yield()
        }*/

        while (isActive) { // 方式2
            if (System.currentTimeMillis() >= nextPrintTime) {
                println("job: I am sleeping ${i++}")
                nextPrintTime += 500L
            }
        }
    }

    delay(1300)
    println("hello wworld")

    job.cancelAndJoin()
    println("welcome")
}
以上两种方式的执行结果：
job: I am sleeping 0
job: I am sleeping 1
job: I am sleeping 2
hello wworld
welcome

使用 finally 来关闭资源

  • 当一个 job 没有执行完，调用了 cancelAndJoin，通常情况下需要有清理动作
  • 另外会抛出 CancellationException
    举例：
fun main() = runBlocking {
  val job = launch {
    try {
      repeat(100) {
        println("job repeat $it")
        delay(500)
      }
    } catch (e: Exception) {
      e.printStackTrace()
    } finally {
      println("execute finally")
    }
  }

  delay(1300)
  println("hello")

  job.cancelAndJoin()
  println("world")
}
输出结果：
job repeat 0
job repeat 1
job repeat 2
hello
execute finally
world
kotlinx.coroutines.JobCancellationException: StandaloneCoroutine was cancelled; job=StandaloneCoroutine{Cancelling}@4f8e5cde
  • 取消协程后，如果依旧调用挂起函数，会抛出异常
    • 抛出 CancellationException
    • 避免这种情况，可使用 withContext 方法，指定协程上下文
fun main() {
  test()
  //testNonCancellable()
}

fun test() = runBlocking {
  val job = launch {
    try {
      repeat(100) {
        println("job repeat $it")
        delay(500)
      }
    } catch (e: Exception) {
      e.printStackTrace()
    } finally {
      println("execute finally")
      delay(1000)
      println("after delay 1000")
    }
  }

  delay(1300)
  println("hello")

  job.cancelAndJoin()
  println("world")
}
执行结果
job repeat 0
job repeat 1
job repeat 2
hello
execute finally
world
kotlinx.coroutines.JobCancellationException: StandaloneCoroutine was cancelled; job=StandaloneCoroutine{Cancelling}@4f8e5cde

fun testNonCancellable() = runBlocking {
  val job = launch {
    try {
      repeat(100) {
        println("job repeat $it")
        delay(500)
      }
    } finally {
      withContext(NonCancellable) {
        println("execute finally")
        delay(1000)
        println("after delay 1000")
      }
    }
  }

  delay(1300)
  println("hello")

  job.cancelAndJoin()
  println("world")
}
执行结果
job repeat 0
job repeat 1
job repeat 2
hello
execute finally
after delay 1000
world
  • withTimeout 函数：kotlinx.coroutines.TimeoutCancellationException
  • withTimeoutOrNull 函数：返回 null，不抛出异常

挂起函数

函数组合

  • 挂起函数可以像普通函数一样在协程中
  • 挂起函数可以使用其他的挂起函数
  • 挂起函数只能用在协程中或是另一个挂起函数中
fun main() = runBlocking {
    val elapsedTime = measureTimeMillis {
        val value1 = intValue1()
        val value2 = intValue2()
        println("$value1 + $value2 = ${value1 + value2}")
    }
    println("total time: $elapsedTime")
}

private suspend fun intValue1(): Int {
    delay(2000)
    return 15
}

private suspend fun intValue2(): Int {
    delay(3000)
    return 20
}
输出结果：
15 + 20 = 35
total time: 5010

async 和 await

  • 通过这两个函数可以实现并发
  • 从概念上讲，async 和 launch 一样，他会开启一个单独的协程
  • 区别是，launch 返回的是一个 Job，Job 并不会持有任何结果值；async 会返回一个 Deferred，类似 future 和 promise，持有一个结果值
  • 通过在 Deferred 上调用 await 方法获取最终的结果值
  • Deferred 是 Job 的子类，是非阻塞的，可取消的 future
fun main() = runBlocking {
  val elapsedTime = measureTimeMillis {
    val s1 = async { intValue1() }
    val s2 = async { intValue2() }

    val value1 = s1.await()
    val value2 = s2.await()

    println("$value1 + $value2 = ${value1 + value2}")
  }
  println("total time: $elapsedTime")
}

private suspend fun intValue1(): Int {
  delay(2000)
  return 15
}

private suspend fun intValue2(): Int {
  delay(3000)
  return 20
}
执行结果：
15 + 20 = 35
total time: 3018

和 Job 一样，Deferred 如果启动参数设置为 CoroutineStart.LAZY，那么同样需要先激活，Deferred 比 Job 多了一个可以激活状态的方法：await

fun main() = runBlocking {
  val elapsedTime = measureTimeMillis {
    val s1 = async(start = CoroutineStart.LAZY) {
      intValue1()
    }
    val s2 = async(start = CoroutineStart.LAZY) {
      intValue2()
    }
    println("hello world")
    Thread.sleep(2500)
    delay(2500)

    val value1 = s1.await()
    val value2 = s2.await()

    println(value1 + value2)
  }
  println("total time: $elapsedTime")
}

private suspend fun intValue1(): Int {
  delay(2000)
  return 15
}

private suspend fun intValue2(): Int {
  delay(3000)
  return 20
}
执行结果
hello world
35
total time: 10032

结构化并发程序开发

fun main() = runBlocking {
  val elapsedTime = measureTimeMillis {
    println("intSum: ${intSum()}")
  }
  println("total time: $elapsedTime")
}

private suspend fun intSum(): Int = coroutineScope<Int> {
  val s1 = async { intValue1() }
  val s2 = async { intValue2() }
  s1.await() + s2.await()
}

private suspend fun intValue1(): Int {
  delay(2000)
  return 15
}

private suspend fun intValue2(): Int {
  delay(3000)
  return 20
}
执行结果
intSum: 35
total time: 3016

协程上下文

分发器

  • 协程总是会在某个上下文中执行，这个上下文是由 CoroutineContext 类型的实例来表示的
  • CoroutineContext 的继承关系如下

在这里插入图片描述

  • 协程上下文本质上是各种元素所构成的一个集合，主要元素包括 Job 以及 CoroutineDispatcher
  • CoroutineDispatcher 的主要功能是确定协程由哪个线程来执行所指定的代码，可以限制到一个具体的线程，也可以分发到一个线程池中，还可以不加任何限制（这种情况下代码执行的线程是不确定的，开发中不建议使用）
  • 所有的协程构建器（如 launch 和 async）的方法可选参数中可以指定一个 CoroutineContext
fun main() = runBlocking<Unit> {
  launch {
    println("no param, thread: ${Thread.currentThread().name}")
  }

  launch(Dispatchers.Unconfined) {
    println("dispatchers unconfined, thread: ${Thread.currentThread().name}")
    delay(100) // 加上延迟，就会发现不是运行在main线程了
    println("dispatchers unconfined, thread: ${Thread.currentThread().name}")
  }

  launch(Dispatchers.Default) {
    println("dispachers default, thread: ${Thread.currentThread().name}")
  }

  val dispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
  launch(dispatcher) {
    println("single thread executor service, thread: ${Thread.currentThread().name}")
    dispatcher.close()
  }

  GlobalScope.launch {
    println("globle scope launch, thread: ${Thread.currentThread().name}")
  }
}
执行结果：
dispatchers unconfined, thread: main
dispachers default, thread: DefaultDispatcher-worker-1
single thread executor service, thread: pool-1-thread-1
globle scope launch, thread: DefaultDispatcher-worker-1
no param, thread: main
dispatchers unconfined, thread: kotlinx.coroutines.DefaultExecutor
  • 当通过 launch 来启动协程且不指定协程分发器时，它会继承启动它的那个 CoroutineScope 的上下文与分发器，对该示例来说，它会继承 runBlocking 的上下文，而 runBlocking 则是运行在 main 线程当中
  • Dispatchers.Unconfined 是一种很特殊的协程分发器，它在该示例中一开始是 main 线程，但是后来线程发生变化
  • Dispatchers.Default 是默认的分发器，当协程是通多 GlobalScope 来启动的时候，它会使用该默认的分发器来启动协程，它会使用一个后台的共享线程池来运行我们的协程代码。因此，launch（Dispatchers.Default） 等价于（这里只说线程， 作用域是不同的） GlobalScope.launch { }
  • asCoroutineDispatcher Kotlin 提供的扩展方法，使得线程池来执行我们所指定的协程代码。在实际开法中，使用专门的线程池来执行协程代码代价是非常高的，因此在协程代码执行完毕后，我们必须要释放相应的资源，这里就需要使用 close 方法来关闭相应的协程分发器，从而释放资源；也可以将该协程分发器存储到一个顶层变量中，以便在程序的其他地方进行复用
  • asCoroutineDispatcher 如果指定的线程池是 ScheduledExecutorService，那么 delay、withTimeout、Flow 等所有时间相关的操作会在此线程池上计算；如果指定的线程池是 ScheduledThreadPoolExecutor，那么还会设置 setRemoveOnCancelPolicy 来减小内存压力；如果指定的线程池不是上述类型，时间相关的操作将在其他线程计算，但协程本身仍将在给定的执行器之上执行；如果指定线程池引发 RejectedExecutionException，则会取消受影响的 Job，并提交到 Dispatchers.IO 以便受影响的协程可以清理其资源并迅速完成
fun main() = runBlocking<Unit> {
  val singleDispatcher = ThreadPoolExecutor(
    1,
    1,
    0,
    TimeUnit.SECONDS,
    ArrayBlockingQueue(1)
  ).asCoroutineDispatcher()
  repeat(10) {
    launch(singleDispatcher) {
      try {
        delay(100)
        println("${Thread.currentThread().name} - $it")
      } catch (e: Exception) {
        println(e.message)
      } finally {
        println("${Thread.currentThread().name} - finally")
      }
    }
  }
}
执行结果：
pool-1-thread-1 - 0
pool-1-thread-1 - finally
The task was rejected
DefaultDispatcher-worker-1 - finally
pool-1-thread-1 - 3
pool-1-thread-1 - finally
The task was rejected
DefaultDispatcher-worker-1 - finally
pool-1-thread-1 - 6
pool-1-thread-1 - finally
The task was rejected
DefaultDispatcher-worker-1 - finally
pool-1-thread-1 - 9
pool-1-thread-1 - finally

调试

  • Kotlin 协程可开启 debug 参数，通过 JVM option 指定：-Dkotlinx.coroutines.debug
  • 我们可以发现，打印线程名的时候，也会把协程名称打印出来
private fun log(msg: String) {
  println("[${Thread.currentThread().name}] - $msg")
}

fun main() = runBlocking {
  val s1 = async {
    delay(2000)
    log("hello world")
    10
  }

  val s2 = async {
    log("welcome")
    20
  }

  log("The result is ${s1.await() + s2.await()}")
}
执行结果：
[main @coroutine#3] - welcome
[main @coroutine#2] - hello world
[main @coroutine#1] - The result is 30

/////////////////////////////////////////////////////

private fun log(msg: String) {
    println("[${Thread.currentThread().name}] - $msg")
}

fun main() {
    newSingleThreadContext("Context1").use { ctx1 ->
        newSingleThreadContext("Context2").use { ctx2 ->
            runBlocking(ctx1) {
                log("started in context1")

                withContext(ctx2) {
                    log("working in context2")
                }

                log("Back to context1")
            }
        }
    }
}
执行结果：
[Context1 @coroutine#1] - started in context1
[Context2 @coroutine#1] - working in context2
[Context1 @coroutine#1] - Back to context1

通过查看 CoroutineContext 的继承关系和源码得知，每一个 Element 都有一个名为 Key 的半生对象

fun main() = runBlocking {
    val job: Job? = coroutineContext[Job]
    println(job)
    println(coroutineContext.isActive)
}
执行结果
BlockingCoroutine{Active}@4459eb14
true

ThreadLocal
asContextElement 扩展方法可以转换成 CoroutineContext 对象

val threadLocal = ThreadLocal<String>()

private fun printCurrentThreadValue(info: String) {
  println("$info, ${Thread.currentThread().name}, local value is: ${threadLocal.get()}")
}

fun main() = runBlocking {
  val newDispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
  threadLocal.set("Main Value")
  printCurrentThreadValue("start main")

  val job = launch(Dispatchers.Default + threadLocal.asContextElement("Coroutine Value")) {
    printCurrentThreadValue("launch a coroutine")
    yield()
    printCurrentThreadValue("coroutine after yield")
    launch {
      printCurrentThreadValue("run in child")
    }
    launch(newDispatcher) {
      printCurrentThreadValue("run in new thread")
    }
  }
  val job2 = launch(Dispatchers.Default) {
    printCurrentThreadValue("run in other coroutine")
  }
  val job3 = launch {
    printCurrentThreadValue("run in other2 coroutine")
  }

  job.join()
  job2.join()
  job3.join()
  newDispatcher.close()

  printCurrentThreadValue("end main")
}
执行结果：
start main, main, local value is: Main Value
launch a coroutine, DefaultDispatcher-worker-1, local value is: Coroutine Value
coroutine after yield, DefaultDispatcher-worker-1, local value is: Coroutine Value
run in child, DefaultDispatcher-worker-2, local value is: Coroutine Value
run in other coroutine, DefaultDispatcher-worker-2, local value is: null
run in new thread, pool-1-thread-1, local value is: Coroutine Value
run in other2 coroutine, main, local value is: Main Value
end main, main, local value is: Main Value

可以发现 ThreadLocal 通过使用 asContextElement 方法，协程之间共享数据遵循协程作用域的范围。

5. 参考资料

https://github.com/JetBrains/kotlin

6. 团队介绍

「三翼鸟数字化技术平台-智家APP平台」 通过持续迭代演进移动端一站式接入平台为三翼鸟APP、智家APP等多个APP提供基础运行框架、系统通用能力API、日志、网络访问、页面路由、动态化框架、UI组件库等移动端开发通用基础设施；通过Z·ONE平台为三翼鸟子领域提供项目管理和技术实践支撑能力，完成从代码托管、CI/CD系统、业务发布、线上实时监控等Devops与工程效能基础设施搭建。

博客
鸿蒙平台运行Lua脚本
07-24 585
使用 rust 在移动端实现 Lua 脚本的运行
博客
从Bug到解决方案：一个Java工程师与Emoji的“爱恨情仇“
07-15 289
处理用户输入，要像对待情人节礼物一样——永远不知道盒子里装的是什么，但必须准备好应对任何可能。
博客
提升开发思维的设计模式（下）
06-26 1087
设计模式就是解决编程里某类问题的通用模板，总结出来的代码套路就是设计模式。本文章总结JS在工作中常用的设计模式 ，以帮助大家提高代码性能，增强工作效率！
博客
提升开发思维的设计模式（上）
06-13 727
总结JS在工作中常用的设计模式
博客
Java 21介绍
05-29 1242
JDK 21 凭借 LTS 版本地位、虚拟线程、性能优化及语言增强，将成为未来 Java 生态的核心
博客
Android应用内存分析与优化 - 工具篇之ByteX
05-22 875
ByteX由字节跳动抖音 Android 团队提供，是一个基于gradle transform api和ASM的字节码插件平台。
博客
Android应用内存分析与优化 - 工具篇之Booster
05-16 1055
本文介绍了滴滴开源的Booster工具，该工具旨在优化移动应用的性能、稳定性和包体积。Booster通过提供性能检测、多线程优化、资源压缩等功能，能够显著提升应用稳定性并减小包体积。
博客
Android应用内存分析与优化 - 理论篇
04-17 919
内存出现问题的地方仅仅只是一个表现的地方，并非深层次的原因。
博客
Vue自定义指令最佳实践教程
04-03 476
Vue 3 显著增强了自定义指令的功能，使其封装更加灵活和易用。
博客
QWen 和 DeepSeek 入门指南
03-20 1113
即便是不会开发AI模型，也必须逐步了解其中的某些概念和一些原理。
博客
一文搞清楚Cursor的Tab到底强大在哪里
03-06 866
什么是AI IDE的核心竞争力？
博客
svg绘图知多少
02-20 1279
SVG是什么？有什么优点？SVG可以为我们开发提供什么便利？
博客
SharedFlow在海尔屏端智家App中的应用实践
02-06 798
底层引擎与上层UI如何流畅地传递数据？
博客
技术团队如何保障运营活动顺利进行？
01-23 846
技术团队如何保障运营活动顺利进行？
博客
hi-element 入门指南
01-09 841
有效地解决网站和应用程序设计和开发中的一些最常见的挑战。
博客
模型工作流：自动化的模型内部三角面剔除
12-26 1569
三维模型的减面工作需要耗费大量的人力成本，通常一个模型的减面工作根据模型的复杂程度不同，需要耗费0.5到1人/天的成本，如果模型特别复杂，这个时间还会增加。因此，自动化减面工具的引入能极大提升建模人员的工作效率。
博客
模型工作流：模型减面原理分析及优化思路
12-13 791
为什么会破面？QEM 的计算逻辑是什么？如何确定一个边是属于轮廓的？为什么当 QEM 对轮廓动手后，就会产生破面呢？把轮廓边界上的点与周围的点焊接到一起，就能解决破面问题吗？
博客
Android电视项目焦点跨层级流转
11-29 1299
在电视项目中焦点、选中、确定、返回这几个交互比较重要
博客
Flutter CustomScrollView 效果-顶栏透明与标签栏吸顶
10-31 2116
TabBar怎么吸顶？为什么SliverOverlapAbsorber高度会被忽略?
博客
图形学系列文章：全局光照的上层理解
10-18 880
建模时模型在不同环境有着不同的颜色怎么办？
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值