merge with 3.3

diff --cc Lib/threading.py
index b99d0e935366f5388198c2ff44f1113032887b9b,625c9b9d7b7590898635c770f7c779782573b975..185c980ce0dafa9beaa744d6afd2a473b3abbc19
--- 1/Lib/threading.py
--- 2/Lib/threading.py
+++ b/Lib/threading.py
@@@ -83,9 -105,34 +111,34 @@@ class _RLock
                  self.__class__.__name__, owner, self._count)
  
      def acquire(self, blocking=True, timeout=-1):
+         """Acquire a lock, blocking or non-blocking.
+ 
+         When invoked without arguments: if this thread already owns the lock,
+         increment the recursion level by one, and return immediately. Otherwise,
+         if another thread owns the lock, block until the lock is unlocked. Once
+         the lock is unlocked (not owned by any thread), then grab ownership, set
+         the recursion level to one, and return. If more than one thread is
+         blocked waiting until the lock is unlocked, only one at a time will be
+         able to grab ownership of the lock. There is no return value in this
+         case.
+ 
+         When invoked with the blocking argument set to true, do the same thing
+         as when called without arguments, and return true.
+ 
+         When invoked with the blocking argument set to false, do not block. If a
+         call without an argument would block, return false immediately;
+         otherwise, do the same thing as when called without arguments, and
+         return true.
+ 
+         When invoked with the floating-point timeout argument set to a positive
+         value, block for at most the number of seconds specified by timeout
+         and as long as the lock cannot be acquired.  Return true if the lock has
+         been acquired, false if the timeout has elapsed.
+ 
+         """
          me = get_ident()
          if self._owner == me:
 -            self._count = self._count + 1
 +            self._count += 1
              return 1
          rc = self._block.acquire(blocking, timeout)
          if rc:
@@@ -220,16 -321,25 +327,25 @@@ class Condition
          return result
  
      def notify(self, n=1):
+         """Wake up one or more threads waiting on this condition, if any.
+ 
+         If the calling thread has not acquired the lock when this method is
+         called, a RuntimeError is raised.
+ 
+         This method wakes up at most n of the threads waiting for the condition
+         variable; it is a no-op if no threads are waiting.
+ 
+         """
          if not self._is_owned():
              raise RuntimeError("cannot notify on un-acquired lock")
 -        __waiters = self._waiters
 -        waiters = __waiters[:n]
 -        if not waiters:
 +        all_waiters = self._waiters
 +        waiters_to_notify = _deque(_islice(all_waiters, n))
 +        if not waiters_to_notify:
              return
 -        for waiter in waiters:
 +        for waiter in waiters_to_notify:
              waiter.release()
              try:
 -                __waiters.remove(waiter)
 +                all_waiters.remove(waiter)
              except ValueError:
                  pass
  
@@@ -274,8 -421,14 +427,14 @@@ class Semaphore
      __enter__ = acquire
  
      def release(self):
+         """Release a semaphore, incrementing the internal counter by one.
+ 
+         When the counter is zero on entry and another thread is waiting for it
+         to become larger than zero again, wake up that thread.
+ 
+         """
          with self._cond:
 -            self._value = self._value + 1
 +            self._value += 1
              self._cond.notify()
  
      def __exit__(self, t, v, tb):
@@@ -806,11 -1065,15 +1104,18 @@@ class Thread
          return self._ident
  
      def is_alive(self):
+         """Return whether the thread is alive.
+ 
+         This method returns True just before the run() method starts until just
+         after the run() method terminates. The module function enumerate()
+         returns a list of all alive threads.
+ 
+         """
          assert self._initialized, "Thread.__init__() not called"
 -        return self._started.is_set() and not self._stopped
 +        if self._is_stopped or not self._started.is_set():
 +            return False
 +        self._wait_for_tstate_lock(False)
 +        return not self._is_stopped
  
      isAlive = is_alive