Apps Script - Achieving Multiple Locks on Different Parts of Script - google-apps-script

Question

I am trying to limit concurrent use of apps script for different parts of the same script, but no matter what I do, one lock will lock the whole thing down. Here's my sample script:
function lockTest(event) {
var r_eventRange = event.range;
var value = r_eventRange.getValue();
if (value == "A"){
var lock1 = LockService.getScriptLock();
lock1.waitLock(10000);
//do stuff
lock1.releaseLock();
} else if (value == "B") {
var lock2 = LockService.getScriptLock();
lock2.waitLock(10000);
//do different stuff
lock2.releaseLock();
}
}
Function 'lockTest' is triggered by an onEdit event. The intent for this script is that there can be two values: "A", and "B". If I get consecutive calls where both have value "A", then force the calls to wait to execute one at a time. Same thing if I get consecutive calls where both have value "B". But if I get consecutive calls where value is "A" in one and "B" in the other, then go ahead and let the code run consecutively without waiting.
However, the with this script the 'lock service' will not allow consecutive runs regardless of the value. In other words, if the first call has value "A", and the second call comes before the first is done but the value is "B", the lock service is forcing the second call to wait for the first call to complete even though the locks are supposed to be different.
Is it possible to control the locking on different parts of the script?
Basically, I need value "A" to trigger lock1 which edits a specific set of shared resources. value "B" should trigger lock2 which edits a completely different set of shared resources than lock1. That means that lock1 and lock2 should be able to run at the same time because the resources they edit are completely different. In fact I need them to run at the same time because lock1 will be triggered a lot more frequently than lock2 and lock1 takes only about 2 seconds to execute. lock2 is triggered much less frequently but takes 30-150 seconds to execute. So I need lock1 to be able to run even if lock2 is already running because otherwise lock1 will either time out or there could be so many instances of lock1 waiting in line while lock2 finishes that the 'lock service' will start throwing errors.
Interestingly enough, if I put a logger before the if() statement, I get logs instantly every time an edit event happens - meaning that the 'lock service' in only locking down the if statement and not the lines before it.
Google's documentation for 'lock service' says
getScriptLock() Gets a lock that prevents any user from concurrently
running a section of code. A code section guarded by a script lock
cannot be executed simultaneously regardless of the identity of the
user.
It seems like from this that we should be able to lock specific sections of code. I just can't figure out how to designate what those individual sections are. I assumed the releaseLock() method would tell it where to end the section. And maybe it does - I'm concerned that the 'lock service' doesn't support designating multiple independent locks, which is what I need here.
According to Oleg's suggestion:
function lockTest(event) {
var r_eventRange = event.range;
var value = r_eventRange.getValue();
if (value == "A"){
checkFormatting();
} else {
doAction();
}
}
function checkFormatting(){
var lock1 = LockService.getScriptLock();
lock1.waitLock(10000);
//do stuff
lock1.releaseLock();
}
function doAction(){
var lock2 = LockService.getScriptLock();
lock2.waitLock(10000);
//do different stuff
lock2.releaseLock();
}
Unfortunately I'm having the same issue with the above code.

Answer 1

I have the same problem as you do. It seems the locks provided by LockService are singletons, and thus your lock.waitLock() calls will always wait irregardless of where the lock was grabbed initially.
I recommend you look at this library providing "named locks" which is what you are looking for here. Have not used it yet, but looks promising.
https://ramblings.mcpher.com/gassnippets2/using-named-locks-with-google-apps-scripts/

Answer 2

LockService provides a single mutex (aka lock) which you can lock/unlock.
Recall that multiple JS runtimes can run in your Google Sheet at a time. The guarantee that LockService provides is that when waitLock() succeeds, you know that you are the only JS runtime that has obtained the lock. All other runtimes are either doing something which doesn't care about the lock, or are waiting for you to release the lock.
const mutex = LockService.getScriptLock();
const TIMEOUT_MS = 10*1000;
function doStuff() {}
function doTheFirstThing() {
// Process some local data. Don't need the lock yet.
doStuff();
// Increment a cell. We definitely need the lock here,
// because we need to read and write in a row without
// somebody changing the value under our nose.
mutex.waitLock(TIMEOUT_MS);
const range = SpreadsheetApp.getActiveSpreadsheet.getRange('A1');
range.setValue(range.getValue()+1);
mutex.releaseLock();
}
function doTheSecondThing() {
// Process some different local data.
// We also don't care about the lock yet.
// Decrement a cell. We definitely need the lock here,
// because we need to read and write in a row without
// somebody changing the value under our nose.
mutex.waitLock(TIMEOUT_MS);
const range = SpreadsheetApp.getActiveSpreadsheet.getRange('A1');
range.setValue(range.getValue()-1);
mutex.releaseLock();
}
So a critical section is not defined really by a code block persay - it is defined by where you lock and unlock a specific mutex. In my example, doTheFirstThing() and doTheSecondThing() share a critical section. What you can do to achieve named locks (and thus distinct critical sections) is maintain a (synchronized) map of (lockName => isLocked) and use the one global lock you get to access said map.
However, be wary of performance here, as locking any named lock will lock the global lock.