shuiyu1123
a51854455b
- android/ 167个模块 (app/content/os/view/widget/graphics/media/hardware/net/telephony/provider等) - java/ 35个模块 (lang/io/util/net/nio/security/crypto/sql/beans/rmi/awt等) - javax/ 4个模块 (net/crypto/security/sql) - org/ 5个模块 (json/w3c_dom/xml_sax/xml_pull/apache_http) - dalvik/ 1个模块 (system) - ~3053个类/接口，方法签名完全对齐Android SDK - 桌面跨平台运行 (Windows/macOS/Linux) - 修复所有导入错误和Python关键字冲突
1044 lines
28 KiB
Python
1044 lines
28 KiB
Python
"""
|
|
Java java.util.concurrent.atomic standard library APIs implemented in Python.
|
|
java.util.concurrent.atomic package - AtomicBoolean, AtomicInteger, AtomicLong, etc.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from .._core import Stub
|
|
from ..java.lang import RuntimeException
|
|
import threading as _threading
|
|
import math as _py_math
|
|
|
|
__all__ = [
|
|
"AtomicBoolean", "AtomicInteger", "AtomicLong", "AtomicReference",
|
|
"AtomicIntegerArray", "AtomicLongArray", "AtomicReferenceArray",
|
|
"AtomicIntegerFieldUpdater", "AtomicLongFieldUpdater",
|
|
"AtomicReferenceFieldUpdater",
|
|
"AtomicMarkableReference", "AtomicStampedReference",
|
|
"DoubleAccumulator", "DoubleAdder",
|
|
"LongAccumulator", "LongAdder", "Striped64",
|
|
]
|
|
|
|
|
|
# ============================================================
|
|
# AtomicBoolean
|
|
# ============================================================
|
|
|
|
class AtomicBoolean(Stub):
|
|
"""java.util.concurrent.atomic.AtomicBoolean"""
|
|
def __init__(self, initial_value=False):
|
|
super().__init__()
|
|
self._lock = _threading.Lock()
|
|
self._value = bool(initial_value)
|
|
|
|
def get(self):
|
|
with self._lock:
|
|
return self._value
|
|
|
|
def set(self, new_value):
|
|
with self._lock:
|
|
self._value = bool(new_value)
|
|
|
|
def lazySet(self, new_value):
|
|
self.set(new_value)
|
|
|
|
def getAndSet(self, new_value):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value = bool(new_value)
|
|
return old
|
|
|
|
def compareAndSet(self, expect, update):
|
|
with self._lock:
|
|
if self._value == expect:
|
|
self._value = update
|
|
return True
|
|
return False
|
|
|
|
def weakCompareAndSet(self, expect, update):
|
|
return self.compareAndSet(expect, update)
|
|
|
|
def toString(self):
|
|
return str(self._value)
|
|
|
|
def hashCode(self):
|
|
return hash(self._value)
|
|
|
|
def equals(self, other):
|
|
if not isinstance(other, AtomicBoolean):
|
|
return False
|
|
return self._value == other._value
|
|
|
|
|
|
# ============================================================
|
|
# AtomicInteger
|
|
# ============================================================
|
|
|
|
class AtomicInteger(Stub):
|
|
"""java.util.concurrent.atomic.AtomicInteger"""
|
|
def __init__(self, initial_value=0):
|
|
super().__init__()
|
|
self._lock = _threading.Lock()
|
|
self._value = int(initial_value)
|
|
|
|
def get(self):
|
|
with self._lock:
|
|
return self._value
|
|
|
|
def set(self, new_value):
|
|
with self._lock:
|
|
self._value = int(new_value)
|
|
|
|
def lazySet(self, new_value):
|
|
self.set(new_value)
|
|
|
|
def getAndSet(self, new_value):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value = int(new_value)
|
|
return old
|
|
|
|
def compareAndSet(self, expect, update):
|
|
with self._lock:
|
|
if self._value == expect:
|
|
self._value = int(update)
|
|
return True
|
|
return False
|
|
|
|
def weakCompareAndSet(self, expect, update):
|
|
return self.compareAndSet(expect, update)
|
|
|
|
def getAndIncrement(self):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value += 1
|
|
return old
|
|
|
|
def getAndDecrement(self):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value -= 1
|
|
return old
|
|
|
|
def getAndAdd(self, delta):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value += delta
|
|
return old
|
|
|
|
def incrementAndGet(self):
|
|
with self._lock:
|
|
self._value += 1
|
|
return self._value
|
|
|
|
def decrementAndGet(self):
|
|
with self._lock:
|
|
self._value -= 1
|
|
return self._value
|
|
|
|
def addAndGet(self, delta):
|
|
with self._lock:
|
|
self._value += delta
|
|
return self._value
|
|
|
|
def getAndUpdate(self, update_func):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value = update_func.applyAsInt(old)
|
|
return old
|
|
|
|
def updateAndGet(self, update_func):
|
|
with self._lock:
|
|
self._value = update_func.applyAsInt(self._value)
|
|
return self._value
|
|
|
|
def getAndAccumulate(self, x, accumulator_func):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value = accumulator_func.applyAsInt(old, x)
|
|
return old
|
|
|
|
def accumulateAndGet(self, x, accumulator_func):
|
|
with self._lock:
|
|
self._value = accumulator_func.applyAsInt(self._value, x)
|
|
return self._value
|
|
|
|
def toString(self):
|
|
return str(self.get())
|
|
|
|
def intValue(self):
|
|
return self.get()
|
|
|
|
def longValue(self):
|
|
return self.get()
|
|
|
|
def floatValue(self):
|
|
return float(self.get())
|
|
|
|
def doubleValue(self):
|
|
return float(self.get())
|
|
|
|
def hashCode(self):
|
|
return self.get()
|
|
|
|
|
|
# ============================================================
|
|
# AtomicLong
|
|
# ============================================================
|
|
|
|
class AtomicLong(Stub):
|
|
"""java.util.concurrent.atomic.AtomicLong"""
|
|
def __init__(self, initial_value=0):
|
|
super().__init__()
|
|
self._lock = _threading.Lock()
|
|
self._value = int(initial_value)
|
|
|
|
def get(self):
|
|
with self._lock:
|
|
return self._value
|
|
|
|
def set(self, new_value):
|
|
with self._lock:
|
|
self._value = int(new_value)
|
|
|
|
def lazySet(self, new_value):
|
|
self.set(new_value)
|
|
|
|
def getAndSet(self, new_value):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value = int(new_value)
|
|
return old
|
|
|
|
def compareAndSet(self, expect, update):
|
|
with self._lock:
|
|
if self._value == expect:
|
|
self._value = int(update)
|
|
return True
|
|
return False
|
|
|
|
def weakCompareAndSet(self, expect, update):
|
|
return self.compareAndSet(expect, update)
|
|
|
|
def getAndIncrement(self):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value += 1
|
|
return old
|
|
|
|
def getAndDecrement(self):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value -= 1
|
|
return old
|
|
|
|
def getAndAdd(self, delta):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value += delta
|
|
return old
|
|
|
|
def incrementAndGet(self):
|
|
with self._lock:
|
|
self._value += 1
|
|
return self._value
|
|
|
|
def decrementAndGet(self):
|
|
with self._lock:
|
|
self._value -= 1
|
|
return self._value
|
|
|
|
def addAndGet(self, delta):
|
|
with self._lock:
|
|
self._value += delta
|
|
return self._value
|
|
|
|
def getAndUpdate(self, update_func):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value = update_func.applyAsLong(old)
|
|
return old
|
|
|
|
def updateAndGet(self, update_func):
|
|
with self._lock:
|
|
self._value = update_func.applyAsLong(self._value)
|
|
return self._value
|
|
|
|
def getAndAccumulate(self, x, accumulator_func):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value = accumulator_func.applyAsLong(old, x)
|
|
return old
|
|
|
|
def accumulateAndGet(self, x, accumulator_func):
|
|
with self._lock:
|
|
self._value = accumulator_func.applyAsLong(self._value, x)
|
|
return self._value
|
|
|
|
def toString(self):
|
|
return str(self.get())
|
|
|
|
def intValue(self):
|
|
return int(self.get())
|
|
|
|
def longValue(self):
|
|
return self.get()
|
|
|
|
def floatValue(self):
|
|
return float(self.get())
|
|
|
|
def doubleValue(self):
|
|
return float(self.get())
|
|
|
|
def hashCode(self):
|
|
return hash(self.get())
|
|
|
|
|
|
# ============================================================
|
|
# AtomicReference
|
|
# ============================================================
|
|
|
|
class AtomicReference(Stub):
|
|
"""java.util.concurrent.atomic.AtomicReference"""
|
|
def __init__(self, initial_value=None):
|
|
super().__init__()
|
|
self._lock = _threading.Lock()
|
|
self._value = initial_value
|
|
|
|
def get(self):
|
|
with self._lock:
|
|
return self._value
|
|
|
|
def set(self, new_value):
|
|
with self._lock:
|
|
self._value = new_value
|
|
|
|
def lazySet(self, new_value):
|
|
self.set(new_value)
|
|
|
|
def getAndSet(self, new_value):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value = new_value
|
|
return old
|
|
|
|
def compareAndSet(self, expect, update):
|
|
with self._lock:
|
|
if self._value is expect or (self._value == expect):
|
|
self._value = update
|
|
return True
|
|
return False
|
|
|
|
def weakCompareAndSet(self, expect, update):
|
|
return self.compareAndSet(expect, update)
|
|
|
|
def getAndUpdate(self, update_func):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value = update_func.apply(old)
|
|
return old
|
|
|
|
def updateAndGet(self, update_func):
|
|
with self._lock:
|
|
self._value = update_func.apply(self._value)
|
|
return self._value
|
|
|
|
def getAndAccumulate(self, x, accumulator_func):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value = accumulator_func.apply(old, x)
|
|
return old
|
|
|
|
def accumulateAndGet(self, x, accumulator_func):
|
|
with self._lock:
|
|
self._value = accumulator_func.apply(self._value, x)
|
|
return self._value
|
|
|
|
def toString(self):
|
|
return str(self.get())
|
|
|
|
def hashCode(self):
|
|
return hash(self._value)
|
|
|
|
|
|
# ============================================================
|
|
# AtomicIntegerArray
|
|
# ============================================================
|
|
|
|
class AtomicIntegerArray(Stub):
|
|
"""java.util.concurrent.atomic.AtomicIntegerArray"""
|
|
def __init__(self, length_or_array):
|
|
super().__init__()
|
|
if isinstance(length_or_array, int):
|
|
self._array = [0] * length_or_array
|
|
else:
|
|
self._array = list(length_or_array)
|
|
self._lock = _threading.Lock()
|
|
|
|
def length(self):
|
|
return len(self._array)
|
|
|
|
def get(self, i):
|
|
with self._lock:
|
|
return self._array[i]
|
|
|
|
def set(self, i, new_value):
|
|
with self._lock:
|
|
self._array[i] = int(new_value)
|
|
|
|
def lazySet(self, i, new_value):
|
|
self.set(i, new_value)
|
|
|
|
def getAndSet(self, i, new_value):
|
|
with self._lock:
|
|
old = self._array[i]
|
|
self._array[i] = int(new_value)
|
|
return old
|
|
|
|
def compareAndSet(self, i, expect, update):
|
|
with self._lock:
|
|
if self._array[i] == expect:
|
|
self._array[i] = int(update)
|
|
return True
|
|
return False
|
|
|
|
def weakCompareAndSet(self, i, expect, update):
|
|
return self.compareAndSet(i, expect, update)
|
|
|
|
def getAndIncrement(self, i):
|
|
with self._lock:
|
|
old = self._array[i]
|
|
self._array[i] += 1
|
|
return old
|
|
|
|
def getAndDecrement(self, i):
|
|
with self._lock:
|
|
old = self._array[i]
|
|
self._array[i] -= 1
|
|
return old
|
|
|
|
def getAndAdd(self, i, delta):
|
|
with self._lock:
|
|
old = self._array[i]
|
|
self._array[i] += delta
|
|
return old
|
|
|
|
def incrementAndGet(self, i):
|
|
with self._lock:
|
|
self._array[i] += 1
|
|
return self._array[i]
|
|
|
|
def decrementAndGet(self, i):
|
|
with self._lock:
|
|
self._array[i] -= 1
|
|
return self._array[i]
|
|
|
|
def addAndGet(self, i, delta):
|
|
with self._lock:
|
|
self._array[i] += delta
|
|
return self._array[i]
|
|
|
|
def toString(self):
|
|
return str(self._array)
|
|
|
|
|
|
# ============================================================
|
|
# AtomicLongArray
|
|
# ============================================================
|
|
|
|
class AtomicLongArray(Stub):
|
|
"""java.util.concurrent.atomic.AtomicLongArray"""
|
|
def __init__(self, length_or_array):
|
|
super().__init__()
|
|
if isinstance(length_or_array, int):
|
|
self._array = [0] * length_or_array
|
|
else:
|
|
self._array = list(length_or_array)
|
|
self._lock = _threading.Lock()
|
|
|
|
def length(self):
|
|
return len(self._array)
|
|
|
|
def get(self, i):
|
|
with self._lock:
|
|
return self._array[i]
|
|
|
|
def set(self, i, new_value):
|
|
with self._lock:
|
|
self._array[i] = int(new_value)
|
|
|
|
def lazySet(self, i, new_value):
|
|
self.set(i, new_value)
|
|
|
|
def getAndSet(self, i, new_value):
|
|
with self._lock:
|
|
old = self._array[i]
|
|
self._array[i] = int(new_value)
|
|
return old
|
|
|
|
def compareAndSet(self, i, expect, update):
|
|
with self._lock:
|
|
if self._array[i] == expect:
|
|
self._array[i] = int(update)
|
|
return True
|
|
return False
|
|
|
|
def weakCompareAndSet(self, i, expect, update):
|
|
return self.compareAndSet(i, expect, update)
|
|
|
|
def getAndIncrement(self, i):
|
|
with self._lock:
|
|
old = self._array[i]
|
|
self._array[i] += 1
|
|
return old
|
|
|
|
def getAndDecrement(self, i):
|
|
with self._lock:
|
|
old = self._array[i]
|
|
self._array[i] -= 1
|
|
return old
|
|
|
|
def getAndAdd(self, i, delta):
|
|
with self._lock:
|
|
old = self._array[i]
|
|
self._array[i] += delta
|
|
return old
|
|
|
|
def incrementAndGet(self, i):
|
|
with self._lock:
|
|
self._array[i] += 1
|
|
return self._array[i]
|
|
|
|
def decrementAndGet(self, i):
|
|
with self._lock:
|
|
self._array[i] -= 1
|
|
return self._array[i]
|
|
|
|
def addAndGet(self, i, delta):
|
|
with self._lock:
|
|
self._array[i] += delta
|
|
return self._array[i]
|
|
|
|
def toString(self):
|
|
return str(self._array)
|
|
|
|
|
|
# ============================================================
|
|
# AtomicReferenceArray
|
|
# ============================================================
|
|
|
|
class AtomicReferenceArray(Stub):
|
|
"""java.util.concurrent.atomic.AtomicReferenceArray"""
|
|
def __init__(self, length_or_array):
|
|
super().__init__()
|
|
if isinstance(length_or_array, int):
|
|
self._array = [None] * length_or_array
|
|
else:
|
|
self._array = list(length_or_array)
|
|
self._lock = _threading.Lock()
|
|
|
|
def length(self):
|
|
return len(self._array)
|
|
|
|
def get(self, i):
|
|
with self._lock:
|
|
return self._array[i]
|
|
|
|
def set(self, i, new_value):
|
|
with self._lock:
|
|
self._array[i] = new_value
|
|
|
|
def lazySet(self, i, new_value):
|
|
self.set(i, new_value)
|
|
|
|
def getAndSet(self, i, new_value):
|
|
with self._lock:
|
|
old = self._array[i]
|
|
self._array[i] = new_value
|
|
return old
|
|
|
|
def compareAndSet(self, i, expect, update):
|
|
with self._lock:
|
|
if self._array[i] is expect or self._array[i] == expect:
|
|
self._array[i] = update
|
|
return True
|
|
return False
|
|
|
|
def weakCompareAndSet(self, i, expect, update):
|
|
return self.compareAndSet(i, expect, update)
|
|
|
|
def toString(self):
|
|
return str(self._array)
|
|
|
|
|
|
# ============================================================
|
|
# AtomicMarkableReference
|
|
# ============================================================
|
|
|
|
class AtomicMarkableReference(Stub):
|
|
"""java.util.concurrent.atomic.AtomicMarkableReference"""
|
|
def __init__(self, initial_ref, initial_mark):
|
|
super().__init__()
|
|
self._lock = _threading.Lock()
|
|
self._reference = initial_ref
|
|
self._mark = bool(initial_mark)
|
|
|
|
def getReference(self):
|
|
with self._lock:
|
|
return self._reference
|
|
|
|
def isMarked(self):
|
|
with self._lock:
|
|
return self._mark
|
|
|
|
def get(self):
|
|
with self._lock:
|
|
return [self._reference, self._mark]
|
|
|
|
def attemptMark(self, expected_reference, new_mark):
|
|
with self._lock:
|
|
if self._reference is expected_reference or self._reference == expected_reference:
|
|
self._mark = bool(new_mark)
|
|
return True
|
|
return False
|
|
|
|
def compareAndSet(self, expected_reference, new_reference,
|
|
expected_mark, new_mark):
|
|
with self._lock:
|
|
if (self._reference is expected_reference or self._reference == expected_reference):
|
|
if self._mark == expected_mark:
|
|
self._reference = new_reference
|
|
self._mark = bool(new_mark)
|
|
return True
|
|
return False
|
|
|
|
def weakCompareAndSet(self, expected_reference, new_reference,
|
|
expected_mark, new_mark):
|
|
return self.compareAndSet(expected_reference, new_reference,
|
|
expected_mark, new_mark)
|
|
|
|
|
|
# ============================================================
|
|
# AtomicStampedReference
|
|
# ============================================================
|
|
|
|
class AtomicStampedReference(Stub):
|
|
"""java.util.concurrent.atomic.AtomicStampedReference"""
|
|
def __init__(self, initial_ref, initial_stamp):
|
|
super().__init__()
|
|
self._lock = _threading.Lock()
|
|
self._reference = initial_ref
|
|
self._stamp = int(initial_stamp)
|
|
|
|
def getReference(self):
|
|
with self._lock:
|
|
return self._reference
|
|
|
|
def getStamp(self):
|
|
with self._lock:
|
|
return self._stamp
|
|
|
|
def get(self):
|
|
with self._lock:
|
|
return [self._reference, self._stamp]
|
|
|
|
def attemptStamp(self, expected_reference, new_stamp):
|
|
with self._lock:
|
|
if self._reference is expected_reference or self._reference == expected_reference:
|
|
self._stamp = int(new_stamp)
|
|
return True
|
|
return False
|
|
|
|
def compareAndSet(self, expected_reference, new_reference,
|
|
expected_stamp, new_stamp):
|
|
with self._lock:
|
|
if (self._reference is expected_reference or self._reference == expected_reference):
|
|
if self._stamp == expected_stamp:
|
|
self._reference = new_reference
|
|
self._stamp = int(new_stamp)
|
|
return True
|
|
return False
|
|
|
|
def weakCompareAndSet(self, expected_reference, new_reference,
|
|
expected_stamp, new_stamp):
|
|
return self.compareAndSet(expected_reference, new_reference,
|
|
expected_stamp, new_stamp)
|
|
|
|
|
|
# ============================================================
|
|
# Field Updaters
|
|
# ============================================================
|
|
|
|
class AtomicIntegerFieldUpdater(Stub):
|
|
"""java.util.concurrent.atomic.AtomicIntegerFieldUpdater"""
|
|
def __init__(self, tclass, field_name):
|
|
super().__init__()
|
|
self._tclass = tclass
|
|
self._field_name = field_name
|
|
|
|
@staticmethod
|
|
def newUpdater(tclass, field_name):
|
|
return AtomicIntegerFieldUpdater(tclass, field_name)
|
|
|
|
def get(self, obj):
|
|
return getattr(obj, self._field_name, 0)
|
|
|
|
def set(self, obj, new_value):
|
|
setattr(obj, self._field_name, int(new_value))
|
|
|
|
def lazySet(self, obj, new_value):
|
|
self.set(obj, new_value)
|
|
|
|
def getAndSet(self, obj, new_value):
|
|
old = self.get(obj)
|
|
self.set(obj, new_value)
|
|
return old
|
|
|
|
def compareAndSet(self, obj, expect, update):
|
|
if self.get(obj) == expect:
|
|
self.set(obj, update)
|
|
return True
|
|
return False
|
|
|
|
def weakCompareAndSet(self, obj, expect, update):
|
|
return self.compareAndSet(obj, expect, update)
|
|
|
|
def getAndIncrement(self, obj):
|
|
old = self.get(obj)
|
|
self.set(obj, old + 1)
|
|
return old
|
|
|
|
def getAndDecrement(self, obj):
|
|
old = self.get(obj)
|
|
self.set(obj, old - 1)
|
|
return old
|
|
|
|
def getAndAdd(self, obj, delta):
|
|
old = self.get(obj)
|
|
self.set(obj, old + delta)
|
|
return old
|
|
|
|
def incrementAndGet(self, obj):
|
|
val = self.get(obj) + 1
|
|
self.set(obj, val)
|
|
return val
|
|
|
|
def decrementAndGet(self, obj):
|
|
val = self.get(obj) - 1
|
|
self.set(obj, val)
|
|
return val
|
|
|
|
def addAndGet(self, obj, delta):
|
|
val = self.get(obj) + delta
|
|
self.set(obj, val)
|
|
return val
|
|
|
|
|
|
class AtomicLongFieldUpdater(Stub):
|
|
"""java.util.concurrent.atomic.AtomicLongFieldUpdater"""
|
|
def __init__(self, tclass, field_name):
|
|
super().__init__()
|
|
self._tclass = tclass
|
|
self._field_name = field_name
|
|
|
|
@staticmethod
|
|
def newUpdater(tclass, field_name):
|
|
return AtomicLongFieldUpdater(tclass, field_name)
|
|
|
|
def get(self, obj):
|
|
return getattr(obj, self._field_name, 0)
|
|
|
|
def set(self, obj, new_value):
|
|
setattr(obj, self._field_name, int(new_value))
|
|
|
|
def lazySet(self, obj, new_value):
|
|
self.set(obj, new_value)
|
|
|
|
def getAndSet(self, obj, new_value):
|
|
old = self.get(obj)
|
|
self.set(obj, new_value)
|
|
return old
|
|
|
|
def compareAndSet(self, obj, expect, update):
|
|
if self.get(obj) == expect:
|
|
self.set(obj, update)
|
|
return True
|
|
return False
|
|
|
|
def weakCompareAndSet(self, obj, expect, update):
|
|
return self.compareAndSet(obj, expect, update)
|
|
|
|
def getAndIncrement(self, obj):
|
|
old = self.get(obj)
|
|
self.set(obj, old + 1)
|
|
return old
|
|
|
|
def getAndDecrement(self, obj):
|
|
old = self.get(obj)
|
|
self.set(obj, old - 1)
|
|
return old
|
|
|
|
def getAndAdd(self, obj, delta):
|
|
old = self.get(obj)
|
|
self.set(obj, old + delta)
|
|
return old
|
|
|
|
def incrementAndGet(self, obj):
|
|
val = self.get(obj) + 1
|
|
self.set(obj, val)
|
|
return val
|
|
|
|
def decrementAndGet(self, obj):
|
|
val = self.get(obj) - 1
|
|
self.set(obj, val)
|
|
return val
|
|
|
|
def addAndGet(self, obj, delta):
|
|
val = self.get(obj) + delta
|
|
self.set(obj, val)
|
|
return val
|
|
|
|
|
|
class AtomicReferenceFieldUpdater(Stub):
|
|
"""java.util.concurrent.atomic.AtomicReferenceFieldUpdater"""
|
|
def __init__(self, tclass, vclass, field_name):
|
|
super().__init__()
|
|
self._tclass = tclass
|
|
self._vclass = vclass
|
|
self._field_name = field_name
|
|
|
|
@staticmethod
|
|
def newUpdater(tclass, vclass, field_name):
|
|
return AtomicReferenceFieldUpdater(tclass, vclass, field_name)
|
|
|
|
def get(self, obj):
|
|
return getattr(obj, self._field_name, None)
|
|
|
|
def set(self, obj, new_value):
|
|
setattr(obj, self._field_name, new_value)
|
|
|
|
def lazySet(self, obj, new_value):
|
|
self.set(obj, new_value)
|
|
|
|
def getAndSet(self, obj, new_value):
|
|
old = self.get(obj)
|
|
self.set(obj, new_value)
|
|
return old
|
|
|
|
def compareAndSet(self, obj, expect, update):
|
|
if self.get(obj) is expect or self.get(obj) == expect:
|
|
self.set(obj, update)
|
|
return True
|
|
return False
|
|
|
|
def weakCompareAndSet(self, obj, expect, update):
|
|
return self.compareAndSet(obj, expect, update)
|
|
|
|
|
|
# ============================================================
|
|
# DoubleAccumulator
|
|
# ============================================================
|
|
|
|
class DoubleAccumulator(Stub):
|
|
"""java.util.concurrent.atomic.DoubleAccumulator"""
|
|
def __init__(self, accumulator_func, identity):
|
|
super().__init__()
|
|
self._lock = _threading.Lock()
|
|
self._value = float(identity)
|
|
self._func = accumulator_func
|
|
|
|
def accumulate(self, x):
|
|
with self._lock:
|
|
self._value = self._func.applyAsDouble(self._value, float(x))
|
|
|
|
def get(self):
|
|
with self._lock:
|
|
return self._value
|
|
|
|
def reset(self):
|
|
with self._lock:
|
|
self._value = 0.0
|
|
|
|
def getThenReset(self):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value = 0.0
|
|
return old
|
|
|
|
def toString(self):
|
|
return str(self.get())
|
|
|
|
def doubleValue(self):
|
|
return self.get()
|
|
|
|
def floatValue(self):
|
|
return float(self.get())
|
|
|
|
def intValue(self):
|
|
return int(self.get())
|
|
|
|
def longValue(self):
|
|
return int(self.get())
|
|
|
|
|
|
# ============================================================
|
|
# DoubleAdder
|
|
# ============================================================
|
|
|
|
class DoubleAdder(Stub):
|
|
"""java.util.concurrent.atomic.DoubleAdder"""
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._lock = _threading.Lock()
|
|
self._value = 0.0
|
|
|
|
def add(self, x):
|
|
with self._lock:
|
|
self._value += float(x)
|
|
|
|
def sum(self):
|
|
with self._lock:
|
|
return self._value
|
|
|
|
def reset(self):
|
|
with self._lock:
|
|
self._value = 0.0
|
|
|
|
def sumThenReset(self):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value = 0.0
|
|
return old
|
|
|
|
def toString(self):
|
|
return str(self.sum())
|
|
|
|
def doubleValue(self):
|
|
return self.sum()
|
|
|
|
def floatValue(self):
|
|
return float(self.sum())
|
|
|
|
def intValue(self):
|
|
return int(self.sum())
|
|
|
|
def longValue(self):
|
|
return int(self.sum())
|
|
|
|
|
|
# ============================================================
|
|
# LongAccumulator
|
|
# ============================================================
|
|
|
|
class LongAccumulator(Stub):
|
|
"""java.util.concurrent.atomic.LongAccumulator"""
|
|
def __init__(self, accumulator_func, identity):
|
|
super().__init__()
|
|
self._lock = _threading.Lock()
|
|
self._value = int(identity)
|
|
self._func = accumulator_func
|
|
|
|
def accumulate(self, x):
|
|
with self._lock:
|
|
self._value = self._func.applyAsLong(self._value, int(x))
|
|
|
|
def get(self):
|
|
with self._lock:
|
|
return self._value
|
|
|
|
def reset(self):
|
|
with self._lock:
|
|
self._value = 0
|
|
|
|
def getThenReset(self):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value = 0
|
|
return old
|
|
|
|
def toString(self):
|
|
return str(self.get())
|
|
|
|
def intValue(self):
|
|
return int(self.get())
|
|
|
|
def longValue(self):
|
|
return self.get()
|
|
|
|
def floatValue(self):
|
|
return float(self.get())
|
|
|
|
def doubleValue(self):
|
|
return float(self.get())
|
|
|
|
|
|
# ============================================================
|
|
# LongAdder
|
|
# ============================================================
|
|
|
|
class LongAdder(Stub):
|
|
"""java.util.concurrent.atomic.LongAdder"""
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._lock = _threading.Lock()
|
|
self._value = 0
|
|
|
|
def add(self, x):
|
|
with self._lock:
|
|
self._value += int(x)
|
|
|
|
def increment(self):
|
|
self.add(1)
|
|
|
|
def decrement(self):
|
|
self.add(-1)
|
|
|
|
def sum(self):
|
|
with self._lock:
|
|
return self._value
|
|
|
|
def reset(self):
|
|
with self._lock:
|
|
self._value = 0
|
|
|
|
def sumThenReset(self):
|
|
with self._lock:
|
|
old = self._value
|
|
self._value = 0
|
|
return old
|
|
|
|
def toString(self):
|
|
return str(self.sum())
|
|
|
|
def intValue(self):
|
|
return int(self.sum())
|
|
|
|
def longValue(self):
|
|
return self.sum()
|
|
|
|
def floatValue(self):
|
|
return float(self.sum())
|
|
|
|
def doubleValue(self):
|
|
return float(self.sum())
|
|
|
|
|
|
# ============================================================
|
|
# Striped64
|
|
# ============================================================
|
|
|
|
class Striped64(Stub):
|
|
"""java.util.concurrent.atomic.Striped64"""
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._value = 0
|
|
self._lock = _threading.Lock()
|
|
|
|
def _get_value(self):
|
|
with self._lock:
|
|
return self._value
|
|
|
|
def _set_value(self, v):
|
|
with self._lock:
|
|
self._value = v |