Keeping reference to object when creating a closure and storing it

Question

I have a question about how references to objects are handled in closures in specific example. The code below is simplified to demonstrate the idea

class SomeObject {
    init(value: Int) {
        self.value = value
    }
    var value: Int {
        didSet {
            valueObservers.forEach { $0(value) }
        }
    }
    var valueObservers = [(Int) -> Void]()
}

class TestClass {

    let obj1 = SomeObject(value: 1)
    let obj2 = SomeObject(value: 2)
    let obj3 = SomeObject(value: 3)

    func valueOfObjectChanged(object: SomeObject) {
        print("Value of object \(object) is \(object.value)")
    }

    init() {
        let objects = [obj1, obj2, obj3]
        objects.forEach { (object) in
            object.valueObservers.append { [unowned self] (_) in
                self.valueOfObjectChanged(object: object)
            }
        }
    }
}

So we have here a class SomeObject which can store an array of closures which will be executed when value of its variable changes. TestClass creates a few of these objects, then makes array from this objects, and for every object in this array it adds a closure that will execute a function of TestClass when a value of any of these SomeObjects changes.

OK now inside this function that can be triggered by any of created objects, I want to be sure that I know which object did actually caused it to execute. The reference is passed in function execution, but note that object here is get from a loop and passed to the closure (closure which will execute valueOfObjectChanged and pass object reference as parameter).

What's the problem with that - I'm not sure if the reference to object will actually be kept for correct object, as this closure is executed somewhere completely different then when the closure was created.

I can't put object in this closure capture list, because this causes Segmentation fault: 11.

I'm not sure how the closure would behave in this situation - will reference to object be kept, or can it be wrong?

I could also add the caller in definition of valueObservers, but this is something I would like to avoid because of current structure of the app (the example is just a simplification).

So my question is - is the reference to object under object.valueObservers.append always correct, and points to the object, that changed it's value, or is it incorrect, and for example points to the last object that was iterated in objects.forEach or even something else?