Java显式锁

最新推荐文章于 2022-05-13 14:02:34 发布
最新推荐文章于 2022-05-13 14:02:34 发布
阅读量395 收藏 1
点赞数
分类专栏： Thread 文章标签： Lock ReadWriteLock Condition
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33704186/article/details/90723743
版权

Lock接口

接口代码：

public interface Lock{
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLcok(long timeout,TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

使用方式：

// ReentrantLock是Lock接口的默认实现类
Lock lock = new ReentrantLock();
lock.lock();
try{
...
}finally{
    lock.unlock();
}

注意事项：必须在finally块中释放锁。否则在被保护的代码中抛出了异常，那么这个锁永远都无法释放。

ReentrantLock

ReentrantLock既支持公平锁，也支持非公平锁。

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

ReentrantLock默认是非公平锁。
公平锁保障锁调度的公平性往往是以增加了线程的暂停和唤醒的可能性，即增加了上下文切换为代价的。公平锁适合于锁被持有的时间相对长或者线程申请锁的平均间隔时间相对长的情形。
线程切换的开销，其实就是非公平锁效率高于公平锁的原因，因为非公平锁减少了线程挂起的几率，后来的线程有一定几率逃离被挂起的开销。
内部锁仅支持非公平锁。

ReadWriteLock

public interface ReadWriteLock{
    Lock readLock();
    Lock writeLock();
}

读/写锁：一个资源可以被多个读操作访问，或者被一个写操作访问，但两者不能同时进行。
读锁对于读线程来说起到保护其访问的共享变量在其访问期间不被修改的作用，并使多个读线程可以同时读取这些变量从而提高了并发性；而写锁保障了写线程能够以独占的方式安全地更新共享变量。写线程对共享变量的更新对读线程是可见的。

锁获得条件排他性作用
读锁相应的写锁未被任何线程持有对读线程是共享的，对写线程是排他的允许多个读线程可以同时读取共享变量，并保障读线程读取共享变量期间没有其他任何线程能更新这些变量
写锁该写锁未被其他任何线程持有并且相应的
读锁未被其他任何线程持有		对写线程和读线程都是排他的使得写线程能够以独占的方式访问共享变量
ReentrantLockReadWriteLock

模版代码：

private final ReadWriteLock rwLock = new ReentrantLockReadWriteLock();
private final Lock readLock = rwLock.readLock();
private final Lock writeLock = rwLock.writeLock();

// 读线程执行该方法
public void reader(){
    // 申请读锁
    readLock.lock();
    try{
        // 再此区域读取共享变量
    } finally{
        // 总是在finally块中释放锁，以免锁泄漏 
        readLock.unlock();
    }
}

// 写线程执行该方法
public void writer(){
    // 申请写锁
    writeLock.lock();
    try{
        // 再此区域写共享变量
    } finally{
        // 总是在finally块中释放锁，以免锁泄漏 
        writeLock.unlock();
    }
}

代码示例：

import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockTest {
    public static void main(String[] args) {
        final Queue3 q3 = new Queue3();
        for (int i = 0; i < 3; i++) {
            new Thread() {
                @Override
                public void run() {
                    while (true) {
                        q3.get();
                    }
                }

            }.start();
        }
        for (int i = 0; i < 1; i++) {
            new Thread() {
                @Override
                public void run() {
                    while (true) {
                        q3.put(new Random().nextInt(10000));
                    }
                }

            }.start();
        }
    }
}

class Queue3 {
    /**
     * 共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
     */
    private Object data = null;
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    public void get() {
        rwl.readLock().lock();//上读锁，其他线程只能读不能写
        try {
            System.out.println(Thread.currentThread().getName() + " be ready to read data!");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " have read data :" + data);
        } finally {
            // 释放读锁
            rwl.readLock().unlock();
        }

    }

    public void put(Object data) {
        rwl.writeLock().lock();//上写锁，不允许其他线程读也不允许写
        try {
            System.out.println(Thread.currentThread().getName() + " be ready to write data!");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.data = data;
            System.out.println(Thread.currentThread().getName() + " have write data: " + data);
        } finally {
            rwl.writeLock().unlock();//释放写锁
        }
    }
}
使用场景
  • 只读操作比写（更新）操作要频繁得多
  • 线程持有锁时间比较长

同时满足上面两个条件的时候，读写锁才是适宜的选择。

ReentrantReadWriteLock所实现的读写锁是个可重入锁。ReentrantReadWriteLock支持锁的降级，即一个线程持有读写锁的写锁的情况下，可以继续获得相应的读锁。ReentrantReadWriteLock并不支持锁的升级。

示例代码：

import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class CacheDemo {
    /**
     * 缓存器
     */
    private Map<String, Object> map = new HashMap<>();
    private ReadWriteLock rwl = new ReentrantReadWriteLock();


    public Object get(String id) {
        Object value = null;
        rwl.readLock().lock();//首先开启读锁，从缓存中去取
        try {
            value = map.get(id);
            //如果缓存中没有释放读锁，上写锁
            if (value == null) {
                rwl.readLock().unlock();
                rwl.writeLock().lock();
                try {
                    if (value == null) {
                        // 此时可以去数据库中查找，这里简单的模拟一下
                        try {
                            TimeUnit.SECONDS.sleep(2);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        value = new Random().nextInt(100);
                        map.put(id, value);
                    }
                } finally {
                    rwl.writeLock().unlock(); //释放写锁
                }
                rwl.readLock().lock(); //然后再上读锁
            }
        } finally {
            rwl.readLock().unlock(); //最后释放读锁
        }
        return value;
    }

    public static void main(String[] args) throws InterruptedException {
        CacheDemo cacheDemo = new CacheDemo();
        for (int i = 0; i < 10; i++) {
            int a = i;
            new Thread() {
                @Override
                public void run() {
                    cacheDemo.get(String.valueOf(a));
                }
            }.start();
        }

        new Thread() {
            @Override
            public void run() {
                int i = 0;
                do {
                    System.out.println("读：key=" + i + ",value=" + cacheDemo.get(String.valueOf(i)));
                    i++;
                } while (i < 10);
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                int i = 10;
                do {
                    System.out.println("写：key=" + i + ",value=" + cacheDemo.get(String.valueOf(i)));
                    i++;
                } while (i < 15);
            }
        }.start();
    }

}

Lock接口中的Condition用法

如果想编写一个带有多个条件谓词的并发对象，或者想获得除了条件队列可见性之外的更多控制权，就可以使用显式的Lock和Condition而不是内置锁和条件队列，这是一种更灵活的选择。
一个Condition和一个Lock关联在一起，就像一个条件队列和一个内置锁相关联一样。要创建一个Condition，可以在相关联的Lock上调用Lock.newCondition方法。
与内置条件队列不同的是，对于每个Lcok，可以有任意数量的Condition对象。Condition对象继承了相关的Lock对象的公平性，对于公平的锁，线程会依照FIFO顺序从Condition.await中释放。
代码示例：

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

public class ConditionBoundedBuffer<T> {
    protected final Lock lock = new ReentrantLock();
    /**
     * 条件谓词：notFull(coun<items.length)
     */
    private final Condition notFull = lock.newCondition();
    /**
     * 条件谓词：notEmpty(count>0)
     */
    private final Condition notEmpty = lock.newCondition();
    private static final int BUFFER_SIZE = 100;
    private final T[] items = (T[]) new Object[BUFFER_SIZE];
    private int tail, head, count;

    /**
     * 阻塞并直到：notFull
     *
     * @param x
     * @throws InterruptedException
     */
    public void put(T x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length)
                notFull.await();
            items[tail] = x;
            if (++tail == items.length)
                tail = 0;
            ++count;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 阻塞并直到：notEmpty
     *
     * @return
     * @throws InterruptedException
     */
    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0)
                notEmpty.await();
            T x = items[head];
            items[head] = null;
            if (++head == items.length)
                head = 0;
            --count;
            notFull.signal();
            return x;
        } finally {
            lock.unlock();
        }
    }
}

测试：

import java.util.concurrent.TimeUnit;

public class ConditionBoundedBufferTest{

    public static void main(String[] args) throws InterruptedException {
         ConditionBoundedBuffer<String> list = new ConditionBoundedBuffer<>();
         new Thread(){
             @Override
             public void run(){
                 try {
                     list.take();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         }.start();

        new Thread(){
            @Override
            public void run(){
                try {
                    list.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();

        TimeUnit.SECONDS.sleep(2);

        new Thread(){
            @Override
            public void run(){
                try {
                    list.put("yangyun");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }
}

output:
Thread-0 take begin
Thread-0 take while
Thread-1 take begin
Thread-1 take while
Thread-2 put begin
Thread-2 put go on
Thread-0 take go on

Condition.await( )方法会释放锁，所以下一个线程可以进入take( )方法。当其他线程中使用signal( )或者signalAll( )方法时，线程会重新获得锁并继续执行。或者当线程中断时，也能跳出等待。

stepMoreForever
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Lockstep:Java框架，用于在网络上运行交互式仿真
05-02
锁步 一个用于在网络上运行交互式仿真的Java框架。 关于 问题： 我们有一个大型仿真，希望在网络上的多台计算机上运行 可以随时通过任何机器将命令发送到模拟 每台机器必须看到完全相同的模拟 有两种方法： 客户端-服务器：一名参与者运行整个模拟，并向所有客户端发送定期状态更新。 服务器是事实的单一来源。 对等：每个参与者都确定性地运行模拟。 必须协调交互式命令，以确保每个人都同步。 前一种方法的问题在于，它在模拟大小上的伸缩性很差。 后一种方法的问题在于，随着参与者人数的增加，它的伸缩性很差。 最佳的权衡将取决于应用程序。 这是点对点方法的框架。 概述 同行互相报告进度 每个对等方仅比最慢的对等方运行n刻度 动作排定在最慢的对等点之前>n滴答，以确保它们始终在正确的时间执行 该框架负责所有这些工作。 程序员必须确保： 模拟是确定性的 动作可以正确编码和解码 开始使用 Locks
Java并发编程 Lock锁
weixin_45183997的博客
04-20 90
synchronized和lock锁的区别。传统的synchronized。
多线程（四）显式锁、队列同步器
HK的博客
05-13 491
Lock、AQS、独占锁、共享锁
游戏中的网络同步机制——Lockstep
我的博客
12-29 907
0x00 前言 每个人或多或少都接触过网游，那个虚拟的世界给予了我们无穷的乐趣，而这个虚拟世界是如何完美的将身处天南地北的玩家连接在一起的呢？我们每个人的电脑配置都不一样，网络延迟也不同，但是在玩FPS（第一人称射击）游戏时，战斗感受与真实世界并无二致，网游是如何做到这一点的呢？ 本文将介绍和分析早期广泛在RTS（即时策略）游戏中应用的同步机制——Lockstep RTS游戏有很多，比如我...
Android中的锁——synchronized内置锁和Lock显示锁（自用）
wqn的博客
07-24 979
内置锁（synchorinized）：包括类锁（static修饰）和对象锁（没有static修饰），是可重入锁（自己不会把自己锁死，可内部递归调用自己，能把自己释放出来），是不能中断的，非公平锁 显示锁（Lock）： ReentranLock重入锁 Lock lock = new ReentranLock(true); // 传入true，创建一个公平锁 读写锁（ReadWriteLock）：速度快 公平锁和非公平锁 死锁：synchronized嵌套 // 都需要在synchronized中使用 w
Java并发编程之显式锁机制详解
08-29
主要为大家详细介绍了Java并发编程之显式锁机制的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
深入理解java内置锁(synchronized)和显式锁(ReentrantLock)
08-28
主要介绍了Java多线程之内置锁(synchronized)和显式锁(ReentrantLock)的深入理解新的和用法，具有一定参考价值，需要的朋友可以了解下。
Java并发显式锁和显式条件队列
12-22
一、显式锁 　在类中利用synchronized修饰的方法或者this代码块，均使用的是类的实例锁或者类的锁。这些锁都称为内置锁。 　可以利用显式锁进行协调对象的访问。即ReentrantLock。这是一种可以提供无条件，可...
Java锁机制Lock用法示例
08-27
主要介绍了Java锁机制Lock用法,结合具体实例形式分析了Java锁机制的相关上锁、释放锁、隐式锁、显式锁等概念与使用技巧,需要的朋友可以参考下
显式锁和AQS(一)
wangxiang the blog
03-15 191
1.显式锁介绍 java中有显示锁与隐藏锁:显示锁是可以有JavaApi来控制的锁属于(Api级别),隐藏锁属于java内置语法比如Synchronized同步锁,隐藏的获取锁跟释放锁如果现在我想拿到Synchronized正在等待的线程是拿不到的我不知道内部的状态,这个锁就是隐藏锁属于(JVM级别) 显示锁的用法: lock():获取锁 **lockInterruptibly()😗*当有两个线程同时获取锁时,会有一个线程拿不到锁直接把这个拿不到锁的线程停止运行 tryLock():尝试获取锁获取到了返回.
Java 显式锁
云原生Java Web领域技术博客
03-24 152
显式锁并不是一种替代内置加锁的方式，而是当内置加锁机制不适用时，作为一种可选择的高级功能。
显式锁基础知识
weixin_51699336的博客
04-25 110
ObjectMonitor 锁类型 1.可重入锁 同一个线程多次获取同一把锁 2.公平锁 多个线程按照申请锁的顺序去获得锁 线程会直接进入队列去排队 永远都是队列的第一位才能得到锁 排队不插队 优点 所有的线程都能得到资源，不会饿死在队列中 缺点 吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大 源码 3.非公平锁 多个线程申请锁时，直接尝试获取锁，获取不到进入队列去排队 优点 减少CPU唤醒线程的开销，整体的吞吐效率会高点，减少CPU
JAVA显式锁,各种锁分类
康雨城
02-22 509
显示锁优势 使用Java内置锁时，不需要通过Java代码显式地对同步对象的监视器进行抢占和释放，这些工作由JVM底层完成，而且任何一个Java对象都能作为一个内置锁使用，所以Java的对象锁使用起来非常方便。但是，Java内置锁的功能相对单一，不具备一些比较高级的锁功能.Lock提供的接口方法可以看出，显式锁至少比Java内置锁多了一些功能
Java中的内置锁和显式锁
想作会飞的鱼的博客
05-21 3004
Java中的内置锁和显式锁 一、java的内置锁synchronized 每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。 java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程
内置锁和显式锁的区别--JCIP C13读书笔记
coolxing
04-11 221
[本文是我对Java Concurrency In Practice C13的归纳和总结.  转载请注明作者和出处,  如有谬误, 欢迎在评论中指正. ] 任何java对象都可以用作同步的锁, 为了便于区分, 将其称为内置锁. JDK5.0引入了显式锁: Lock及其子类(如ReentrantLock, ReadWriteLock等).  内置锁和显式锁的区别有:   1. 可中断申...
隐式(Synchronized)锁和显式(java.util.Lock)锁
zbuger的博客
03-08 1117
隐式(Synchronized)锁和显式(java.util.Lock)锁 为了控制多个线程按照正确的顺序来访问共享数据,Java提供了提供了两种锁方案 1.隐式锁(Synchronized)   这一种就是比较大家熟悉的synchronized关键字,因为Java中每个对象都实现了lock的功能,所以synchronized正是利用了这一特性,来控制并发访问.使用synchroni
Java高级上锁机制：显式锁 ReentrantLock
weixin_34362991的博客
11-17 106
Java 5.0 加入了新的上锁工作：ReentrantLock，它和同步(Synchronized)方法的内置锁不同，这是一种显式锁。显式锁作为一种高级的上锁工作， 是同步方法的一种补充和扩展，用来实现同步代码块无法完成的功能。 1 Lock和ReentrantLock Lock作为显式锁，其提供了一种无...
java 显式锁_JAVA显式锁简介
weixin_29419279的博客
03-05 116
在java中，协调对共享对象的访问时可以使用的机制包括synchronized,volatile以及java5.0之后新增的ReentrantLock机制。需要注意的是，ReentrantLock不是替代内置锁的方法，而是当内置锁不适用时作为可选择的高级功能。Lock提供了一种无条件的，可轮询的，定时的以及可中断的锁获取操作。Lock的实现中必须提供与内部所相同的内存可见性语义。Reentrant...
实现Java显式锁解析
lilei的博客
07-20 158
导读: 本文分为三部分: 实现lock锁部分 用到的线程工具类 测试代码与结果展示 实现代码如下: public class SelfLock implements Lock { // state 表示获取到锁 state = 1 获取到了锁 state = 0 表示锁当前没有被拿到 // 定义内部类继承AQS 实现独占式进程方法 private static clas...
java中的锁
最新发布
05-24
Java 提供了两种类型的锁：内置锁和显式锁。 1. 内置锁 内置锁是 Java 对象提供的一种锁机制，也称为监视器锁。每个 Java 对象都有一个内置锁，可以使用 synchronized 关键字来获取该锁。当一个线程获得了某个对象...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值