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

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 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();
        }
    }

}

你可能感兴趣的:(java并发编程的艺术笔记第五章——java中的锁)