Changes between Version 44 and Version 45 of DjangoSpecifications/Core/Threading

Timestamp:

Apr 26, 2008, 3:46:55 PM (17 years ago)

Author:

mrts

Comment:

--

DjangoSpecifications/Core/Threading

@@ -12 +12 @@
 Only easy-to-identify globals have been reviewed, a related task is to identify other components not listed here that may have threading issues.
 
-== Globals ==
-
-There are four types of globals:
- 1. globals that are assigned to at module level and never modified later (THREAD-SAFE),
- 1. globals that are assigned to at module level and whose elements are modified with module level code, but never modified later (PROBABLY THREAD-SAFE, although elementwise modification at module level is not thread-safe ''per se'', the module is most likely cached ''before'' threads get access to it)
- 1. global mutable data structures (lists and dictionaries, also instances) that are assigned to at module level but whose elements are modified in functions and that are accessed without using the `global` keyword (NOT THREAD-SAFE),
- 1. globals assigned to in functions by using the `global` keyword (NOT THREAD-SAFE),
+== Introduction ==
+
+The main pattern of global variable usage in Django is ''use `var` if initialized, otherwise initialize''. This is generally not thread-safe.
 
 "Not thread-safe" has two broad subcategories:
- * inefficiencies due to calls meant to occur only once occurring more than once (the general `if not foo: initialize foo`, including `memoize` decorator),
+ * inefficiencies due to initialization calls meant to occur only once occurring more than once (the general `if not foo: initialize foo`, including `memoize` decorator),
  * errors due to incomplete initialization.
+
+Paradoxically, accepting the "inefficiencies" results generally in more ''efficient'' execution as:
+ * mutual exclusion (locking) is expensive,
+ * the inefficient case is not a certain event, it only occurs with a probability that can be quite low,
+ * locking would needlessly penalize single-threaded execution.
+
+Thus, lock-free algorithms should be always preferred and the inefficient case tolerated -- unless the inefficiency is highly probable and results in overhead that is considerably greater than with locking.
 
 === Inefficiencies ===
@@ -74 +77 @@
 
 There is at least one location in code that uses the "bad" algorithm.
+
+
+== Globals ==
+
+There are four types of globals:
+ 1. globals that are assigned to at module level and never modified later (THREAD-SAFE),
+ 1. globals that are assigned to at module level and whose elements are modified with module level code, but never modified later (PROBABLY THREAD-SAFE, although elementwise modification at module level is not thread-safe ''per se'', the module is most likely cached ''before'' threads get access to it)
+ 1. global mutable data structures (lists and dictionaries, also instances) that are assigned to at module level but whose elements are modified in functions and that are accessed without using the `global` keyword (NOT THREAD-SAFE),
+ 1. globals assigned to in functions by using the `global` keyword (NOT THREAD-SAFE),
 
 === Modules' use of globals ===