feat: 大规模扩充至212个模块/175K行代码 — 覆盖android/java/javax/org/dalvik全包

- 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关键字冲突
2026-06-24 14:15:56 +00:00
1 parent 506f9ac725
commit a51854455b
@@ -0,0 +1,681 @@
+"""
+Java java.util.concurrent.locks standard library APIs implemented in Python.
+java.util.concurrent.locks package - Lock, ReadWriteLock, ReentrantLock, etc.
+"""
+
+from __future__ import annotations
+
+from .._core import Stub
+from ..java.lang import RuntimeException
+
+# InterruptedException (桌面模拟)
+class InterruptedException(RuntimeException):
+    def __init__(self, message=""):
+        super().__init__(message)
+import threading as _threading
+import time as _time
+import collections as _collections
+
+__all__ = [
+    "Lock", "ReadWriteLock", "ReentrantLock",
+    "ReentrantReadWriteLock",
+    "ReentrantReadWriteLock_ReadLock",
+    "ReentrantReadWriteLock_WriteLock",
+    "Condition", "LockSupport",
+    "AbstractQueuedSynchronizer",
+    "AbstractQueuedLongSynchronizer",
+    "AbstractOwnableSynchronizer",
+]
+
+
+# ============================================================
+# Lock interface
+# ============================================================
+
+class Lock(Stub):
+    """java.util.concurrent.locks.Lock"""
+    def lock(self):
+        raise NotImplementedError
+
+    def lockInterruptibly(self):
+        raise NotImplementedError
+
+    def tryLock(self, time_val=None, unit=None):
+        raise NotImplementedError
+
+    def unlock(self):
+        raise NotImplementedError
+
+    def newCondition(self):
+        raise NotImplementedError
+
+
+class ReadWriteLock(Stub):
+    """java.util.concurrent.locks.ReadWriteLock"""
+    def readLock(self):
+        raise NotImplementedError
+
+    def writeLock(self):
+        raise NotImplementedError
+
+
+# ============================================================
+# ReentrantLock
+# ============================================================
+
+class ReentrantLock(Lock):
+    """java.util.concurrent.locks.ReentrantLock"""
+    def __init__(self, fair=False):
+        super().__init__()
+        self._lock = _threading.RLock()
+        self._fair = fair
+        self._owner = None
+        self._hold_count = 0
+
+    def lock(self):
+        self._lock.acquire()
+        self._owner = _threading.current_thread()
+        self._hold_count += 1
+
+    def lockInterruptibly(self):
+        self.lock()
+
+    def tryLock(self, timeout=None, unit=None):
+        if timeout is None:
+            acquired = self._lock.acquire(blocking=False)
+        else:
+            if unit is not None:
+                timeout = timeout
+            acquired = self._lock.acquire(blocking=True, timeout=timeout)
+        if acquired:
+            self._owner = _threading.current_thread()
+            self._hold_count += 1
+            return True
+        return False
+
+    def unlock(self):
+        self._hold_count -= 1
+        if self._hold_count == 0:
+            self._owner = None
+        self._lock.release()
+
+    def newCondition(self):
+        return Condition(self)
+
+    def getHoldCount(self):
+        return self._hold_count
+
+    def isHeldByCurrentThread(self):
+        return self._owner is _threading.current_thread()
+
+    def isLocked(self):
+        return self._owner is not None
+
+    def isFair(self):
+        return self._fair
+
+    def getOwner(self):
+        return self._owner
+
+    def getQueuedThreads(self):
+        return []
+
+    def getQueueLength(self):
+        return 0
+
+    def hasQueuedThreads(self):
+        return False
+
+    def hasQueuedThread(self, thread):
+        return False
+
+    def toString(self):
+        status = "Locked" if self.isLocked() else "Unlocked"
+        return f"ReentrantLock[{status}, hold={self._hold_count}]"
+
+
+# ============================================================
+# ReentrantReadWriteLock
+# ============================================================
+
+class ReentrantReadWriteLock(ReadWriteLock):
+    """java.util.concurrent.locks.ReentrantReadWriteLock"""
+    def __init__(self, fair=False):
+        super().__init__()
+        self._fair = fair
+        self._read_lock = ReentrantReadWriteLock_ReadLock(self)
+        self._write_lock = ReentrantReadWriteLock_WriteLock(self)
+        self._read_hold_count = 0
+        self._write_hold_count = 0
+        self._write_owner = None
+        self._lock = _threading.RLock()
+        self._read_lock_obj = _threading.Lock()
+        self._read_cond = _threading.Condition(self._read_lock_obj)
+        self._readers = 0
+        self._writers_waiting = 0
+
+    def readLock(self):
+        return self._read_lock
+
+    def writeLock(self):
+        return self._write_lock
+
+    def isFair(self):
+        return self._fair
+
+    def getReadLockCount(self):
+        return self._readers
+
+    def isWriteLocked(self):
+        return self._write_owner is not None
+
+    def isWriteLockedByCurrentThread(self):
+        return self._write_owner is _threading.current_thread()
+
+    def getWriteHoldCount(self):
+        return self._write_hold_count
+
+    def getReadHoldCount(self):
+        return self._read_hold_count
+
+    def getOwner(self):
+        return self._write_owner
+
+    def getQueuedWriterThreads(self):
+        return []
+
+    def getQueuedReaderThreads(self):
+        return []
+
+    def getQueueLength(self):
+        return 0
+
+    def hasQueuedThreads(self):
+        return False
+
+    def hasQueuedThread(self, thread):
+        return False
+
+    def toString(self):
+        w = self._write_hold_count
+        r = self._readers
+        return f"ReentrantReadWriteLock[read_locks={r}, write_locks={w}]"
+
+    def _acquire_read(self):
+        with self._lock:
+            while self._write_owner is not None and self._write_owner != _threading.current_thread():
+                self._read_cond.wait()
+            self._readers += 1
+            self._read_hold_count += 1
+
+    def _release_read(self):
+        with self._lock:
+            self._readers -= 1
+            self._read_hold_count -= 1
+            if self._readers == 0:
+                self._read_cond.notify_all()
+
+    def _acquire_write(self):
+        self._lock.acquire()
+        self._write_owner = _threading.current_thread()
+        self._write_hold_count += 1
+
+    def _release_write(self):
+        self._write_hold_count -= 1
+        if self._write_hold_count == 0:
+            self._write_owner = None
+            self._read_cond.notify_all()
+        self._lock.release()
+
+
+class ReentrantReadWriteLock_ReadLock(Lock):
+    """java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock"""
+    def __init__(self, rw_lock):
+        super().__init__()
+        self._rw_lock = rw_lock
+
+    def lock(self):
+        self._rw_lock._acquire_read()
+
+    def lockInterruptibly(self):
+        self.lock()
+
+    def tryLock(self, timeout=None, unit=None):
+        self.lock()
+        return True
+
+    def unlock(self):
+        self._rw_lock._release_read()
+
+    def newCondition(self):
+        raise UnsupportedOperationException("Read locks do not support Condition")
+
+
+class ReentrantReadWriteLock_WriteLock(Lock):
+    """java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock"""
+    def __init__(self, rw_lock):
+        super().__init__()
+        self._rw_lock = rw_lock
+
+    def lock(self):
+        self._rw_lock._acquire_write()
+
+    def lockInterruptibly(self):
+        self.lock()
+
+    def tryLock(self, timeout=None, unit=None):
+        if timeout is None:
+            acquired = self._rw_lock._lock.acquire(blocking=False)
+        else:
+            acquired = self._rw_lock._lock.acquire(blocking=True, timeout=timeout)
+        if acquired:
+            self._rw_lock._write_owner = _threading.current_thread()
+            self._rw_lock._write_hold_count += 1
+            return True
+        return False
+
+    def unlock(self):
+        self._rw_lock._release_write()
+
+    def newCondition(self):
+        return Condition(self)
+
+    def isHeldByCurrentThread(self):
+        return self._rw_lock._write_owner is _threading.current_thread()
+
+
+# ============================================================
+# Condition
+# ============================================================
+
+class Condition(Stub):
+    """java.util.concurrent.locks.Condition"""
+    def __init__(self, lock=None):
+        super().__init__()
+        self._lock = lock
+        self._cond = _threading.Condition(_threading.RLock()) if lock is None else _threading.Condition()
+
+    def await_signal(self, time_val=None, unit=None):
+        self._cond.acquire()
+        try:
+            if time_val is None:
+                self._cond.wait()
+                return True
+            else:
+                if unit is not None:
+                    secs = time_val / 1000.0  # milliseconds
+                else:
+                    secs = float(time_val)
+                self._cond.wait(timeout=secs)
+                return True
+        finally:
+            self._cond.release()
+
+    def awaitUninterruptibly(self):
+        self.await_signal()
+
+    def awaitNanos(self, nanos_timeout):
+        self.await_signal(nanos_timeout / 1000000.0)
+        return 0
+
+    def awaitUntil(self, deadline):
+        now = _time.time()
+        diff = deadline - now
+        if diff > 0:
+            self.await_signal(diff)
+        return True
+
+    def signal(self):
+        self._cond.acquire()
+        try:
+            self._cond.notify()
+        finally:
+            self._cond.release()
+
+    def signalAll(self):
+        self._cond.acquire()
+        try:
+            self._cond.notify_all()
+        finally:
+            self._cond.release()
+
+
+# ============================================================
+# LockSupport
+# ============================================================
+
+class LockSupport(Stub):
+    """java.util.concurrent.locks.LockSupport"""
+    _blocked = {}
+
+    @staticmethod
+    def park(blocker=None):
+        if blocker is not None:
+            LockSupport._blocked[_threading.current_thread().ident] = blocker
+        _time.sleep(0.01)
+        if blocker is not None:
+            del LockSupport._blocked[_threading.current_thread().ident]
+
+    @staticmethod
+    def parkNanos(nanos, blocker=None):
+        if blocker is not None:
+            LockSupport._blocked[_threading.current_thread().ident] = blocker
+        _time.sleep(nanos / 1000000000.0)
+        if blocker is not None:
+            del LockSupport._blocked[_threading.current_thread().ident]
+
+    @staticmethod
+    def parkUntil(deadline, blocker=None):
+        now = _time.time()
+        diff = deadline - now
+        if diff > 0:
+            if blocker is not None:
+                LockSupport._blocked[_threading.current_thread().ident] = blocker
+            _time.sleep(diff)
+            if blocker is not None:
+                del LockSupport._blocked[_threading.current_thread().ident]
+
+    @staticmethod
+    def unpark(thread):
+        pass
+
+    @staticmethod
+    def getBlocker(thread):
+        return LockSupport._blocked.get(thread.ident)
+
+
+# ============================================================
+# AbstractOwnableSynchronizer
+# ============================================================
+
+class AbstractOwnableSynchronizer(Stub):
+    """java.util.concurrent.locks.AbstractOwnableSynchronizer"""
+    def __init__(self):
+        super().__init__()
+        self._exclusive_owner_thread = None
+
+    def setExclusiveOwnerThread(self, thread):
+        self._exclusive_owner_thread = thread
+
+    def getExclusiveOwnerThread(self):
+        return self._exclusive_owner_thread
+
+
+# ============================================================
+# AbstractQueuedSynchronizer
+# ============================================================
+
+class AbstractQueuedSynchronizer(AbstractOwnableSynchronizer):
+    """java.util.concurrent.locks.AbstractQueuedSynchronizer"""
+    class ConditionObject(Condition):
+        def __init__(self, sync):
+            super().__init__()
+            self._sync = sync
+
+    def __init__(self):
+        super().__init__()
+        self._state = 0
+        self._lock = _threading.Lock()
+        self._cond = _threading.Condition(self._lock)
+        self._head = None
+        self._tail = None
+        self._wait_queue = _collections.deque()
+
+    def getState(self):
+        with self._lock:
+            return self._state
+
+    def setState(self, new_state):
+        with self._lock:
+            self._state = new_state
+
+    def compareAndSetState(self, expect, update):
+        with self._lock:
+            if self._state == expect:
+                self._state = int(update)
+                return True
+            return False
+
+    def acquire(self, arg):
+        if not self.tryAcquire(arg):
+            self._acquire_queued(self._add_waiter(), arg)
+
+    def acquireInterruptibly(self, arg):
+        self.acquire(arg)
+
+    def tryAcquireNanos(self, arg, nanos_timeout):
+        return self.tryAcquire(arg)
+
+    def release(self, arg):
+        if self.tryRelease(arg):
+            self._signal_next()
+            return True
+        return False
+
+    def acquireShared(self, arg):
+        if self.tryAcquireShared(arg) < 0:
+            self._acquire_shared_queued(self._add_waiter(), arg)
+
+    def acquireSharedInterruptibly(self, arg):
+        self.acquireShared(arg)
+
+    def tryAcquireSharedNanos(self, arg, nanos_timeout):
+        return self.tryAcquireShared(arg) >= 0
+
+    def releaseShared(self, arg):
+        if self.tryReleaseShared(arg):
+            self._signal_next()
+            return True
+        return False
+
+    def tryAcquire(self, arg):
+        raise NotImplementedError
+
+    def tryRelease(self, arg):
+        raise NotImplementedError
+
+    def tryAcquireShared(self, arg):
+        return 1
+
+    def tryReleaseShared(self, arg):
+        return True
+
+    def isHeldExclusively(self):
+        return self.getExclusiveOwnerThread() is _threading.current_thread()
+
+    def getQueuedThreads(self):
+        return list(self._wait_queue)
+
+    def getQueueLength(self):
+        return len(self._wait_queue)
+
+    def hasQueuedThreads(self):
+        return len(self._wait_queue) > 0
+
+    def hasContended(self):
+        return len(self._wait_queue) > 0
+
+    def getFirstQueuedThread(self):
+        if self._wait_queue:
+            return self._wait_queue[0]
+        return None
+
+    def owns(self, condition):
+        return isinstance(condition, AbstractQueuedSynchronizer.ConditionObject)
+
+    def hasWaiters(self, condition):
+        return False
+
+    def getWaitQueueLength(self, condition):
+        return 0
+
+    def getWaitingThreads(self, condition):
+        return []
+
+    def toString(self):
+        return f"AbstractQueuedSynchronizer[state={self._state}]"
+
+    def _add_waiter(self):
+        thread = _threading.current_thread()
+        with self._lock:
+            self._wait_queue.append(thread)
+        return thread
+
+    def _acquire_queued(self, node, arg):
+        while True:
+            if self.tryAcquire(arg):
+                with self._lock:
+                    if node in self._wait_queue:
+                        self._wait_queue.remove(node)
+                return
+            _time.sleep(0.001)
+
+    def _acquire_shared_queued(self, node, arg):
+        while True:
+            if self.tryAcquireShared(arg) >= 0:
+                with self._lock:
+                    if node in self._wait_queue:
+                        self._wait_queue.remove(node)
+                return
+            _time.sleep(0.001)
+
+    def _signal_next(self):
+        with self._lock:
+            if self._wait_queue:
+                self._cond.notify()
+
+
+# ============================================================
+# AbstractQueuedLongSynchronizer
+# ============================================================
+
+class AbstractQueuedLongSynchronizer(AbstractOwnableSynchronizer):
+    """java.util.concurrent.locks.AbstractQueuedLongSynchronizer"""
+    class ConditionObject(Condition):
+        def __init__(self, sync):
+            super().__init__()
+            self._sync = sync
+
+    def __init__(self):
+        super().__init__()
+        self._state = 0
+        self._lock = _threading.Lock()
+        self._cond = _threading.Condition(self._lock)
+        self._wait_queue = _collections.deque()
+
+    def getState(self):
+        with self._lock:
+            return self._state
+
+    def setState(self, new_state):
+        with self._lock:
+            self._state = int(new_state)
+
+    def compareAndSetState(self, expect, update):
+        with self._lock:
+            if self._state == expect:
+                self._state = int(update)
+                return True
+            return False
+
+    def acquire(self, arg):
+        if not self.tryAcquire(arg):
+            self._acquire_queued(self._add_waiter(), arg)
+
+    def acquireInterruptibly(self, arg):
+        self.acquire(arg)
+
+    def tryAcquireNanos(self, arg, nanos_timeout):
+        return self.tryAcquire(arg)
+
+    def release(self, arg):
+        if self.tryRelease(arg):
+            self._signal_next()
+            return True
+        return False
+
+    def acquireShared(self, arg):
+        if self.tryAcquireShared(arg) < 0:
+            self._acquire_shared_queued(self._add_waiter(), arg)
+
+    def acquireSharedInterruptibly(self, arg):
+        self.acquireShared(arg)
+
+    def tryAcquireSharedNanos(self, arg, nanos_timeout):
+        return self.tryAcquireShared(arg) >= 0
+
+    def releaseShared(self, arg):
+        if self.tryReleaseShared(arg):
+            self._signal_next()
+            return True
+        return False
+
+    def tryAcquire(self, arg):
+        raise NotImplementedError
+
+    def tryRelease(self, arg):
+        raise NotImplementedError
+
+    def tryAcquireShared(self, arg):
+        return 1
+
+    def tryReleaseShared(self, arg):
+        return True
+
+    def isHeldExclusively(self):
+        return self.getExclusiveOwnerThread() is _threading.current_thread()
+
+    def getQueuedThreads(self):
+        return list(self._wait_queue)
+
+    def getQueueLength(self):
+        return len(self._wait_queue)
+
+    def hasQueuedThreads(self):
+        return len(self._wait_queue) > 0
+
+    def getFirstQueuedThread(self):
+        if self._wait_queue:
+            return self._wait_queue[0]
+        return None
+
+    def toString(self):
+        return f"AbstractQueuedLongSynchronizer[state={self._state}]"
+
+    def _add_waiter(self):
+        thread = _threading.current_thread()
+        with self._lock:
+            self._wait_queue.append(thread)
+        return thread
+
+    def _acquire_queued(self, node, arg):
+        while True:
+            if self.tryAcquire(arg):
+                with self._lock:
+                    if node in self._wait_queue:
+                        self._wait_queue.remove(node)
+                return
+            _time.sleep(0.001)
+
+    def _acquire_shared_queued(self, node, arg):
+        while True:
+            if self.tryAcquireShared(arg) >= 0:
+                with self._lock:
+                    if node in self._wait_queue:
+                        self._wait_queue.remove(node)
+                return
+            _time.sleep(0.001)
+
+    def _signal_next(self):
+        with self._lock:
+            if self._wait_queue:
+                self._cond.notify()
+
+
+# ============================================================
+# UnsupportedOperationException
+# ============================================================
+
+class UnsupportedOperationException(RuntimeException):
+    """java.lang.UnsupportedOperationException"""
+    pass