线程并发学习----线程阻塞（lock）

来源：互联网发布：本地连接网络使用率编辑：程序博客网时间：2024/06/06 07:13

线程并发学习

线程并发学习—-核心概念（转载）
线程并发学习—-线程阻塞（sleep、wait、notifyAll、notify、join）
线程并发学习—-线程阻塞（synchronized）
线程并发学习—-线程阻塞（lock）
线程并发学习—-Thread、Runnable、Callable
线程并发学习—-队列（Queue）
spring学习—-线程池
java中一些锁概念整理（转载）

Lock类图

这里写图片描述

Lock与synchronized比较

synchronized是java内置特性；Lock不是java内置的，是通过一个类实现同步
synchronized不需要手动释放锁，被修饰的方法或代码块执行完或者异常，jvm会自动释放锁；lock必需手动释放锁，否则有可能会造成死锁，并且一般在finally中释放锁
synchronized修饰，一个线程获取锁后，其它线程只能等待，其执行完成释放或异常释放；lock提供可以只等待一定的时间或者能够响应中断，而且lock可以知道获取锁是否成功
synchronized不会区分读写；lock可以有读写锁，实现读操作不被阻塞
synchronized使用简单，直接使用关键字就行；lock需要创建对象，调用对象方法实现同步

Lock简介

源码

public interface Lock {    //获取锁，如果当前有线程获取锁了，则进入等待队列    void lock();    //获取锁，如果当前有线程获取锁了，则进入等待队列  不过可以在该线程使用interrupt()方法能够中断线程的等待过程    void lockInterruptibly() throws InterruptedException;    //顾名思义，尝试获取锁，获取到了返回true，否则返回false   不会阻塞    boolean tryLock();    //顾名思义，尝试获取锁，获取到了返回true，否则等待设置的超时时间，如没有返回false，如果获取到锁返回true    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;    //顾名思义，释放锁，一般在finally块中使用，确保一定可以执行到，防止造成死锁    void unlock();    Condition newCondition();}

Lock的两个常用实现ReentrantLock和ReentrantReadWriteLock

ReentrantLock 可重入锁

源码

public class ReentrantLock implements Lock, java.io.Serializable {    private static final long serialVersionUID = 7373984872572414699L;    private final Sync sync;    abstract static class Sync extends AbstractQueuedSynchronizer {...}    static final class NonfairSync extends Sync {...}    static final class FairSync extends Sync {...}      //默认实现非公平锁    public ReentrantLock() {        sync = new NonfairSync();    }    //通过参数 true创建公平锁    false创建非公平锁    public ReentrantLock(boolean fair) {        sync = fair ? new FairSync() : new NonfairSync();    }    //所有获取释放锁的具体实现都是内部类Sync    public void lock() {        sync.lock();    }    public void lockInterruptibly() throws InterruptedException {        sync.acquireInterruptibly(1);    }    public boolean tryLock() {        return sync.nonfairTryAcquire(1);    }       public boolean tryLock(long timeout, TimeUnit unit)            throws InterruptedException {        return sync.tryAcquireNanos(1, unit.toNanos(timeout));    }    public void unlock() {        sync.release(1);    }}

从源码可知ReentrantLock实现功能主要依赖三个内部类Sync、NonfairSync、FairSync ，下面一起看看内部具体实现

Sync 继承 AbstractQueuedSynchronizer

源码

abstract static class Sync extends AbstractQueuedSynchronizer {        private static final long serialVersionUID = -5179523762034025860L;        abstract void lock();        final boolean nonfairTryAcquire(int acquires) {            final Thread current = Thread.currentThread();            int c = getState();            if (c == 0) {                if (compareAndSetState(0, acquires)) {                    setExclusiveOwnerThread(current);                    return true;                }            }            else if (current == getExclusiveOwnerThread()) {                int nextc = c + acquires;                if (nextc < 0) // overflow                    throw new Error("Maximum lock count exceeded");                setState(nextc);                return true;            }            return false;        }        protected final boolean tryRelease(int releases) {            int c = getState() - releases;            if (Thread.currentThread() != getExclusiveOwnerThread())                throw new IllegalMonitorStateException();            boolean free = false;            if (c == 0) {                free = true;                setExclusiveOwnerThread(null);            }            setState(c);            return free;        }        protected final boolean isHeldExclusively() {            return getExclusiveOwnerThread() == Thread.currentThread();        }        final ConditionObject newCondition() {            return new ConditionObject();        }        //获取当前持有锁的线程        final Thread getOwner() {            return getState() == 0 ? null : getExclusiveOwnerThread();        }        final int getHoldCount() {            return isHeldExclusively() ? getState() : 0;        }        //当前锁是否有线程获取        final boolean isLocked() {            return getState() != 0;        }        private void readObject(java.io.ObjectInputStream s)            throws java.io.IOException, ClassNotFoundException {            s.defaultReadObject();            setState(0); // reset to unlocked state        }    }

AbstractQueuedSynchronizer源码

    //判断锁是否被持有是使用volatile修饰的int变量来判断的    private volatile int state;    protected final boolean compareAndSetState(int expect, int update) {        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);    }    public final void acquire(int arg) {        if (!tryAcquire(arg) &&            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))            selfInterrupt();    }     public final boolean release(int arg) {        if (tryRelease(arg)) {            Node h = head;            if (h != null && h.waitStatus != 0)                unparkSuccessor(h);            return true;        }        return false;    }

代码分析

可重入锁的实现
1、默认方式创建非公平锁
2、通过调用lock获取锁。因为是非公平锁，从代码可以看出它是直接尝试去获取锁（通过CAS），获取不到锁就和公平锁流程一样了,可以参考tryAcquire这个方法，如果获取不到锁就进入等待队列
3、获取锁后，执行相关逻辑，释放锁，删去当前持有锁的线程重置为null

锁是否被持有是通过private volatile int state; 值的变更实现的

NonfairSync 非公平锁（默认锁）继承Sync

源码

static final class NonfairSync extends Sync {        private static final long serialVersionUID = 7316153563782823691L;        final void lock() {            if (compareAndSetState(0, 1))                setExclusiveOwnerThread(Thread.currentThread());            else                acquire(1);        }        protected final boolean tryAcquire(int acquires) {            return nonfairTryAcquire(acquires);        }    }

FairSync 继承Sync

源码

static final class FairSync extends Sync {        private static final long serialVersionUID = -3000897897090466540L;        final void lock() {            acquire(1);        }        protected final boolean tryAcquire(int acquires) {            final Thread current = Thread.currentThread();            int c = getState();            if (c == 0) {                if (!hasQueuedPredecessors() &&                    compareAndSetState(0, acquires)) {                    setExclusiveOwnerThread(current);                    return true;                }            }            else if (current == getExclusiveOwnerThread()) {                int nextc = c + acquires;                if (nextc < 0)                    throw new Error("Maximum lock count exceeded");                setState(nextc);                return true;            }            return false;        }    }

公平锁和非公平锁比较

非公平锁获取锁时，不管锁是否被持有，直接去尝试获取锁，获取不到接下来流程与公平锁相同；共平锁先判断锁是否被持有，如果被持有，则进入等待队列，否则持有锁，修改相关状态

ReentrantReadWriteLock 读写锁

读写锁实现与ReentrantLock有点类似，也是通过内部类Sync、NonfairSync、FairSync，同时增加ReadLock、WriteLock，这里不列出源码了，感兴趣自己看，下面分析一下读写锁

读写锁底层也是volatile修饰的state，不过将其分为高16位和低16位；高16位为读锁数量，低16位为写锁数量（锁的持有最大数65535）

写锁

通过lock方法获取写锁，判断当前锁是否被持有，state是否为0

如果state不为0，判断是否有读锁或者当前持有锁的线程是否为当前线程，若没有读锁或不是当前线程持有，则进入等待队列，否则判断当前读锁的数量是否大于最大数，若是抛出异常，否则读锁数量加1
如果state为0，通过CAS获取锁，若成功，设置锁的持有者为当前线程，否则进入等待队列，接下来获取写锁逻辑与ReentrantLock一样

读锁

读锁的逻辑比写锁稍微复杂一些，这里列出大体逻辑，具体可参考“参考资料”，或者自己看源码

通过lock获取读锁，判断锁是否被线程持有写锁，并且不是当前线程，则等待
否则判断是否需要阻塞或读锁数是否大于最大数，如不大于通过CAS获取读锁，如果成功设置相关内部变量，否则进入fullTryAcquireShared，判断是否有写锁，及是否走写锁在等待，如果是进入等待队列

参考资料
https://www.cnblogs.com/dolphin0520/p/3923167.html
http://blog.csdn.net/prestigeding/article/details/53286756

阅读全文

0 0