如何在javascript中处理竞争条件？

Question

First off all, I'm a pythonist, not a javascripter - please be kind.

In a popular MVVM Javascript framework from a popular Internet search provider , there is a class called Scope.

This class has a method called $watch , used to register callbacks (called listeners) that are supposed to be called every time that Scope.$digest is fired. Calls to Scope.$watch returns a deregistration function for this listener.

Listeners are called in the following loop:

...
do { // "traverse the scopes" loop
  if ((watchers = current.$$watchers)) {
    // process our watches
    length = watchers.length;
    while (length--) {
      try {
        watch = watchers[length];
        // Most common watches are on primitives, in which case we can short
        // circuit it with === operator, only when === fails do we use .equals
          if ((value = watch.get(current)) !== (last = watch.last)
... 

Since a listener can be registered or destroyed from another listener, there are two race conditions here :

1. when a listener is deregistered between length = watchers.length and watch = watchers[length] , watch will be undefined and the call to watch.get(current) will fail (undefined has no method get).
2. when a listener is registered by another listener it may be skipped.

I guess a simple check for the existence of watch would fix condition #1:

if (watch && (value = watch.get(current)) !== (last = watch.last)

I'm not sure how to solve condition #2. Shall not modify an array while iterating over it - my first thought was: why while (length--) ? Then I read in the source comments:

• Loop operations are optimized by using while(count--) { ... }
• • this means that in order to keep the same order of execution as addition we have to add items to the array at the beginning (shift) instead of at the end (push)

In Python I would probably try to solve it using queues. Two questions:

1. What is the idiomatic way of dealing with this problem in javascript when targeting maximum performance and memory conservation?
2. How should I go about unit tests for race conditions (or should I use end-to-end tests instead)?

[edit]

Samuel Neff commented that since JavaScript is not multi-threaded, this is not really a race condition.

A more objective question is: with performance and memory footprint in mind, what can I do to prevent bugs caused by a callback that modifies the very array I'm iterating over when using the while (length--) pattern to loop over an array of callbacks?

Answer 1

JavaScript is not multi-threaded. You don't have to worry about another "thread" modifying the objects between sequential lines of code.

It is possible to have race conditions if you depend on callbacks being called back in a particular order, but you don't have to worry about race conditions like in normal multi-threaded languages.

Answer 2

The way I have solved problems like this a few times in the past (when iterating through connections in server code, for example) is by adding new listeners (or in my case, connections) to a temporary array / "queue."

In my main loop I would go first go through the existing connections, deleting the ones which had been marked as dropped and dispatching other threads to deal with connections which needed servicing. Other threads could register connections to the queue array or mark connections as dropped from the main array but would not actually delete them. This took care of your first race condition.

The second race condition was solved by having my main loop atomically link the queue array to the end of the main array thus starting an empty queue array and extending the main array by the previous contents of the queue array. The main loop then finished going through the newly extended contents of the main array.