Java Lock锁

已于 2022-03-02 14:58:41 修改
阅读量1.9k 收藏 9
点赞数 4
分类专栏： # Java 线程系列 文章标签： java 显示锁 Lock ReentrantLock ReadWriteLock
于 2022-02-20 21:22:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_14876133/article/details/123036246
版权

文章目录

Java Lock锁

概述

synchronized被称为隐式锁，会自动获取释放锁，是非公平锁；Lock被称为显示锁，需要显示的手动获取释放锁，可以设置是否为公平锁。

Lock与synchronized一样可以实现线程同步，但比synchronized更强大，粒度更小，更灵活。

  • lock()获取锁。
  • unlock()释放锁。

ReentrantLock

显示锁的基本使用。

Lock#lock()

public class Demo {
    public static void main(String[] args) {
        Task task = new Task();
        new Thread(task).start();
        new Thread(task).start();
    }
}

class Task implements Runnable {
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        lock.lock();
        try {
            Thread.sleep(3000L);
            System.out.println(Thread.currentThread().getName() + " hello world");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

Lock#tryLock()

非阻塞式获取锁。

  • lock()是阻塞锁。
  • tryLock()是非阻塞锁，当锁被占用时，可以执行其他任务；tryLock()支持超时时间，在指定时间内可以获取锁返回true，否则返回false。
public class Demo {
    public static void main(String[] args) {
        Task task = new Task();
        new Thread(task).start();
        new Thread(task).start();
    }
}

class Task implements Runnable {
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        if (lock.tryLock()) {
            try {
                Thread.sleep(3000L);
                System.out.println(Thread.currentThread().getName() + ": hello world");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        } else {
            System.out.println(Thread.currentThread().getName() + ": 锁被占用，执行其他任务！");
        }
    }
}

Lock#lockInterruptibly()

不可中断等待锁的线程：

public class Demo {
    public static void main(String[] args) {
        Task task = new Task();
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //中断线程
        t2.interrupt();
    }
} 

class Task implements Runnable {
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        lock.lock();
        try {
            Thread.sleep(3000L);
            System.out.println(Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

输出：

java.lang.InterruptedException: sleep interrupted
	at java.base/java.lang.Thread.sleep(Native Method)
	at com.example.lib_java.Task.run(Demo.java:35)
	at java.base/java.lang.Thread.run(Thread.java:834)
Thread-0

可中断等待锁的线程：

public class Demo {
    public static void main(String[] args) {
        Task task = new Task();
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //中断线程
        t2.interrupt();
    }
}

class Task implements Runnable {
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            lock.lockInterruptibly();
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName() + "被中断");
            return;
        }
        try {
            Thread.sleep(3000L);
            System.out.println(Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

输出：

Thread-1被中断
Thread-0

await() & signal() & signalAll()

Condition的用法基本与synchronized的等待唤醒基本一致。

synchronizedCondition
wait()await()
wait(long timeout)await(long time, TimeUnit unit)
notify()signal()
notifyAll()signalAll()

await() 使用：

public class Demo {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        Task task = new Task(lock, condition);
        new Thread(task).start();
    }
}

class Task implements Runnable {
    private Lock lock;
    private Condition condition;

    public Task(Lock lock, Condition condition) {
        this.lock = lock;
        this.condition = condition;
    }

    @Override
    public void run() {
        lock.lock();
        try {
            //等待
            condition.await();
            System.out.println("hello world");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

说明：线程处于等待阶段，“hello world”一直没有输出。

await() & signal() 使用：

public class Demo {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        Task task = new Task(lock, condition);
        new Thread(task).start();
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.lock();
        //唤醒
        condition.signal();
        lock.unlock();
    }
}

class Task implements Runnable {
    private Lock lock;
    private Condition condition;

    public Task(Lock lock, Condition condition) {
        this.lock = lock;
        this.condition = condition;
    }

    @Override
    public void run() {
        lock.lock();
        try {
            //等待
            condition.await();
            System.out.println("hello world");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

说明：线程进入等待阶段，1秒后被唤醒，“hello world”被输出。

await() & signalAll() 使用：

public class Demo {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        Task task = new Task(lock, condition);
        new Thread(task).start();
        new Thread(task).start();
        new Thread(task).start();
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.lock();
        //唤醒所有等待
        condition.signalAll();
        lock.unlock();
    }
}

class Task implements Runnable {
    private Lock lock;
    private Condition condition;

    public Task(Lock lock, Condition condition) {
        this.lock = lock;
        this.condition = condition;
    }

    @Override
    public void run() {
        lock.lock();
        try {
            condition.await();
            System.out.println("hello world");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

说明：1秒后，三个线程都被唤醒，输出了3个“hello world”。

读写锁（ReadWriteLock）

  • 读锁：也称为共享锁，线程共享的，用于读取操作的同步锁，锁对象是ReentrantReadWriteLock.ReadLock。
  • 写锁：也称为独占锁，线程独占的，用于读取操作的同步锁，锁对象是ReentrantReadWriteLock.WriterLock。

论证读锁是共享锁

public class Demo {
    public static void main(String[] args) {
        Task task = new Task();
        Thread t1 = new Thread(task, "线程一");
        Thread t2 = new Thread(task, "线程二");
        Thread t3 = new Thread(task, "线程三");
        t1.start();
        t2.start();
        t3.start();
    }
}

class Task implements Runnable {
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
    private Lock readLock = readWriteLock.readLock();

    @Override
    public void run() {
        readLock.lock();
        try {
            Thread.sleep(3000L);
            System.out.println(Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readLock.unlock();
        }
    }
}

说明：同时输出三条内容，说明三个线程同时拿到锁，所以读锁是共享的。

论证写锁是独占的

public class Demo {
    public static void main(String[] args) {
        Task task = new Task();
        Thread t1 = new Thread(task, "线程一");
        Thread t2 = new Thread(task, "线程二");
        Thread t3 = new Thread(task, "线程三");
        t1.start();
        t2.start();
        t3.start();
    }
}

class Task implements Runnable {
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
    private Lock writeLock = readWriteLock.writeLock();

    @Override
    public void run() {
        writeLock.lock();
        try {
            Thread.sleep(3000L);
            System.out.println(Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            writeLock.unlock();
        }
    }
}

说明：依次输出三个线程的信息，说明三个线程是依次获取锁，所以写锁是独占的。

使用读写锁实现高并发容器

public class Demo {
    public static void main(String[] args) {
        //数据存储容器
        RWDictionary dictionary = new RWDictionary();
        //写任务
        WriteTask writeTask = new WriteTask(dictionary);
        //读任务
        ReadTask readTask = new ReadTask(dictionary);

        Thread write1 = new Thread(writeTask, "写入线程一");
        Thread write2 = new Thread(writeTask, "写入线程二");
        Thread write3 = new Thread(writeTask, "写入线程三");
        Thread read1 = new Thread(readTask, "读取线程一");
        Thread read2 = new Thread(readTask, "读取线程二");
        Thread read3 = new Thread(readTask, "读取线程三");
        write1.start();
        write2.start();
        write3.start();
        read1.start();
        read2.start();
        read3.start();
    }
}

/**
 * 写任务
 */
class WriteTask implements Runnable {
    private RWDictionary dictionary;

    public WriteTask(RWDictionary dictionary) {
        this.dictionary = dictionary;
    }

    @Override
    public void run() {
        int i = 0;
        while (true) {
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String name = Thread.currentThread().getName();
            dictionary.put("hello", name + "---" + i++);
        }
    }
}

/**
 * 读任务
 */
class ReadTask implements Runnable {
    private RWDictionary dictionary;

    public ReadTask(RWDictionary dictionary) {
        this.dictionary = dictionary;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String[] keys = dictionary.allKeys();
            for (String key : keys) {
                Object value = dictionary.get(key);
                System.out.println(key + ":" + value);
            }
        }
    }
}

/**
 * 数据管理容器
 */
class RWDictionary {
    //存储数据
    private final HashMap<String, Object> map = new HashMap<>();
    //读写锁
    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
    //读锁
    private final Lock r = readWriteLock.readLock();
    //写锁
    private final Lock w = readWriteLock.writeLock();

    /**
     * 获取数据
     */
    public Object get(String key) {
        r.lock();
        try {
            return map.get(key);
        } finally {
            r.unlock();
        }
    }

    /**
     * 获取所有键
     */
    public String[] allKeys() {
        r.lock();
        try {
            return map.keySet().toArray(new String[0]);
        } finally {
            r.unlock();
        }
    }

    /**
     * 写入数据
     */
    public Object put(String key, Object value) {
        w.lock();
        try {
            return map.put(key, value);
        } finally {
            w.unlock();
        }
    }

    /**
     * 清理所有数据
     */
    public void clear() {
        w.lock();
        try {
            map.clear();
        } finally {
            w.unlock();
        }
    }
}

输出：

hello:写入线程一---193
hello:写入线程一---193
hello:写入线程一---193
hello:写入线程二---194
hello:写入线程二---194
hello:写入线程二---194
hello:写入线程一---195
hello:写入线程一---195
hello:写入线程一---195
hello:写入线程一---196
hello:写入线程一---196
hello:写入线程一---196
xiangxiongfly915
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-Lock锁
u014230945的博客
01-10 2293
1、JDK1.5以后，Java提供了Lock同步锁，相对与需要JVM隐士获取和释放锁Synchronized 同步锁，Lock同步锁需要显示获取和释放锁，这就为获取和释放锁提供了更多的灵活性。 2、Lock锁的基本操作通过乐观锁来实现，但是由于Lock锁也会在阻塞的时候被挂起，因此它依然属于悲观锁。 对比Synchronized和Lock如下图 Synchronized Lock 实现方式 ...
Java锁
m0_38061188的博客
03-03 90
1. 公平锁非公平锁 比较 非公平锁比公平锁性能高5-10倍，因为公平锁需要在多核情况下维护一个队列，如果当前线程不是队列的第一个无法获取锁，增加了线程切换次数。 应用 在Java中ReentrantLock,ReentrantReadWriteLock和Semaphore可设置成公平锁。 2. 可重入锁 ReentrantLock，ReentrantReadWriteLock，synchro...
Java中的Lock详解
热门推荐
向上的"狼"的博客
04-28 2万+
简介 java.util.concurrent.locks.Lock 是一个类似于synchronized 块的线程同步机制。但是 Lock比 synchronized 块更加灵活。Lock是个接口，有个实现类是ReentrantLock。 Lock和syncronized的区别
Java中Lock锁详解
mercedes_benz
07-08 6643
在Java中，Lock是一个接口，它提供了比关键字更高级的线程同步机制。使用Lock接口可以创建更复杂和灵活的同步结构。Lock接口的常用实现类有ReentrantLock和ReentrantReadWriteLock，它们提供了可重入的互斥锁和读写锁。使用Lock锁的一般步骤如下：1. 创建一个`Lock`对象实例。2. 在需要进行同步的代码块中，通过调用`lock()`方法来获取锁。3. 在同步的代码块执行完之后，通过调用`unlock()`方法释放锁。
java中的Lock锁
纯洁的小魔鬼
07-15 1万+
一. 概述 Lock 是 java.util.concurrent.locks 包 下的接口，Lock 实现提供了比 synchronized 关键字 更广泛的锁操作，它能以更优雅的方式处理线程同步问题。Lock提供了比synchronized更多的功能。 1.Lock和ReadWriteLock是两大锁的根接口，Lock代表实现类是ReentrantLock（可重入锁），ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock。 　2.Lock 接口支...
Java多线程之Lock使用深入理解
tian830937的专栏
03-19 2001
Lock锁的使用
Java并发之 Lock 锁
Qynwang的博客
06-13 2397
锁是一种工具，用于控制对共享资源的访问Lock和synchronized是最常见的两个锁，他们都能够达到线程安全的目录，但是使用和功能上又有较大的不同Lock接口最常见的实现类就是通常情况下Lock只允许一个线程访问共享资源，特殊情况也允许多个线程并发访问，如ReadWriteLock的ReadLock悲观锁认为：如果我不锁住这个资源，别人就会来争抢，就会造成数据结果错误，所以为了结果的正确性，悲观锁会在每次获取并修改结果时把数据锁住，让别人无法访问。
Java Lock锁多线程中实现流水线任务
08-19
"Java Lock锁多线程中实现流水线任务" Java Lock锁多线程中实现流水线任务是Java多线程编程中非常重要的一个主题。在多线程编程中，如何保证线程安全和避免死锁是两个主要的问题。Java提供了多种方式来解决这些问题...
Java lock同步锁使用实例解析
08-25
Java lock同步锁使用实例解析 Java lock同步锁是Java并发编程中的一种常见同步锁机制，主要用于解决多线程并发访问共享资源时的同步问题。在Java中，Lock是一个接口，而synchronized是Java中的关键字，两者都可以...
Java锁机制Lock用法示例
08-27
Java锁机制Lock用法示例 Java锁机制Lock是Java并发编程中的一种同步机制，用于解决多线程安全问题。Lock机制是Java 1.5以后引入的显示锁机制，相比于传统的synchronized隐式锁机制，Lock机制提供了更灵活和高效的...
Java多线程中Lock锁的使用总结
08-18
Java多线程中Lock锁的使用总结 Java多线程中Lock锁的使用总结主要介绍了Java多线程中Lock锁的使用总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值。 知识点1: Java多线程中的...
lock锁，lock锁和synchronized的对比
11-19
lock锁，lock锁和synchronized的对比 # Lock锁 JDK5.0后Java提供了一种更加强大的线程同步机制。一种显式定义同步锁对象来实现锁，提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问...
java多线程进阶（四）LOCK锁及其原理
jiayibingdong的博客
05-21 2249
Java中Lock的底层原理
qq_34949319的博客
12-13 1247
通过ReentrantLock源码来学习java lock加锁过程
【学习笔记】Java中的锁Lock
zuzhiang的博客
08-28 1908
本文参考自：Java并发编程：Lock。 Lock锁并不是java内置的功能，其应用场景是在多线程并发访问时，为了避免冲突，需要每个线程先获取锁，避免其他线程的进入，等线程执行完后释放锁，允许其他线程进入。 1. Lock锁与synchronized同步的区别 Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现； synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLo
Java 中的Lock锁
学习笔记
05-26 1万+
Lock锁，可以得到和synchronized一样的效果，即实现原子性、有序性和可见性。 相较于synchronized，Lock锁可手动获取锁和释放锁、可中断的获取锁、超时获取锁。 Lock是一个接口，两个直接实现类：ReentrantLock（重入锁）, ReentrantReadWriteLock（读写锁）。 1.概述 Lock锁，使用时手动获取锁和释放锁，比synchro...
Java多线程-简单使用Lock(锁)
见证自己学习,成长的记录
09-07 3712
lock是JUC(并发)下的一个接口,一般用它的实现类ReentrantLock(可重入锁)比较多。加锁:lock(),解锁:unLock(),一般放在try catch finally中使用。Lock锁>同步代码块(已经进入了方法体,分配了相应资源)>同步方法(在方法体外)
配置系统PATH环境变量
最新发布
weixin_44626980的博客
06-29 604
PATH环境变量在操作系统中起着非常重要的作用，特别是在命令行或脚本中执行程序时，系统会根据PATH环境变量中定义的路径查找可执行文件。当用户在命令行或脚本中输入一个命令时，系统会根据PATH环境变量中定义的路径依次查找对应的可执行文件，如果找到则执行。本文详细介绍了如何配置系统的PATH环境变量，包括在Windows和Linux系统中的操作步骤。在Linux系统中，可以通过编辑shell配置文件来配置PATH环境变量，常用的shell配置文件包括.bashrc、.bash_profile等。
一文带你看懂Java中的Lock锁底层AQS到底是如何实现的.doc
07-08
一文带你看懂Java中的Lock锁底层AQS到底是如何实现的.doc

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值