相关疑难解决方法(0)

异步和同步执行有什么区别？

谁能解释一下是NSRunLoop什么？所以我知道这NSRunLoop是一件与之相关的事情NSThread吗？所以假设我创建一个类似的线程

NSThread* th=[[NSThread alloc] initWithTarget:self selector:@selector(someMethod) object:nil];
[th start];

-(void) someMethod
{
    NSLog(@"operation");
}

在这个线程完成他的工作之后？为什么使用RunLoops或在哪里使用？从Apple docs我已经阅读了一些东西,但对我来说并不清楚,所以请尽可能简单地解释

我经常发现这些术语在并发编程的上下文中使用.它们是相同的还是不同的？

我一直在使用DispatchQueue.main.async很长一段时间来执行一些与UI相关的操作.但Swift提供了DispatchQueue.main.async和DispatchQueue.main.sync,两者都在主队列中执行.那么有谁可以告诉我他们之间的区别？我什么时候应该使用它们？先感谢您.

DispatchQueue.main.async {
    self.imageView.image = imageView
    self.lbltitle.text = ""

}

DispatchQueue.main.sync {
    self.imageView.image = imageView
    self.lbltitle.text = ""
}

我熟悉AsyncTaskAndroid中的使用:创建子类,调用子类execute的实例,并onPostExecute在UI线程或主线程上调用.什么是iOS中的等价物？

在最长的时间里,我认为异步是在后台线程上运行某些东西的同义词,而同步意味着在主线程上(阻止UI更新和交互).我明白,不在主线程上运行昂贵的操作是因为它不允许在主线程被占用时发生UI操作,但为什么同步麻烦？

但是,我注意到你可以在主线程上进行异步调用,在后台线程上进行同步调用.

我总是听到人们说不要同步或在主线程上使用昂贵的调用,因为它会阻止用户的UI.这两个不同的问题我应该确保我不这样做吗？有什么区别？

我收到了这个错误:

线程1:EXC_BAD_INSTRUCTION(代码= EXC_I386_INVOP,子代码= 0x0)

我怎么解决这个问题？代码工作正常,但在计算器中,当我单击唯一相等的按钮时,它会给出该错误.

@IBAction func equals(sender: AnyObject) {

    secondNumber = Screen.text!.toInt()!  // here it shows an error which is "Thread 1:EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0)"

    if operation == "+"{
        result = firstNumber + secondNumber
    }
    else if operation == "-" {
        result = firstNumber - secondNumber
    }
    else if operation == "x" {
        result = firstNumber * secondNumber
    }
    else {
        result = firstNumber / secondNumber
    }
    Screen.text = "\(result)"
}

在Swift中,我有时会使用这种模式.

DispatchQueue.global().async {
    // do stuff in background, concurrent thread

    DispatchQueue.main.sync {
        // update UI
    }
}

这种模式的目的很明确.在全局线程中进行耗时的计算,因此UI未被锁定,并且在计算完成后更新主线程中的UI.

如果没有什么可计算的怎么办？我刚刚在我的项目中发现了一个逻辑

//A
DispatchQueue.main.sync {
    // do something
}

崩溃但是

// B
DispatchQueue.global().async {
    DispatchQueue.main.sync {
        // do something
    }
}

没有崩溃.

他们有什么不同？案例B是否与此不同？

// C
DispatchQueue.main.async {
    // do something
}

还有一个问题.我知道主线程是串行队列,但如果我多个运行多个代码块main.async,它就像并发队列一样.

DispatchQueue.main.async {
    // do A
}

DispatchQueue.main.async {
    // do B
}

如果主线程实际上是一个串行队列,它们如何同时运行？如果它只是一个时间切片而不是它们与全局并发队列的不同而不是主线程可以更新UI？

我有和应用程序有一个单一的存储整个应用程序的信息.但是,当使用来自不同线程的单例时,这会产生一些数据争用问题.

这里有一个非常虚拟和简单化的问题版本:

独生子

class Singleton {
    static var shared = Singleton()

    var foo: String = "foo"
}

单例的使用(为简单起见,来自AppDelegate)

class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?


    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.

        DispatchQueue.global().async {
            var foo = Singleton.shared.foo // Causes data race
        }

        DispatchQueue.global().async {
            Singleton.shared.foo = "bar"   // Causes data race
        }

        return true
    }
}

有没有办法确保单例是线程安全的,所以它可以在应用程序的任何地方使用,而不必担心你在哪个线程？

这个问题不是在Swift中使用dispatch_once单例模型的重复,因为(如果我理解正确的话)那里他们正在解决访问单例对象本身的问题,但不能确保其属性的读写完成线程安全.

我经常碰到“线程安全”这两个关键术语，想知道这意味着什么。例如，在Firebase或Realm中，某些对象被视为“线程安全”。线程安全的东西到底意味着什么？