def __init__(self):
# We explicitly do not call super() here, because while we want BaseCache.__init__() to run, we *don't*
# want LocMemCache.__init__() to run, because that would store our caches in its globals.
BaseCache.__init__(self, {})
self._cache = {}
self._expire_info = {}
self._lock = RWLock()
def __init__(self, _, params):
BaseCache.__init__(self, params)
self._params = params
self._cache = {} # entry:(val,expire_time)
try:
self._max_entries = int(params.get('max_entries'))
except:
self._max_entries = MAX_KEYS
self._call_seq = {}
self._call_list = []
self._lock = RWLock()
def __init__(self, _, params):
BaseCache.__init__(self, params)
self._cache = {}
self._expire_info = {}
max_entries = params.get('max_entries', 300)
try:
self._max_entries = int(max_entries)
except (ValueError, TypeError):
self._max_entries = 300
cull_frequency = params.get('cull_frequency', 3)
try:
self._cull_frequency = int(cull_frequency)
except (ValueError, TypeError):
self._cull_frequency = 3
self._lock = RWLock()
def _set_model(self, model):
cache_name = '.'.join((
model._meta.app_label,
model._meta.model_name,
self.name,
))
self._cache = CACHES.setdefault(cache_name, OrderedDict())
self._info = CACHE_INFO.setdefault(cache_name, {'expire_time': 0})
self._lock = LOCKS.setdefault(cache_name, RWLock())
self._indexes = {}
for field_name in self.indexed_fields:
cache_name = '.'.join((
model._meta.app_label,
model._meta.model_name,
self.name,
field_name,
))
self._indexes[field_name] = CACHES.setdefault(cache_name, {})
self._model = model
if not model._meta.abstract and not model._meta.swapped:
post_save.connect(self._model_changed, sender=model)
post_delete.connect(self._model_changed, sender=model)
def __init__(self):
self.commands = list()
self.lock = RWLock()
def __init__(self, name, params):
BaseCache.__init__(self, params)
self._cache = _caches.setdefault(name, {})
self._expire_info = _expire_info.setdefault(name, {})
self._lock = _locks.setdefault(name, RWLock())
def __init__(self, name, params):
BaseCache.__init__(self, params)
self._cache = _caches.setdefault(name, LRU(self._max_entries))
self._lock = _locks.setdefault(name, RWLock())
def __init__(self, _, params):
BaseCache.__init__(self, params)
self._cache = {}
self._expire_info = {}
self._lock = RWLock()
def __init__(self, host, params):
SimpleCacheClass.__init__(self, host, params)
self._lock = RWLock()
def __init__(self, _, params):
BaseStorage.__init__(self, params)
self._db = {}
self._lock = RWLock()
from django.utils.synch import RWLock
import threading
lock = RWLock()
def r():
"""读进的时候只会被写给等待"""
with lock.reader():
import time
for i in range(0, 3):
print(i)
time.sleep(i * 4)
def w():
with lock.writer():
import time
for i in range(0, 3):
print(i)
time.sleep(i * 4)
class myThread(threading.Thread):
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self):
