java并发编程的艺术笔记第五章——java中的锁

会跳舞的机器人

发布于 2018-09-21 16:15:57

4050

发布于 2018-09-21 16:15:57

1、Lock接口

锁是用来控制多个线程访问共享资源的方式，一般来说锁能够防止多个线程同时访问共享资源（有的锁可以允许多个线程访问共享资源，比如说读写锁），在Lock接口出现之前，java程序是靠synchronized关键字实现锁功能的，但是在JKD1.5之后并发包中新增了Lock接口及其实现来实现锁的功能。它提供了synchronized关键字类似的功能，但是Lock需要显示的获取锁、释放锁，而synchronized是通过隐式的方式来实现获取、释放锁。

Lock接口常见的API请自行查找

2、队列同步器

略…

3、重入锁

重入锁ReentrantLock，顾名思义，就是支持重进入的锁，重入锁支持同一个线程多次的获取锁。除此之外，该锁还支持获取锁时的公平和非公平性。

关于锁的公平性，如果在绝对的时间上，先对锁进行获取请求的操作一定会先被满足，则说明这个锁是公平的，反之则是不公平的。ReentrantLock的构造函数支持构造公平锁与非公平锁，默认为非公平锁，因为非公平锁能减少上下文切换，开销更小。

4、读写锁

读写锁支持同一时刻允许多个线程同时访问，但是在写线程访问时，所有的读线程与其他的写线程均被阻塞。读写锁维护了一对锁，读锁与写锁，通过读锁与写锁的分离，读写锁的并发性相比于其他排他锁都有很大的提升。

java并发包提供的读写锁是ReentrantReadWriteLock，它具有公平性选择、锁重入、锁降级三个特性。

读写锁实现简单缓存demo

package main.java.com.robot.demo;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author: 会跳舞的机器人
 * @date: 2017/8/16 14:45
 * @description: 读写锁实现缓存demo
 */
public class Cache {
    static Map<String, Object> map = new HashMap<>();
    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock writeLock = rwl.writeLock();
    static Lock readLock = rwl.readLock();

    /**
     * 读缓存
     */
    public static final Object get(String key) {
        readLock.lock();
        try {
            return map.get(key);
        } finally {
            readLock.unlock();
        }
    }

    /**
     * 写入缓存
     */
    public static final Object put(String key, Object value) {
        writeLock.lock();
        try {
            return map.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }

    /**
     * 清空缓存
     */
    public static final void clear() {
        writeLock.lock();
        try {
            map.clear();
        } finally {
            writeLock.unlock();
        }
    }

    /**
     * 获取缓存大小
     */
    public static final int size() {
        writeLock.lock();
        try {
            return map.size();
        } finally {
            writeLock.unlock();
        }
    }
}

5、LockSupport工具

略…

6、Condition接口

利用Condition接口来实现一个简单的有界阻塞队列，当队列为空时，队列的获取操作将会阻塞获取线程，知道有新的元素添加进来，当队列满时，队列的插入操作将会阻塞插入线程，知道队列出现“空位”。

package main.java.com.robot.demo;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author: 会跳舞的机器人
 * @date: 2017/8/16 15:48
 * @description: Condition实现有界阻塞队列demo
 */
public class BoundedQueue {
    private Object[] items;

    private int addIndex, removeIndex, count;

    private Lock lock = new ReentrantLock();

    private Condition notEmpty = lock.newCondition();

    private Condition notFull = lock.newCondition();

    public BoundedQueue(int size) {
        items = new Object[size];
    }

    /**
     * 添加一个元素，如果队列已满，则线程进入等待状态，直到有空位为止
     */
    public void add(Object object) throws InterruptedException {
        lock.lock();
        try {
            // 队列已满，阻塞线程
            while (items.length == count) {
                System.out.println("队列已满，等待......");
                notFull.await();
            }
            items[addIndex] = object;
            if (++addIndex == items.length) {
                addIndex = 0;
            }
            ++count;
            // 唤醒
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 删除队列的第一个元素，如果队列为空，则线程进入等待状态，直到有新元素添加进来
     */
    public Object remove() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                System.out.println("空队列，等待......");
                notEmpty.await();
            }
            Object obj = items[removeIndex];
            if (++removeIndex == items.length) {
                removeIndex = 0;
            }
            --count;
            notFull.signal();
            return obj;
        } finally {
            lock.unlock();
        }
    }

}

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2017-11-29，如有侵权请联系 cloudcommunity@tencent.com 删除

java