Java并发编程中的类结构与重构技巧

### Java并发编程中的类结构与重构技巧 在Java并发编程中，为了提高代码的可重用性和性能，我们需要掌握一些有效的类结构和重构技巧。下面将详细介绍相关内容。 #### 1. SpinLock类 SpinLock类是一种锁机制，它的`release`方法使用`synchronized`修饰，以确保在释放锁时进行内存同步。以下是SpinLock类的代码示例： ```java class SpinLock { // Avoid needing to use this private volatile boolean busy = false; synchronized void release() { busy = false; } void acquire() throws InterruptedException { int spinsBeforeYield = 100; // 100 is arbitrary int spinsBeforeSleep = 200; // 200 is arbitrary long sleepTime = 1; // 1msec is arbitrary int spins = 0; for (;;) { if (!busy) { // test-and-test-and-set synchronized(this) { if (!busy) { busy = true; return; } } } if (spins < spinsBeforeYield) { // spin phase ++spins; } else if (spins < spinsBeforeSleep) { // yield phase ++spins; Thread.yield(); } else { // back-off phase Thread.sleep(sleepTime); sleepTime = 3 * sleepTime / 2 + 1; // 50% is arbitrary } } } } ``` 在`acquire`方法中，存在三个阶段： - **自旋阶段（spin phase）**：当`spins`小于`spinsBeforeYield`时，线程会不断自旋。 - **让步阶段（yield phase）**：当`spins`大于等于`spinsBeforeYield`且小于`spinsBeforeSleep`时，线程会调用`Thread.yield()`方法让步。 - **退避阶段（back-off phase）**：当`spins`大于等于`spinsBeforeSleep`时，线程会进入睡眠状态，并且睡眠时间会逐渐增加。 #### 2. 类的结构化与重构 基本的等待和通知技术可以与其他设计策略结合，以提高类的可重用性和性能，同时实现对操作的更细粒度控制。以下将介绍几种常见的模式和技术。 ##### 2.1 状态跟踪 编写受保护方法的一种保守策略是每次更改实例变量的值时都调用`notifyAll`。这种策略具有高度的可扩展性，但可能会产生一些无用的通知。通过逻辑状态分析，可以消除一些或所有无用的通知。 ###### 2.1.1 通道和有界缓冲区 通道抽象在并发软件设计中起着核心作用。以下是`Channel`接口的定义： ```java interface Channel { void put(Object x) throws InterruptedException; Object take() throws InterruptedException; } ``` 有界缓冲区可以用作通道，它的结构与有界计数器类似。以下是`BoundedBuffer`接口的定义： ```java interface BoundedBuffer extends Channel { int capacity(); // INV: 0 < capacity int size(); // INV: 0 <= size <= capacity } ``` 有界缓冲区的逻辑状态和转换如下表所示： | 状态 | 条件 | put | take | | ---- | ---- | ---- | ---- | | full | size == capacity | no | yes | | partial | 0 < size < capacity | yes | yes | | empty | size == 0 | yes | no | 通过分析可知，只有从`empty`和`full`状态转换时才可能影响等待的线程。以下是`BoundedBufferWithStateTracking`类的实现： ```java class BoundedBufferWithStateTracking { protected final Object[] array; // the elements protected int putPtr = 0; // circular indices protected int takePtr = 0; protected int usedSlots = 0; // the count public BoundedBufferWithStateTracking(int capacity) throws IllegalArgumentException { if (capacity <= 0) throw new IllegalArgumentException(); array = new Object[capacity]; } public synchronized int size() { return usedSlots; } public int capacity() { return array.length; } public synchronized void put(Object x) throws InterruptedException { while (usedSlots == array.length) // wait until not full wait(); array[putPtr] = x; putPtr = (putPtr + 1) % array.length; // cyclically inc if (usedSlots++ == 0) // signal if was empty notifyAll(); } public synchronized Object take() throws InterruptedException{ while (usedSlots == 0) // wait until not empty wait(); Object x = array[takePtr]; array[takePtr] = null; takePtr = (takePtr + 1) % array.length; if (usedSlots-- == array.length) // signal if was full notifyAll(); return x; } } ``` 这个版本的实现可以减少不必要的通知，从而提高效率。 ###### 2.1.2 状态变量 使用状态变量可以简化和更好地封装状态跟踪。状态变量通常是枚举类型，在相关字段更新后重新评估。以下是`BoundedCounterWithStateVariable`类的实现： ```java class BoundedCounterWithStateVariable { static final int BOTTOM = 0, MIDDLE = 1, TOP = 2; protected int state = BOTTOM; // the state variable protected long count = MIN; protected void updateState() {//PRE: synch lock held int oldState = state; if (count == MIN) state = BOTTOM; ```