Do I need capture self using thread class?

Question

I have this code:

myThreadTemp = Thread(target: self, selector: #selector(threadMain), object: nil)

 @objc func threadMain(data: AnyObject) {
        let runloop = RunLoop.current
        runloop.add(NSMachPort(), forMode: RunLoopMode.defaultRunLoopMode)
        while !Thread.current.isCancelled{
                //foreground
                DispatchQueue.main.async {[weak self] in

                self?.somemethod()
                self?.somevar = 1
                    print("tick")
                }
            if Thread.current.isCancelled {

            }
            Thread.sleep(forTimeInterval: 1.0)
        }
        runloop.run(mode: RunLoopMode.defaultRunLoopMode, before: NSDate.distantFuture)

    }

or I can just do this:

DispatchQueue.main.async {
                self.somemethod()
                self.somevar = 1
                    print("tick")
                }

I saw this:

Shall we always use [unowned self] inside closure in Swift

But was if @objc func is used?

Answer 1

The 1st example looks to spin the runloop indefinitely, waiting 1s between ticks, whereas the 2nd example will execute once, on the very next run loop iteration. There is no memory management issue in terms of capturing self in the 2nd case, indeed because it is only executed once and the block is released after it (breaking the momentary retain loop that does exist between self and the block).

Assuming you are trying to tick every 1s (as I am guessing based on your questions), there is a better way to do what you are trying to do, using a timer:

// Must be executed on main thread, or other NSRunLoop enabled thread, 
// or the below code will silently do nothing.
self.timer = Timer(timeInterval: 1.0, repeats: true) { [weak self] _ in
    self?.someMethod()
    self?.someVar = 1
    print("tick")
}

// Somewhere in the future, to stop the timer:
// self.timer.invalidate()

As you can see in the above example, with the timer case you might indeed want to refer to self with either an unowned or weak reference (as the timer block will otherwise make a strong reference to self, and self to the timer). The block should be released on invalidating the timer too, so even in this case the weak reference is not 100% necessary I guess.