使用多线程

线程

线程允许同时执行代码。它允许从主线程卸载工作。

Godot 支持线程，并提供了许多方便使用的功能。

备注

如果使用其他语言（C#、C++），它们支持的线程类可能会更容易使用。

警告

在线程中使用内置类之前，请先阅读 线程安全的 API，检查在线程中使用是否安全。

创建线程

创建一个线程非常简单, 只需使用以下代码:

GDScript

  1. var thread
  3. # The thread will start here.
  4. func _ready():
  5.     thread = Thread.new()
  6.     # Third argument is optional userdata, it can be any variable.
  7.     thread.start(self, "_thread_function", "Wafflecopter")
  10. # Run here and exit.
  11. # The argument is the userdata passed from start().
  12. # If no argument was passed, this one still needs to
  13. # be here and it will be null.
  14. func _thread_function(userdata):
  15.     # Print the userdata ("Wafflecopter")
  16.     print("I'm a thread! Userdata is: ", userdata)
  18. # Thread must be disposed (or "joined"), for portability.
  19. func _exit_tree():
  20.     thread.wait_to_finish()

然后, 你的函数将在一个单独的线程中运行, 直到它返回. 即使函数已经返回, 线程也必须收集它, 所以调用 Thread.wait_to_finish() , 它将等待线程完成(如果还没有完成), 然后妥善处理它.

Mutex

并不总是支持从多个线程访问对象或数据(如果你这样做, 会导致意外行为或崩溃). 请阅读 线程安全的 API 文档, 了解哪些引擎API支持多线程访问.

在处理自己的数据或调用自己的函数时, 通常情况下, 尽量避免从不同的线程直接访问相同的数据. 你可能会遇到同步问题, 因为数据被修改后,CPU核之间并不总是更新. 当从不同线程访问一个数据时, 一定要使用 Mutex .

当调用 Mutex.lock() 时, 一个线程确保所有其他线程如果试图 锁 同一个mutex, 就会被阻塞(进入暂停状态). 当通过调用 Mutex.unlock() 来解锁该mutex时, 其他线程将被允许继续锁定(但每次只能锁定一个).

下面是一个使用 Mutex 的例子:

GDScript

  1. var counter = 0
  2. var mutex
  3. var thread
  6. # The thread will start here.
  7. func _ready():
  8.     mutex = Mutex.new()
  9.     thread = Thread.new()
  10.     thread.start(self, "_thread_function")
  12.     # Increase value, protect it with Mutex.
  13.     mutex.lock()
  14.     counter += 1
  15.     mutex.unlock()
  18. # Increment the value from the thread, too.
  19. func _thread_function(userdata):
  20.     mutex.lock()
  21.     counter += 1
  22.     mutex.unlock()
  25. # Thread must be disposed (or "joined"), for portability.
  26. func _exit_tree():
  27.     thread.wait_to_finish()
  28.     print("Counter is: ", counter) # Should be 2.

Semaphore

有时你希望你的线程能“按需”工作。换句话说，告诉它什么时候工作，让它在不工作的时候暂停。为此，可以使用信号量 Semaphore。线程中使用函数 Semaphore.wait() 来暂停它的工作，直到有数据到达。

而主线程则使用 Semaphore.post() 来表示数据已经准备好被处理:

GDScript

  1. var counter = 0
  2. var mutex
  3. var semaphore
  4. var thread
  5. var exit_thread = false
  8. # The thread will start here.
  9. func _ready():
  10.     mutex = Mutex.new()
  11.     semaphore = Semaphore.new()
  12.     exit_thread = false
  14.     thread = Thread.new()
  15.     thread.start(self, "_thread_function")
  18. func _thread_function(userdata):
  19.     while true:
  20.         semaphore.wait() # Wait until posted.
  22.         mutex.lock()
  23.         var should_exit = exit_thread # Protect with Mutex.
  24.         mutex.unlock()
  26.         if should_exit:
  27.             break
  29.         mutex.lock()
  30.         counter += 1 # Increment counter, protect with Mutex.
  31.         mutex.unlock()
  34. func increment_counter():
  35.     semaphore.post() # Make the thread process.
  38. func get_counter():
  39.     mutex.lock()
  40.     # Copy counter, protect with Mutex.
  41.     var counter_value = counter
  42.     mutex.unlock()
  43.     return counter_value
  46. # Thread must be disposed (or "joined"), for portability.
  47. func _exit_tree():
  48.     # Set exit condition to true.
  49.     mutex.lock()
  50.     exit_thread = true # Protect with Mutex.
  51.     mutex.unlock()
  53.     # Unblock by posting.
  54.     semaphore.post()
  56.     # Wait until it exits.
  57.     thread.wait_to_finish()
  59.     # Print the counter.
  60.     print("Counter is: ", counter)