I have two methods which run on a serial queue. Each method return a copy of some class. I'm trying to achieve thread safety solution while also mainting data integrity.

for example:

```
-(Users *) getAllUsers
{ 
       __block copiedUsers;
       dispatch_sync(_backgroundQueue, ^{
            copiedUsers = [self.users copy]; // return copy object to calling thread.  
       });
       return copiedUsers;
}

-(Orders *) getAllOrders
{ 
       __block copiedOrders;
       dispatch_sync(_backgroundQueue, ^{
            copiedOrders = [self.Orders copy]; // return copy object to calling thread.
       });
       return copiedOrders;
}

```

In addition to this two methods, I have a worker class that add/remove users and orders, all done via a serial queue `backgroundQueue`.

If in the main thread I call `getAllUsers` and then `getAllOrders` right after the other my data integrity isn't safe because between the two calls the worker class might have changed the model. 

my question is how can I make to the caller a nice interface that allows multiple methods to run atomically?