多线程（四）

最新推荐文章于 2024-04-09 05:24:52 发布

dhiwhdiow

最新推荐文章于 2024-04-09 05:24:52 发布

阅读量718

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/baidu_40931662/article/details/86614471

版权

Java 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

一. 初识Lock与AbstractQueuedSynchronizer（AQS）

二. ReentrantLock（独占式重入锁）

1. 重入的实现

2. 公平锁OR非公平锁

三. 可重入读写锁---ReentrantReadWriteLock详解

1. 写锁---WriteLock（独占锁）

2. ReadLock---读锁（共享式锁）

3. 缓存的实现应用读写锁

4. 锁降级

四. Condition接口的await、signal机制

1. 与内建锁wait、notify的区别

2. 等待队列

3. 应用

一. 初识Lock与AbstractQueuedSynchronizer（AQS）

1. Lock简介

在Lock接口出现之前，java程序主要靠synchronized关键字实现锁的功能，而在JDK5之后，并发包中增加了lock接口，他提供了与synchronized一样的锁功能。

lock在juc包下。（java.util.concurrent）

与内建锁不同的是，内建锁是隐式的加减锁，而lock是显式的进行锁的获取和消除。

通常使用lock的情况如下：

Lock lock = new ReentrantLock();
        lock.lock();
        try{
            ......
        }finally {
            lock.unlock();
        }

2. Lock常用API

lock体系拥有可中断的获取锁、超时获取锁以及共享锁等内建锁不具备的特性。

常用API：

void lock(); //获取锁
void lockInterruptibly() throws InterruptedException(); //响应中断锁
boolean tryLock(); //只有在调用是才可以获取锁，获取到锁返回true，否则返回false
boolean tryLock(long time, TimeUnit unit); //超时获取锁，在规定时间内未获取到锁返回false
Condition newCondition(); //获取与lock绑定的等待通知组件
void unlock(); //释放锁

3. 初识AQS（队列同步器）

同步器是用来构建锁以及其他同步组件的基础框架，它的实现主要是依赖一个int状态变量以及通过一个FIFO队列共同构成同步队列。它的子类必须重写AQS的protected修饰的用来改变同步状态的方法，其它方法主要是实现了排队与阻塞机制。int状态的更新使用getState()，setState()以及compareAndSetState()方法。

同步器是实现锁的关键，在锁的实现中聚合同步器，利用同步器实现锁的语义。可以这样理解二者的关系：

lock：面向使用者，定义了使用者与锁交互的接口。

AQS：面向锁的实现者，屏蔽了同步状态的管理，线程排队，线程等待与唤醒等等底层操作。

4. AQS的模板模式

AQS使用模板方法模式，将一些与状态相关的核心方法开放给子类重写，而后AQS会使用子类重写的关于状态的方法进行线程的排队，阻塞以及唤醒等操作。

例：自己实现简易的Lock锁

package www.like.java;


import com.sun.corba.se.impl.orbutil.concurrent.Sync;

import java.sql.Time;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;


//自定义锁
class Mutex implements Lock{
    private Sync sync = new Sync();

    //自定义同步器
    static class Sync extends AbstractQueuedSynchronizer {
        @Override
        protected boolean tryAcquire(int arg) {

            //0表示无锁状态，更新为1表示当前线程拿到锁
            if (arg != 1){
                throw new RuntimeException("arg参数不为1");
            }
            //将0状态改为1状态
            if (compareAndSetState(0,1)){
                //此时线程成功获取同步状态，将当前线程ID扔进去
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        @Override
        protected boolean tryRelease(int arg) {
            if(getState() == 0){
                throw new IllegalMonitorStateException();
            }
            //当前线程置空
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        @Override
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }
    }

    //-------------------------------------------------------------------


    @Override
    public void lock() {
        sync.acquire(1);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    @Override
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1,time);
    }

    @Override
    public void unlock() {
        sync.release(1);
    }

    @Override
    public Condition newCondition() {
        return null;
    }

    //------------------------------------------------------------------------

}

public class Test {
    public static void main(String[] args)  {
        Lock lock = new Mutex();
        for (int i = 0; i < 10; i++){
            Thread thread = new Thread(()->{
               lock.lock();
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            });
            thread.start();
        }
    }
}

结果表明，同一时间只有一个线程获取到锁，这也印证了我们的锁实现是正确的。

（如果有些方法不明白的，会在下面进行讲解）

5. AQS详解

在同步组件（锁）中，AQS是最核心的部分。同步组件依赖AQS提供的模板方法来实现同步语义。

AQS核心组成：同步队列、独占锁的获取与释放、共享锁的获取与释放、可中断锁、超时锁。

同步队列：

在AQS内部有一个静态内部类Node，这是同步队列中每个具体的节点。

节点中有如下属性：

int waitStatus：节点状态
Node prev：同步队列中前驱节点
Node next：同步队列中后继结点
Thread thread：当前节点包装的线程对象
Node nextWaiter：等待队列中下一个节点

节点状态值如下：

int INITIAL = 0; //初始状态
int CANCELLED = 1; //当前节点从同步队列中取消
int SIGNAL = -1; //后继节点处于阻塞（wait）状态。如果当前节点释放同步状态会通知后继节点，使后继节点继续运行
int CONDITION = -2; //节点处于等待队列中。当其他线程对Condition调用signal()方法后，该节点会从等待队列移到同步队列中
int PROPAGATE = -3; //共享式同步状态会无条件的传播

AQS同步队列采用带有头尾节点的双向链表。

独占式锁：

void acquire(int arg)：独占式获取同步状态，如果获取失败，插入同步队列进行等待
void acquireInterruptibly(int arg)：在1的基础上，此方法可以在同步队列中响应中断
boolean tryAcquireNanos(int arg, long nanosTimeOut)：在2的基础上增加了超时等待功能，到了预计时间还未获得锁就直接返回
boolean tryAcquire(int arg)：获取锁成功返回true，失败返回false
boolean release(int arg)：释放同步状态，该方法会唤醒同步队列中的下一个节点

共享式锁：

void acquireShared(int arg)：共享获取同步状态，同一时刻多个线程获取同步状态
void acquireSharedInterruptibly(int arg)：在1的基础上增加相应中断
boolean tryAcquireSharedNanons(int arg, long nanosTimeOut)：在2的基础上增加超时等待功能
boolean releaseShared(int arg)：共享式释放同步状态

二. ReentrantLock（独占式重入锁）

1. 重入的实现

重入：表示能够对共享资源重复加锁，即当前线程再次获取锁时不会被阻塞。

我们来看一下源码：

c代表的是获取当前同步状态。如果当前同步状态不为0，表示此时同步状态已被线程获取，就执行else语句，else语句是判断持有同步状态的线程是否为当前线程，如果是，同步状态再次加1并返回true，表示持有线程重入同步块。

释放过程：

当且仅当持有线程为当前线程并且同步状态减为0时，表示锁被正确释放，否则调用setState()将减1后的状态设置回去。

2. 公平锁OR非公平锁

ReentrantLock支持两种锁，公平锁和非公平锁。那么，什么是公平性呢？如果锁的获取顺序符合时间上的顺序，即等待时间最长的线程最先获取锁。那么就是公平锁，反之，即为非公平锁。ReentrantLock默认使用非公平锁。

如果要想使用公平锁，需要调用ReentrantLock的有参构造，传入true，获取内置的公平锁。

对比：

公平锁保证了获取到锁的线程一定是等待时间最长的线程，保证了请求资源时间上的绝对顺序，需要频繁的进行上下文切换，性能开销较大。
非公平锁保证系统有更大的吞吐量（效率较高），但是会造成线程的饥饿现象（有的线程永远获取不到锁）。

三. 可重入读写锁---ReentrantReadWriteLock详解

读写锁：允许同一时刻被多个读线程访问，但是在写线程访问时，读线程和其他写线程都会被阻塞。

写线程能够获取到锁的条件：没有任何读写线程拿到锁。

注意：读线程与写线程互斥，写线程与读线程和写线程都互斥。

1. 写锁---WriteLock（独占锁）

在同一时刻写锁不能被多个线程获取，很显然，它是独占锁，而实现锁的同步语义是通过重写AQS的tryAcquire()方法实现的，源码及分析如下：

protected final boolean tryAcquire(int acquires) {
    /*
     * Walkthrough:
     * 1. If read count nonzero or write count nonzero
     *    and owner is a different thread, fail.
     * 2. If count would saturate（饱和）, fail. (This can only
     *    happen if count is already nonzero.)
     * 3. Otherwise, this thread is eligible（合格的） for lock if
     *    it is either a reentrant acquire or
     *    queue policy allows it. If so, update state
     *    and set owner.
     */
    Thread current = Thread.currentThread();
    //判断当前同步状态
    int c = getState();
    //判断写锁的获取次数（exclusive---独占式）
    int w = exclusiveCount(c);
    if (c != 0) {
        // (Note: if c != 0 and w == 0 then shared count != 0)
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        // Reentrant acquire
        setState(c + acquires);
        return true;
    }
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires))
        return false; 
    //获取写锁成功
    setExclusiveOwnerThread(current);
    return true;
}

***重要：同步状态的低16位表示写锁获取次数，高16位表示读锁获取次数。***

写锁的获取逻辑：当读锁已被读线程或写锁已被其他线程获取，则写锁获取失败，否则，当前同步状态没有被任何读写线程获取，当前线程获取写锁成功并且支持重入。

2. ReadLock---读锁（共享式锁）

源码及分析如下：

protected final int tryAcquireShared(int unused) {
    /*
     * Walkthrough:
     * 1. If write lock held by another thread, fail.
     * 2. Otherwise, this thread is eligible for
     *    lock wrt state, so ask if it should block
     *    because of queue policy. If not, try
     *    to grant by CASing state and updating count.
     *    Note that step does not check for reentrant
     *    acquires, which is postponed to full version
     *    to avoid having to check hold count in
     *    the more typical non-reentrant case.
     * 3. If step 2 fails either because thread
     *    apparently not eligible or CAS fails or count
     *    saturated, chain to version with full retry loop.
     */
    Thread current = Thread.currentThread();
    int c = getState();
    //如果写锁已经被获取并且获取写锁的线程不是当前线程
    //线程获取读锁失败并返回-1
    if (exclusiveCount(c) != 0 &&
        getExclusiveOwnerThread() != current)
        return -1;
    int r = sharedCount(c);
    if (!readerShouldBlock() &&
        r < MAX_COUNT &&
        //当前线程获取读锁
        compareAndSetState(c, c + SHARED_UNIT)) {
        //当前获取锁的次数
        if (r == 0) {
            firstReader = current;
            firstReaderHoldCount = 1;
        } else if (firstReader == current) {
            firstReaderHoldCount++;
        } else {
            HoldCounter rh = cachedHoldCounter;
            if (rh == null || rh.tid != getThreadId(current))
                cachedHoldCounter = rh = readHolds.get();
            else if (rh.count == 0)
                readHolds.set(rh);
            rh.count++;
        }
        return 1;
    }
    //CAS失败或者已经获取读锁的线程再次重入
    return fullTryAcquireShared(current);
}

3. 缓存的实现应用读写锁

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

/**
 * 读写锁实现缓存
 */

public class Test {
    static Map<String,Object> map = new HashMap<>();
    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock readLock = rwl.readLock();
    static Lock writeLock = rwl.writeLock();

    /**
     * 线程安全的根据一个key获取value
     * @param key
     * @return
     */

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

    /**
     * 线程安全的根据key设置value，并返回旧的value
     * @param key
     * @param value
     * @return
     */

    public static Object put(String key,Object value){
        writeLock.lock();
        try {
            return map.put(key,value);
        }finally {
            writeLock.unlock();
        }
    }

    /**
     * 线程安全的清空所有value
     */
    
    public static final void clear(){
        writeLock.lock();
        try {
            map.clear();
        }finally {
            writeLock.unlock();
        }
    }

4. 锁降级

写锁可以降级为读锁，读锁不能升级为写锁。

四. Condition接口的await、signal机制

1. 与内建锁wait、notify的区别

Object类提供的wait、notify方法是与对象监视器monitor配合完成线程的等待与通知机制，属于JVM底层实现。而Condition与Lock配合完成的等待通知机制属于Java语言级别，具有更高的控制与扩展性。
Condition独有特性：

支持不响应中断，而Object不支持。
支持多个等待队列，而Object只有一个。
支持截止时间设置，而Object不支持。

等待方法：

void await() throws InterruptedException---同Object.wait()，直到被中断或唤醒。
void awaitUninterruptibly()---不响应中断，直到被唤醒。
boolean await(long time, TimeUnit unit) throws InterruptedException---同Object.wait(long timeout)，多了自定义时间单位，中断、超时、被唤醒。
boolean awaitUntil(Date deadline) throws InterruptedException---支持设置截止时间。

唤醒方法：

signal()：唤醒一个等待在condition上的线程，将该线程由等待队列转移到同步队列中。

signalAll()：将所有等待在condition上的线程全部转移到同步队列中。

2. 等待队列

等待队列与同步队列共享Node节点类（内部静态类），等待队列是一个单向的有头尾节点的队列。

3. 应用

Condition实现的多生产多消费模型：

package www.like.java;

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

class Goods{
    private String name;
    private int count;
    private int maxCount;
    private Lock lock = new ReentrantLock();
    //消费者等待队列
    private Condition consumerCondition = lock.newCondition();
    //生产者等待队列
    private Condition producerCondition = lock.newCondition();
    public Goods(int maxCount) {
        this.maxCount = maxCount;
    }

    /**
     * 生产者方法
     * @param name  设置商品名称
     */

    public void setGoods(String name){
        lock.lock();
        try{
            //商品数量达到最大值，生产者线程进入生产者等待队列
            while(count == maxCount) {
                try {
                    System.out.println(Thread.currentThread().getName()+"还有很多商品，歇会~");
                    producerCondition.await();
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            this.name = name;
            count++;
            System.out.println(Thread.currentThread().getName()+"生产"+toString());
            //唤醒属于消费者队列的线程
            consumerCondition.signalAll();
        }finally {
            lock.unlock();
        }
    }

    /**
     * 消费者方法
     */

    public void getGoods(){
        try{
            lock.lock();
            while(count == 0){
                System.out.println(Thread.currentThread().getName()+"还没有商品");
                try {
                    consumerCondition.await();
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            count--;
            System.out.println(Thread.currentThread().getName()+"消费"+toString());
            //唤醒所有生产者线程
            producerCondition.signalAll();
        }finally {
            lock.unlock();
        }
    }

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", count=" + count +
                '}';
    }
}

class Producer implements Runnable{

    private Goods goods;

    public Producer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        while(true){
            this.goods.setGoods("computer");
        }
    }
}

class Consumer implements Runnable{
    private Goods goods;

    public Consumer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        while(true){
            this.goods.getGoods();}
    }
}


public class Test {

    public static void main(String[] args)  {
        Goods goods = new Goods(100);
        Producer producer = new Producer(goods);
        Consumer consumer = new Consumer(goods);
        List<Thread> list = new ArrayList<>();
        //启动10个生产者线程
        for(int i = 0; i < 10; i++){
            Thread thread = new Thread(producer,"生产者"+i);
            list.add(thread);
        }
        //启动15个消费者线程
        for(int i = 0; i < 15; i++){
            Thread thread = new Thread(consumer,"消费者"+i);
            list.add(thread);
        }
        //一键启动
        for(Thread th:list){
            th.start();
        }
    }
}