How to prevent a function being called multiple times? (locking)

Question

With a function that calls an asynchronous process, it's possible to call the same function multiple times.

What is a reliable way to avoid this that properly handles quit and errors being raised?

Is there an lisp convention for how to handle this?

---

This is an example of locking function, I'm wondering if there are better ways to handle this (existing macros or conventions for e.g).

(defvar my-fn--lock nil)

(defun my-fn ()
  (unless my-fn--lock
    (unwind-protect
        (progn
          (setq my-fn--lock t)

          ;; Code body.
          (do-stuff))

      ;; Protected.
      (setq my-fn--lock nil))))

Answer 1

I'd probably use a symbol property: function-put to add or release the lock on the function symbol, and function-get to query the state.

Tangentially, C-h i g (elisp)Mutexes is a thing; but that's not what you're looking for here.

Answer 2

This can be done using unwind-protect, this example shows how it can be done in a macro:

;; Generic macro:

(defmacro with-lock-var (var &rest body)
  "Set VAR to t while in the scope of BODY, use to implement locking."
  (declare (indent 1))
  `
  (unwind-protect
    (progn
      (setq ,var t)
      ,@body)

    ;; Protected.
    (setq ,var nil)))


;; Example use:

(defvar my-fn--lock nil)

(defun my-fn ()
  (unless my-fn--lock
    (with-lock-var
      ;; Code body.
      (do-stuff))))