Grails - MongoDB Gorm Plugin - Race Condition - Pessimistic Locking Solution? Semaphore? - mongodb

Question

I currently have a couple of Grails applications using a single MongoDB replica set for some shared information. Recently, a race condition reproducibly occurred where:
A user performed an action on a front-end that started a back-end process
Part of the back-end process involved saving a new status on two domain objects
The back-end process generated a message to an outside server notifying of the event
The outside server generated a request for more details on the relevant domain objects after receiving the message
My app responded with stale data for one resource and accurate(up-to-date) data for the other.
On retry, the outside server generated an identical request and received the expected(accurate) data for both resources.
Neither save was called with flush:true, however the 1st resources save occurs two lines before the 2nd resources save, and the line in between is the change to the second resource. It may be the case that flush will resolve this issue, but I'd like to implement a solution that will guarantee the specific situation doesn't arise again.
My somewhat naive/1st thrust implementation of a solution involves get & release semaphore methods:
public synchronized boolean releaseSemaphore(Thing thing){
if(thing.semaphore==true){
thing.semaphore=false
if(thing.save(failOnError:true, flush:true)){
return true
}
else{
log.warn "releasing thing semaphore, thing: "+thing.id+", failed on thing.save()"
return false
}
}
else{
log.error "releaseThingSemaphore called with thing: "+thing.id+" when semaphore not held."
return false
}
}
public synchronized getThingWithSemaphore(String thingId){
def thing = Thing.get(thingId)
if(thing){
if(thing.semaphore==false){
thing.semaphore=true
if(thing.save(failOnError:true, flush:true)){
return [thing, true]
}
else{
log.debug "Failed to get lock on thing: "+thingId
return [null, false]
}
}
else{
log.warn "Thing: "+thingId+" was locked when getThingWithSemaphore was called"
return [null, false]
}
}
else{
return [null, false]
}
}
Would the GORM API's Thing.lock(thingId) {(http://grails.github.io/grails-doc/3.0.x/guide/GORM.html#locking) .lock()} accomplish the same guarantees I've tried to achieve in my above implementation here (when getting the semaphore prior to writing or reading for a significant action)?
http://www.anyware.co.uk/2005/2012/11/12/the-false-optimism-of-gorm-and-hibernate/ (while I realize its old) claims the .lock() method used to fail silently when outside of a transaction, not actually locking anything. Is this still the case?
(I also have concerns around MongoDB's general level ofsupport for transactions, and the impact this would have on a GORM .lock() call)
If I were to deploy multiple instances of the identical app in different data-centers requiring cross app-instance locking (or cross non-identical app sharing the same MongoDB replication set datasource), would I be able to leverage anything in the GORM API to enable cross-app document locking?