threading.Semaphore

    def check_proxies(self, proxy_list):
        self._total = len(proxy_list)
        self._running_semaphore = threading.Semaphore(value=0)
        self._mutex = threading.Lock()
        self._active_threads = threading.Semaphore(value=20)
        result_list = deque()
        for proxy in proxy_list:

import curses
import sys
from threading import Thread
from threading import Semaphore
 
from processes_module import ProcessesModule
from clock_module import ClockModule
 
painting_semaphore = Semaphore(value=1)

import logging
 
NumThreads = 1
EndSema = threading.Semaphore(value=NumThreads)
 
#-------------------------------------------------------------------------------
# Supported Boards

 
import threading
from threading import Thread
from threading import RLock
from threading import Semaphore
from collections import deque
 
class ThreadPool(object):
 
    def __init__(self, thread_count = 10):
        self.resize_lock = RLock()
        self.debug_print_lock = RLock()
        self.job_semaphore = Semaphore(0)

    self.enabled = enabled
    self.enabled_count = 1
    self.lock = threading.Lock()
    self.thread_semaphore = threading.Semaphore(self.enabled_count)
    self._threads = []
    self.backoff_time = 0
    self.sleep = sleep

 
__all__ = ['synchronized', 'ThreadedPromptController']
 
from threading import Semaphore, Lock
from threading import currentThread
import sys
 

def synchronized_function(function, count = 1, semaphore = None):
    """Decorates a function with a semaphore so that only one thread may run 
    it at any time."""
    if semaphore is None:
        semaphore = Semaphore(count)
    def wrapped(*arguments, **keywords):
        semaphore.acquire()

def synchronized_property(attr, semaphore = None):
    if semaphore is None:
        semaphore = Semaphore(1)
    @Synchronized(semaphore = semaphore)
    def get(self):
        return getattr(self, attr)
    @Synchronized(semaphore = semaphore)

    class Foo(object):
        semaphore = Semaphore()
        a = synchronized_property('_a', semaphore)
        b = synchronized_property('_b', semaphore)
 
    foo = Foo()
    foo.a = 10

    """
    self.__enabled_count = 1
    self.__lock = threading.Lock()
    self.__thread_semaphore = threading.Semaphore(self.__enabled_count)
    self.__num_threads = num_threads
    self.__backoff_time = 0
    self.__sleep = sleep

	def __init__(self, source, wallpapers):
		threading.Thread.__init__(self)
		self.setDaemon(True)
		self.setName("WallpaperDownloader thread")
		self.__semaphore = threading.Semaphore(1)
		self.__source = source
		self.__wallpapers = wallpapers

    """
    self.__enabled_count = 1
    self.__lock = threading.Lock()
    self.__thread_semaphore = threading.Semaphore(self.__enabled_count)
    self.__num_threads = num_threads
    self.__backoff_time = 0
    self.__sleep = sleep

import os
import gtk
import gobject
import time
from threading import Lock, Semaphore
from videodownloadthread import VideoDownloadThread
from youtubed2x_lib.sessioninfo import SessionInfo, SessionItem

            raise Exception ("Download speed limit is less than zero. Passed: %s" % app_settings.download_speed_limit)
 
        self._sem_limit = app_settings.process_limit
        self.semaphore = Semaphore (self._sem_limit)
        self.sem_lock = Lock ()
        self.app_settings = app_settings
        self.lock = Lock ()

        # Used to keep track of downloaded bytes across all downloads
        self.download_speed_total = 0
        # Limit the number of transcoding process
        self.transcode_semaphore = Semaphore (1)
 
 
    def register (self, signal, observer):

    def alter_sem (self, value):
        self.sem_lock.acquire ()
        if isinstance (value, int) and value >= 0:
            if value == 0:
                self.semaphore = Semaphore (value)
            elif value >= self._running_items:
                self.semaphore = Semaphore (value-self._running_items)