Question

我有一个单身人士课程：

class SomeManager {
    static let sharedInstance = SomeManager()

    let serverService  = SomerServerService()
    let musicService = SomeMusicService()
}

我尝试使用

class SomeMusicService
{
  let serverService = SomeManager.sharedInstance.serverService //here seems I get cycle.
}

我应该使用延迟还是其他初始化。

正如您所看到的，let musicService = SomeMusicService()初始化一个对象，然后在同一个对象SomeMusicService中，它会尝试调用sharedInstance单例的SomeManager来获取另一个服务。< / p>

所以这是一个完整的列表：

import Foundation

class ServerService
{
  func downloadMusic()
  {
    print("Download music and play it after that.")
  }
}

class MusicService
{
  let serverService = Singleton.shared.serverService

  func playMusic()
  {
    serverService.downloadMusic()
  }
}

class Singleton
{
  static let shared = Singleton()

  let serverService = ServerService()
  let musicService = MusicService()
}


let s = Singleton.shared
print("Hello, World!")

我们永远不会调用print("Hello, World!")行。

Answer 1

您可以使用weak来避免保留周期，但更好的答案是计算属性：

class SomeMusicService {
    var serverService: SomeService { return SomeManager.sharedInstance.serverService }
}

我从你的更新代码中看到了这个循环是什么。以下是它的表现：

调用Singleton.shared
- 开始构建Singleton
  - 构造ServerService（用于serverService属性）
  - 开始构建MusicService（用于musicService属性）
    - 调用Singleton.shared（对于serverService属性）
    - 阻止等待Singleton.shared完成

该程序现已陷入僵局等待。

正确的答案是使用计算属性，以便在构造期间无需调用Singleton.shared。 lazy属性也可以正常工作，但这似乎很麻烦（并且可能会在服务之间创建保留循环）。

在Swift中使用单例循环

1 个答案: