锁

最新推荐文章于 2025-09-10 07:00:00 发布

转载最新推荐文章于 2025-09-10 07:00:00 发布 · 99 阅读

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/u/2286010/blog/3074046

本文详细介绍了Lock和Synchronized两种锁机制。Lock接口有多种获取锁的方法，其实现包括ReentrantLock等，支持可重入和响应中断。Synchronized有自旋锁、偏向锁等类型，执行过程会根据竞争情况从偏向锁逐步升级到重量级锁，线程争用激烈时可禁用偏向锁。

一、Lock

Lock接口的方法：

lock()：获取锁，如果锁被暂用则一直等待
unlock()：释放锁
tryLock()：注意返回类型是boolean，仅在调用时锁未被另一个线程保持的情况下，才获取该锁。如果锁被占用，则直接返回
tryLock(long time, TimeUnit unit)：比起tryLock()就是给了一个时间期限，保证等待参数时间
lockInterruptibly()：用该锁的获得方式，如果线程在获取锁的阶段进入了等待，那么可以中断此线程，先去做别的事

可重入锁

可重入锁意味着，线程可以进入任何一个它已经拥有的锁所同步着的代码块。Sychronized是可重入锁，Lock可选择是否可重入。

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
}

响应中断

线程因为等待获取Sychronized或普通Lock锁而引起阻塞时，是不能响应中断的（即调用interrupt()无法抛出异常，不影响阻塞状态）。但通过lock.lockInterruptibly()方法获取的锁可以响应中断。

class Syn{
    Lock lock=new ReentrantLock();
    public void get(){
        try{
            //普通锁
            lock.lock();
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(5*1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

public class ThreadTest extends Thread {
    Syn s;
    public ThreadTest(Syn s,String name){
        this.s=s;
        this.setName(name);
    }
    @Override
    public void run() {
        super.run();
        s.get();
    }

    public static void main(String[] args) {
        Syn s=new Syn();
        ThreadTest t1=new ThreadTest(s,"t1");
        ThreadTest t2=new ThreadTest(s,"t2");
        try{
            t1.start();
            Thread.sleep(1000);
            t2.start();
            Thread.sleep(1000);
            //此时t2处于等待获取锁的阻塞状态
            t2.interrupt();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

结果：

t1
t2

class Syn{
    Lock lock=new ReentrantLock();
    public void get(){
        try{
            //可中断锁
            lock.lockInterruptibly();
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(5*1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}
public class ThreadTest extends Thread {
    Syn s;
    public ThreadTest(Syn s,String name){
        this.s=s;
        this.setName(name);
    }
    @Override
    public void run() {
        super.run();
        s.get();
    }

    public static void main(String[] args) {
        Syn s=new Syn();
        ThreadTest t1=new ThreadTest(s,"t1");
        ThreadTest t2=new ThreadTest(s,"t2");
        try{
            t1.start();
            Thread.sleep(1000);
            t2.start();
            Thread.sleep(1000);
            t2.interrupt();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

结果：

t1
java.lang.InterruptedException
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222)
	at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
	at algorithm.Syn.get(ThreadTest.java:13)
	at algorithm.ThreadTest.run(ThreadTest.java:32)
Exception in thread "t2" java.lang.IllegalMonitorStateException
	at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
	at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
	at algorithm.Syn.get(ThreadTest.java:19)
	at algorithm.ThreadTest.run(ThreadTest.java:32)

Process finished with exit code 0

Lock的实现

ReentrantLock
ReentrantReadWriteLock
StampedLock

ReentrantReadWriteLock读写锁：

读写分离，即，读读共享、写写互斥、读写互斥。同时还支持一下功能：

支持公平和非公平的获取锁的方式；
支持可重入。读线程在获取了读锁后还可以获取读锁；写线程在获取了写锁之后既可以再次获取写锁又可以获取读锁；
还允许从写入锁降级为读取锁，其实现方式是：先获取写入锁，然后获取读取锁，最后释放写入锁。但是，从读取锁升级到写入锁是不允许的；

https://www.cnblogs.com/zaizhoumo/p/7782941.html

https://blog.youkuaiyun.com/fxkcsdn/article/details/82217760

二、Synchronized

自旋锁

自旋锁原理非常简单，如果持有锁的线程能在很短时间内释放锁资源，那么那些等待竞争锁的线程就不需要做内核态和用户态之间的切换进入阻塞挂起状态，它们只需要等一等（自旋），等持有锁的线程释放锁后即可立即获取锁，这样就避免用户线程和内核的切换的消耗。

但是线程自旋是需要消耗cup的，说白了就是让cup在做无用功，如果一直获取不到锁，那线程也不能一直占用cup自旋做无用功，所以需要设定一个自旋等待的最大时间。

如果持有锁的线程执行的时间超过自旋等待的最大时间扔没有释放锁，就会导致其它争用锁的线程在最大等待时间内还是获取不到锁，这时争用线程会停止自旋进入阻塞状态。

偏向锁

偏向锁，顾名思义，它会偏向于第一个访问锁的线程，如果在运行过程中，同步锁只有一个线程访问，不存在多线程争用的情况，则线程是不需要触发同步的，这种情况下，就会给线程加一个偏向锁。偏向锁通过消除资源无竞争情况下的同步原语，进一步提高了程序的运行性能。

如果在运行过程中，遇到了其他线程抢占锁，则持有偏向锁的线程会被挂起，JVM会消除它身上的偏向锁，将锁恢复到标准的轻量级锁。

偏向锁的获取过程：

访问Mark Word中偏向锁的标识是否设置成1，锁标志位是否为01，确认为可偏向状态。
如果为可偏向状态，则测试线程ID是否指向当前线程，如果是，进入步骤5，否则进入步骤3。
如果线程ID并未指向当前线程，则通过CAS操作竞争锁。如果竞争成功，则将Mark Word中线程ID设置为当前线程ID，然后执行5；如果竞争失败，执行4。
如果CAS获取偏向锁失败，则表示有竞争。当到达全局安全点（safepoint）时获得偏向锁的线程被挂起，偏向锁升级为轻量级锁，然后被阻塞在安全点的线程继续往下执行同步代码。（撤销偏向锁的时候会导致stop the word）
执行同步代码。