java.util.concurrent Uml

最新推荐文章于 2019-08-09 10:25:02 发布

原创最新推荐文章于 2019-08-09 10:25:02 发布 · 249 阅读

0 ·

CC 4.0 BY-SA版权

更多专栏收录该内容

27 篇文章

订阅专栏

本文详细介绍了Java并发编程中核心组件的设计与实现原理，包括各种队列、锁、线程池及原子类等，并深入探讨了它们之间的联系与区别。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

java.util.concurrent（不包含外部类的继承关系）

non-exception

这里写图片描述

普通队列

ConcurrentLinkedDeque
ConcurrentLinkedQueue

阻塞队列

LinkedBlockingDeque
LinkedTransferQueue
ArrayBlockingQueue
- final Object[] items
- final ReentrantLock lock
- new 需要指定大小
DelayQueue
LinkedBlockingQueue
- Node {item, next}
- 双向链表：Node head，Node last
- 初始化即 last = head = new Node(null)，即每个时刻头尾都是 item=null，这样就实现了 2 个操作（put take）或锁的无关性，提高性能，类似分段锁
- ReentrantLock takeLock
- ReentrantLock putLock
- new 大小默认 Integer.MAX_VALUE
PriorityBlockingQueue
SynchronousQueue

List & Set

ConcurrentSkipListSet
- 基于 ConcurrentSkipListMap
- 内部有 static UNSAFE，但是是再 clone() 的时候用到
Copy-on-Write 解释：写时复制，即用于读多写少多场景，读不加锁，写的时候加锁，再复制一份修改，修改好了再提换掉原值
CopyOnWriteArrayList
- 基于 ReentrantLock
- volatile Object[] array
- get 不加锁
- add 等包含修改等操作先加锁，再通过 Arrays.copyOf -> native void System.arraycopy 复制一份进行 add（或其它操作），然后再 set 当前 array
CopyOnWriteArraySet
- 基于 CopyOnWriteArrayList<E> al

Map

ConcurrentHashMap
- Java 7 & 8 HashMap ConcurrentHashMap
- Java 7
  - 分段锁
  - final Segment<K,V>[] segments 默认大小 16，记住大小设置后不可变
  - volatile Node<K,V>[] nextTable rehash 用到
  - Segment 继承自 ReentrantLock，内部有 volatile HashEntry<K,V>[] table
  - Segment 提供个 map 的一些操作：put remove rehash 等
  - HashEntry 是一个 {hash, k, v, next} 链
  - get：(k = e.key) == key || (e.hash == h && key.equals(k))
- Java 8：红黑树
  - volatile Node<K,V>[] table 默认大小 16
  - Node 是一个 {hash, k, v, next} 链
  - TreeNode

Others

CountDownLatch
Exchanger
Executors
ForkJoinWorkerThread
Phaser
Semaphore
ThreadLocalRandom

PlantUml

@startuml

enum TimeUnit

interface BlockingDeque
interface BlockingQueue
interface Callable
interface CompletionService
interface CompletionStage
interface ConcurrentMap
interface ConcurrentNavigableMap
interface Delayed
interface Executor
interface ExecutorService
interface Future
interface RejectedExecutionHandler
interface RunnableFuture
interface RunnableScheduledFuture
interface ScheduledExecutorService
interface ScheduledFuture
interface ThreadFactory
interface TransferQueue

Executor <|-- ExecutorService
ConcurrentMap <|-- ConcurrentNavigableMap
Future <|-- RunnableFuture
ScheduledFuture <|-- RunnableScheduledFuture
RunnableFuture <|-- RunnableScheduledFuture
ExecutorService <|-- ScheduledExecutorService
Future <|-- ScheduledFuture
Delayed <|-- ScheduledFuture
BlockingQueue <|-- TransferQueue

abstract class AbstractExecutorService
abstract class CountedCompleter
abstract class ForkJoinTask
abstract class RecursiveAction
abstract class RecursiveTask

ExecutorService <|.. AbstractExecutorService

BlockingQueue <|.. ArrayBlockingQueue
BlockingQueue <|-- BlockingDeque

Future <|.. CompletableFuture
CompletionStage <|.. CompletableFuture

ConcurrentMap <|.. ConcurrentHashMap

ConcurrentNavigableMap <|.. ConcurrentSkipListMap

Future <|.. ForkJoinTask
ForkJoinTask <|-- CountedCompleter

BlockingQueue <|.. DelayQueue

CompletionService <|.. ExecutorCompletionService

AbstractExecutorService <|-- ForkJoinPool

RunnableFuture <|.. FutureTask

BlockingDeque <|.. LinkedBlockingDeque
BlockingQueue <|.. LinkedBlockingQueue
TransferQueue <|.. LinkedTransferQueue
BlockingQueue <|.. PriorityBlockingQueue

ForkJoinTask <|-- RecursiveAction
ForkJoinTask <|-- RecursiveTask

ScheduledExecutorService <|.. ScheduledThreadPoolExecutor
ThreadPoolExecutor <|-- ScheduledThreadPoolExecutor

BlockingQueue <|.. SynchronousQueue

AbstractExecutorService <|-- ThreadPoolExecutor

class ConcurrentLinkedDeque
class ConcurrentLinkedQueue
class ConcurrentSkipListSet
class CopyOnWriteArrayList
class CopyOnWriteArraySet
class CountDownLatch
class Exchanger
class Executors
class ForkJoinWorkerThread
class Phaser
class Semaphore
class ThreadLocalRandom

@enduml

exception

这里写图片描述

@startuml

class BrokenBarrierException
class CancellationExceptpion
class CompletionException
class ExecutionException
class RejectedExecutionException
class TimeoutException
class CyclicBarrier

@enduml

java.util.concurrent.atomic Uml

这里写图片描述

PlantUml

@startUml

package java.lang {
  abstract class Number
}
package sun.misc {
  class Unsafe
}

package java.util.concurrent.atomic {
  class AtomicBoolean {
    -static final Unsafe unsafe
    -volatile int value
  }
  class AtomicInteger {
    -static final Unsafe unsafe
    -volatile int value
  }
  class AtomicIntegerArray {
    -static final Unsafe unsafe
    final int[] value
  }
  abstract class AtomicIntegerFieldUpdater
  class AtomicLong {
    -static final Unsafe unsafe
    -volatile long value
  }
  class AtomicLongArray {
    -static final Unsafe unsafe
    -final long[] array
  }
  abstract class AtomicLongFieldUpdater
  class AtomicMarkableReference {
    -static final Unsafe UNSAFE
  }
  class AtomicReference {
    -static final Unsafe unsafe
    -volatile V value
  }
  class AtomicReferenceArray {
    -static final Unsafe unsafe
    -final Object[] array
  }
  abstract class AtomicReferenceFieldUpdater
  class AtomicStampedReference {
    -static final Unsafe UNSAFE
  }
  class DoubleAccumulator
  class DoubleAdder
  class LongAccumulator
  class LongAdder
  abstract class Striped64 {
    -static final Unsafe UNSAFE
  }
}

Unsafe <.. AtomicBoolean
Unsafe <.. AtomicInteger
Unsafe <.. AtomicIntegerArray
Unsafe <.. AtomicIntegerFieldUpdater
Unsafe <.. AtomicLong
Unsafe <.. AtomicLongArray
Unsafe <.. AtomicLongFieldUpdater
Unsafe <.. AtomicMarkableReference
Unsafe <.. AtomicReference
Unsafe <.. AtomicReferenceArray
Unsafe <.. AtomicReferenceFieldUpdater
Unsafe <.. AtomicStampedReference
Unsafe <.. Striped64

Number <|-- AtomicInteger
Number <|-- AtomicLong
Number <|-- Striped64

Striped64 <|-- DoubleAccumulator
Striped64 <|-- DoubleAdder
Striped64 <|-- LongAccumulator
Striped64 <|-- LongAdder

@endUml

java.util.concurrent.locks

这里写图片描述

Lock

ReentrantLock
- 默认非公平锁
- Sync NonfairSync FairSync
- 只有排它锁，所以释放和获取都只有一种情况
- state 代表当前线程获取锁对次数，0 代表没有线程获取，exclusiveOwnerThread 代表持有排它锁对线程
- 都是对上面 3 个锁对包装
ReentrantReadWriteLock
- 默认非公平锁
- Sync NonfairSync FairSync ReadLock WriteLock
- ReadLock WriteLock 包装 Sync
- 有排它锁和共享锁，所以释放和获取有 2 种情况
- 都是对上面 5 个锁对包装
StampedLock
- Java 8 才有
- ReadLockView
- WriteLockView
- ReadWriteLockView

PlantUml

@startUml

package sun.misc {
  class Unsafe
}

package java.util.concurrent.locks {
  abstract class AbstractOwnableSynchronizer {
    -transient Thread exclusiveOwnerThread
    #AbstractOwnableSynchronizer()
    #final void setExclusiveOwnerThread(Thread thread)
    #final Thread getExclusiveOwnerThread()
  }
  abstract class AbstractQueuedLongSynchronizer {
    -static final Unsafe unsafe
    -volatile long state
  }
  abstract class AbstractQueuedSynchronizer {
    -static final Unsafe unsafe
    -volatile int state
  }
  interface Condition {
    +void await() throws InterruptedException
    +void awaitUninterruptibly()
    +long awaitNanos(long nanosTimeout) throws InterruptedException
    +boolean await(long time, TimeUnit unit) throws InterruptedException
    +boolean awaitUntil(Date deadline) throws InterruptedException
    +void signal()
    +void signalAll()
  }
  interface Lock {
    +void lock()
    +void lockInterruptibly() throws InterruptedException
    +boolean tryLock()
    +boolean tryLock(long time, TimeUnit unit) throws InterruptedException
    +void unlock()
    +Condition newCondition()
  }
  class LockSupport {
    -static final Unsafe UNSAFE
    +static void unpark(Thread thread)
    +static void park(Object blocker)
    +static void parkNanos(Object blocker, long nanos)
    +static void parkUntil(Object blocker, long deadline)
    +static Object getBlocker(Thread t)
    +static void park()
    +static void parkNanos(long nanos)
    +static void parkUntil(long deadline)
    ~static final int nextSecondarySeed()
  }
  interface ReadWriteLock {
    +Lock readLock()
    +Lock writeLock()
  }
  class ReentrantLock
  class ReentrantReadWriteLock {
    -static final Unsafe UNSAFE
    -ReadLock readerLock
    -WriteLock writerLock
  }
  class StampedLock
}

AbstractOwnableSynchronizer <|-- AbstractQueuedLongSynchronizer
AbstractOwnableSynchronizer <|-- AbstractQueuedSynchronizer
Lock <.. ReadWriteLock
Lock <|.. ReentrantLock
ReadWriteLock <|.. ReentrantReadWriteLock

Unsafe <.. AbstractQueuedLongSynchronizer
Unsafe <.. AbstractQueuedSynchronizer
Condition <.. Lock
Unsafe <.. LockSupport
Condition <.. ReentrantLock
Unsafe <.. ReentrantReadWriteLock
ReadWriteLock <.. StampedLock

@endUml