《Java并发编程实战》读书笔记五:深入理解同步实现

一、构建自定义的同步工具

1. 内置的条件队列

条件队列就如同烤面包机上的面包已好的铃声。如果你正在听着它, 当面包烤好后你可以立即注意到, 并且放下手头的事情开始品尝面包, 如果你没有听见它, 你会错过通知消息, 但是回到厨房后还是看到面包的状态, 如果已经烤完, 就取面包, 如果未烤完, 就再次监听铃声。

条件队列中的元素是一个个正在等待相关条件的线程。每一个对象都可以作为一个条件队列,并且Object的wait,notify和notifyAll构成了内部条件队列的API。

wait:wait是等待的意思,调用wait会自动释放锁,并请求系统挂起当前线程,从而使其他线程能够获得这个锁
notify:发出通知,解除阻塞条件,JVM会从这个条件队列上等待的多个线程选择一个来唤醒
notifyAll:发出通知,解除阻塞条件,JVM会唤醒所有在这个条件队列上等待的线程
条件谓语:线程等待的条件

条件等待中存在一个很重要的三元关系:synchronized,wait和一个条件谓语。
条件变量由一个锁保护,检查条件谓语时必须先持有锁,调用wait和notifyAll所在方法的对象必须是同一个对象。

用下面这个代码来解析:

public synchronized V take() throws InterruptedException{
    while(isEmpty()){
        wait();
    }
    V v = get();
    notifyAll();
    return v;
}

在这块代码中,isEmpty就是take()方法的条件谓语,A线程如果判断为空,将会调用wait,阻塞A线程,直到其它线程B操作使isEmpty为false,接着B调用notifyAll,释放锁后,唤醒线程A。

notify和notifyAll的区别:
大多数情况下,应该优先选择notifyAll。假如线程A在条件队列上等待条件谓语PA,线程B在同一个条件队列上等待条件谓语PB,假如线程C将PB变为真,且调用notify,JVM将从众多的等待线程选择其中A来唤醒,但是A看到PA仍然为false,于是继续等待,然而线程B本可以开始执行,却没有被唤醒。

只有满足一下两个条件时,才能用单一的notify而不是notifyAll:
1. 所有等待线程的类型都相同
2. 单进单出:在条件变量上的每次通知,最多只能唤醒一个线程来执行
如果有10个线程在条件队列中等待, 调用notifyAll会唤醒每一个线程, 让它们去竞争锁, 然后它们中的大多数或者全部又回到休眠状态, 这意味着每一个激活单一线程执行的事件, 都会带来大量的上下文切换, 和大量竞争锁的请求

2. Condition对象

内置的条件队列有一些缺陷,每一个内置锁都只能由一个相关联的条件队列。如果想要编写一个带有多个条件谓语的并发对象,可以使用Lock和Condition。

一个Condition和一个单独的Lock相关联, 调用Lock.newCondition()方法, 可以创建一个Condition。每个Lock可以有任意数量的Condition对象. wait, notify, notifyAll在Condition中都有对应的:await, signal, signalAll, 而且一定要使用后者!

示例:

public class ConditionBoundedBuffer {  
    private static final int BUFFER_SIZE = 2;  
    private final Lock lock = new ReentrantLock();  
    private final Condition notFull = lock.newCondition();  
    private final Condition notEmpty = lock.newCondition();  
    private final T[] items = (T[]) new Object[BUFFER_SIZE];  
    private int tail, head, count;  

    public void put(T x) throws InterruptedException {  
        lock.lock();  
        try {  
            while (count == items.length) {  
                notFull.await();  //
            }  
            items[tail] = x;  
            if (++tail == items.length) {  
                tail = 0;  
            }  
            count++;  
            notEmpty.signal();  //
        } finally {  
            lock.unlock();  
        }  
    }  

    public T take() throws InterruptedException {  
        lock.lock();  
        try {  
            while (count == 0) {  
                notEmpty.await();// 
            }  
            T x = items[head];  
            items[head] = null;  
            if (++head == items.length) {  
                head = 0;  
            }  
            count--;  
            notFull.signal();  //
            return x;  
        } finally {  
            lock.unlock();  
        }  
    }  
}  

3.AbstractQueuedSynchronizer(AQS)

同步的实现都是基于AbstractQueuedSynchronizer(AQS),AQS是一个用于构建锁和同步器的框架,例如ReentrantLock,Semaphore,CountDownLatch等都是基于AQS构建的。

AQS构建的容器中,最基本的就是获取操作和释放操作,对于CountDownLatch,获取意味着等待并直到闭锁到达结束状态,对于FutureTask,获取意味着等待直到任务已经完成。

AQS负责同步容器类中的状态,它管理了一个整数状态信息,可以通过getState,setState以及compareAndSetState来设置和获取。例如ReentrantLock用它来表示线程已经重复获取该锁的次数,Semaphore用它来表示剩余的许可数量,FutureTask用它来表示任务的状态(尚未开始,正在运行,已完成以及以取消)

AQS获取操作可能是独占的, 就像ReentrantLock一样, 也可能是非独占的, 就像Semaphore和CountDownLatch一样, 这取决于不同的Synchronizer

下面使用AQS来实现一个闭锁:(事实上,同步容器就是这样做的)

public class OneShotLatch {  
    private final Sync sync = new Sync();  

    private class Sync extends AbstractQueuedSynchronizer {  
        @Override  
        protected int tryAcquireShared(int arg) {  
            return (getState() == 1) ? 1 : -1;  
        }  

        @Override  
        protected boolean tryReleaseShared(int arg) {  
            setState(1);  
            return true;  
        }  
    }  

    public void signal() {  
        sync.releaseShared(0);  
    }  

    public void await() throws InterruptedException {  
        sync.acquireInterruptibly(0);  
    }  
}

代码中通过AQS管理闭锁的状态:关闭0, 打开1。await方法调用AQS的acqurieSharedInterruptibly, 后者随后请求OneShotLatch中的tryAcquireShared方法必须返回一个值来表明操作能否继续执行. 如果闭锁已经事先打开, tryAcquireShared会返回成功, 并允许线程通过; 否则他会返回一个值, 表明获取请求的尝试失败. acquireSharedInterruptibly方法处理失败的方式, 是把线程植入一个队列中, 该队列中的元素都是等待中的线程, signal调用releaseShared, 进而导致tryReleaseShared被调用. tryReleasseShared的实现无条件地把闭锁的状态设置为打开, 通过返回值表明Synchronizer处于完全释放的状态

4.java.util.concurrent同步类中的AQS

java.util.concurrent同步类都没有直接扩展AQS,而是将他们的功能委托给AQS子类实现。
java.util.concurrent中基于AQS开发的类有:ReentrantLock,Semaphore,ReentrantReadWriteLock,CountDownLatch,SynchronousQueue和FutureTask等。

二、原子变量和非阻塞同步机制

非阻塞算法被广泛用于操作系统和JVM中实现线程/进程调度机制,垃圾回收机制以及锁和其它并发数据结构。

1. 比较并交换(CAS)

概念:
1. 比较并交换有三个操作数: 内存位置V,进行比较的值A,新值B
2. 当且仅当V的值等于旧值A时, CAS才会用新值B原子化地更新V的值, 否则它什么都不会做。
3. 无论位置V的值是否等于A,CAS都会返回V的真实值。CAS的意思是: 我认为V的值应该是A, 如果是, 那么将B值赋值给V, 若不是, 则不修改, 并告诉我V的旧值为多少。
4. CAS是一项乐观技术: 它抱着成功的希望进行更新, 并且如果另一个线程在上次检查后更新了该变量, 它能够发现错误
5. 当多个线程试图使用CAS同时更新相同的变量时, 只有一个线程会更新变量的值,而其他的都会失败。然而,失败的线程不会被挂起, 他们会被告知这次赛跑失利, 但是允许重试。由于一个线程不会竞争CAS时不会被阻塞,因此它可以决定是否重试。

CAS的典型使用模式:
首先从V中读取值A,根据A计算值B,然后通过CAS以原子操作将V的值A变为B。

一个模拟的CAS:

public class SimulateCAS {  
    private int value;  

    public synchronized int get() {  
        return value;  
    }  

    public synchronized int compareAndSwap(int expectedValue, int newValue) {  
        int oldValue = value;  
        if (expectedValue == oldValue) {  
            value = newValue;  
        }  
        return oldValue;  //无论能否修改,都返回旧值
    }  

    public synchronized boolean compareAndSet(int expectedValue, int newValue) {  
        return (expectedValue == compareAndSwap(expectedValue, newValue));  
    }  
}

基于CAS实现的线程安全的计数器:

public class CasCounter {  
    private SimulateCAS value = new SimulateCAS();  

    public int getValue() {  
        return value.get();  
    }  

    public int increment() {  
        int v;  
        do {  
            v = value.get();  
        } while (v != value.compareAndSwap(v, v + 1));  
        return v + 1;  
    }  
}  

2.非阻塞算法

如果线程在持有锁时由于阻塞IO,内存页缺失或其他延迟导致推迟执行,那么很可能所有的线程都不能继续执行下去。
非阻塞算法:如果在某种算法中,一个线程的失败或者挂起不会导致其他线程也失败或挂起,那么这种算法就被称为非阻塞算法。
无锁算法:如果在算法的每一个步骤都存在某个线程能够执行下去,那么这种算法称为无锁算法。
无阻塞,无锁算法:如果算法中仅将CAS用于协调线程之间的操作,并且能够正确地实现,那么它是一种无阻塞,无锁算法。

上面基于CAS实现的线程安全的计数器就是无阻塞算法实现

基于非阻塞的Stack实现:

public class ConcurrentStack {  
    class Node {  
        E item;  
        Node next;  
        public Node(E item) {  
            this.item = item;  
        }  

    }  

    AtomicReference> top = new AtomicReference>(); // 对栈顶的一个引用  

    public void push(E item) {  
        Node newHead = new Node(item);  
        Node oldHead;  
        do {  
            oldHead = top.get();  
            newHead.next = oldHead;  
        } while (!top.compareAndSet(oldHead, newHead));  
    }  

    public E pop() {  
        Node oldHead;  
        Node newHead;  
        do {  
            oldHead = top.get();  
            if (oldHead == null) {  
                return null;  
            }  
            newHead = oldHead.next;  
        } while (!top.compareAndSet(oldHead, newHead));  
        return oldHead.item;  
    }  
}

基于非阻塞的链表:

public class LinkedQueue {  
    static class Node {  

        final E item;  
        final AtomicReference> next;  

        public Node() {  
            this(null, null);  
        }  

        public Node(E item, Node next) {  
            this.item = item;  
            this.next = new AtomicReference>(next);  
        }  
    }  

    private final Node dummy = new Node();  
    private final AtomicReference> head = new AtomicReference>(dummy);  
    private final AtomicReference> tail = new AtomicReference>(dummy);  

    public boolean put(E item) {  
        Node newNode = new Node(item, null);  
        while (true) {  
            Node curTailNode = tail.get();  
            Node tailNextNode = curTailNode.next.get();  
            if (curTailNode == tail.get()) {  
                if (tailNextNode == null) {  
                    // 更新尾节点下一个节点  
                    if (curTailNode.next.compareAndSet(null, newNode)) {  
                        // 更新成功, 将尾节点指向下一个节点  
                        tail.compareAndSet(curTailNode, newNode);  
                        return true;  
                    }  
                } else {  
                    // 在更新过程中, 发现尾节点的下一个节点被更新了, 将尾节点指向下一个节点  
                    tail.compareAndSet(curTailNode, tailNextNode);  
                }  
            }  
        }  
    }  

    public static void main(String[] args) {  
        final LinkedQueue queue = new LinkedQueue();  
        new Thread(new Runnable() {  
            @Override  
            public void run() {  
                queue.put("item1");  
            }  
        }).start();  
        new Thread(new Runnable() {  
            @Override  
            public void run() {  
                queue.put("item2");  
            }  
        }).start();  
    }  
}

你可能感兴趣的:(《Java并发编程实战》读书笔记五:深入理解同步实现)