多线程-Lock的使用

已于 2022-07-13 22:48:02 修改
阅读量522 收藏 2
点赞数
分类专栏： 多线程 文章标签： java
于 2022-07-13 22:44:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51604685/article/details/125774354
版权

1，使用ReentrantLock类

​ 在java中，可以使用synchronized关键字可以实现线程之间同步互斥，在jdk1.5中新增了ReentrantLock类也能够达到同样的效果，并且在扩展功能上面也更加强大，比如具有嗅探锁定、多路分支通知等功能，而且在使用上也比synchronized更加灵活。

使用ReentrantLock来实现线程同步

示例：创建一个共享对象MyService，将这个对象也是使用lock来锁住，只有拿到这个对象的线程才能够来操作这个资源中的代码，记住，lock是不会自己释放锁的，因此在代码执行完成以后是需要手动释放锁的。

class MyService{
    private Lock lock = new ReentrantLock();

    public void testMethod(){
        //获得锁
        lock.lock();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() +"==>"+ (i));
        }
        //释放锁
        lock.unlock();
    }
}

class MyThread extends Thread{
    private MyService myService;
    public MyThread(MyService myService){
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.testMethod();
    }
}
public class Test1 {
    public static void main(String[] args) {
        MyService myService = new MyService();
        new MyThread(myService).start();
        new MyThread(myService).start();
        new MyThread(myService).start();
        new MyThread(myService).start();
        new MyThread(myService).start();
    }
}

2,使用Condition实现等待/通知

​ 当一个线程获取到锁了以后就可以执行同步代码块中的代码了，当这个线程执行完成以后会释放锁，这个时候主线程会休眠3秒钟，然后也会来执行同步代码块中的方法。

Object类Condition类
wait()await()
wait(long timeout)await(long timeout,TimeUnit unit)
notify()signal()
notifyAll()signalAll()
class MyService1{
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    public void await(){
        try{
            lock.lock();
            System.out.println("await时间为 " + System.currentTimeMillis());
            condition.await();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void signal(){
        try {
            lock.lock();
            System.out.println("signal时间为 " + System.currentTimeMillis());
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}

class ThreadA extends Thread{
    private MyService1 myService1;
    public ThreadA(MyService1 myService1){
        this.myService1 = myService1;
    }

    @Override
    public void run() {
        myService1.await();
    }
}
public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        MyService1 myService1 = new MyService1();
        new ThreadA(myService1).start();
        Thread.sleep(3000);
        myService1.signal();
    }
}

3,生产者/消费者模式

实现一对一交替打印

class MyService3{
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private boolean hasValue = false;

    public void set(){
        try {
            lock.lock();
            while (hasValue){
                condition.await();
            }
            System.out.println("现在正在设置值");
            hasValue = true;
            condition.signal();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void get(){
        try {
            lock.lock();
            while (!hasValue){
                condition.await();
            }
            System.out.println("现在正在获取值");
            hasValue = false;
            condition.signal();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

class MyThreadA extends Thread{
    private MyService3 myService3;
    public MyThreadA(MyService3 myService3){
        this.myService3 = myService3;
    }

    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            myService3.set();
        }
    }
}

class MyThreadB extends Thread{
    private MyService3 myService3;
    public MyThreadB(MyService3 myService3){
        this.myService3 = myService3;
    }

    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            myService3.get();
        }
    }
}


public class Test3 {
    public static void main(String[] args) {
        MyService3 myService3 = new MyService3();
        new MyThreadA(myService3).start();
        new MyThreadB(myService3).start();
    }
}

4,公平锁与非公平锁

​ 公平与非公平锁：锁Lock分为“公平锁”和“非公平锁”，公平锁表示线程获取锁的顺序按照线程加锁的顺序来分配的（即先来先得的FIFO先进先出顺序），而非公平锁就是一种锁的抢占机制，是随机获得锁的，这种方式可能造成某些线程一直拿不到锁。

公平锁的实现：

class MyService4{
    private ReentrantLock lock;

    public MyService4(boolean isFair){
        lock = new ReentrantLock(isFair);
    }

    public void serviceMethod(){
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "获得到锁");
        }finally {
            lock.unlock();
        }
    }
}
public class Test4 {
    public static void main(String[] args) {
        final MyService4 service4 = new MyService4(true);
        Runnable runnable = () -> {
            System.out.println(Thread.currentThread().getName()+"运行了");
            service4.serviceMethod();
        };
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(runnable);
        }
        for (int i = 0; i < 10; i++) {
            threads[i].start();
        }
    }
}

非公平锁：表示先启动的线程不一定先获取到锁。

class MyService4{
    private ReentrantLock lock;

    public MyService4(boolean isFair){
        lock = new ReentrantLock(isFair);
    }

    public void serviceMethod(){
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "获得到锁");
        }finally {
            lock.unlock();
        }
    }
}
public class Test4 {
    public static void main(String[] args) {
        final MyService4 service4 = new MyService4(false);
        Runnable runnable = () -> {
            System.out.println(Thread.currentThread().getName()+"运行了");
            service4.serviceMethod();
        };
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(runnable);
        }
        for (int i = 0; i < 10; i++) {
            threads[i].start();
        }
    }
}

5，synchronized和ReentrantLock的区别

两者的共同点：

  1. 都是用来协调多线程对共享对象、变量的访问
  2. 都是可重入锁，同一线程可以多次获得同一个锁
  3. 都保证了可见性和互斥性

两者的不同点：

  1. ReentrantLock显示获得释放锁；synchronized隐式获得释放锁
  2. ReentrantLock可相应中断，可轮回；synchronized是不可以相应中断的
  3. ReentrantLock是API级别的；synchronized是JVM级别的
  4. ReentrantLock可以实现公平锁（默认是非公平锁）；synchronized只能是非公平锁
  5. ReentrantLock是同步非阻塞，采用乐观并发策略；synchronized是同步阻塞，采用悲观并发策略
  6. ReentrantLock是一个接口；synchronized时java关键字
  7. ReentrantLoc在发生异常的时候不会自动释放锁；synchronized在发生异常的时候会自动释放锁
  8. ReentrantLock可以响应中断；synchronized不能响应中断，只能一直等待直到执行结束
  9. ReentrantLock无法知道是否成功获取到锁；synchronized可以知道是否成功获取到锁
  10. ReentrantLock通过读写锁提高效率；synchronized在任何情况下都只有一个线程可以访问这个资源

6，使用ReentrantReadWriteLock类

​ 类ReentrantLock具有完全互斥排他的效果，即同一时间只有一个线程在执行ReentrantLock.lock()方法后后面的任务，这样可以保证线程的安全，但是这样的效率是特别低的。因此引进ReentrantReadWriteLock类，该类使用了读写锁（读锁也叫共享锁，写锁也叫排他锁），读锁之间是不互斥的，读锁和写锁之间是互斥的，写锁和写锁之间是互斥的，也就说同一时刻可以有多个线程获取到读锁来读取数据。

读锁之间的共享：同一时刻多个线程都是可以获取到这一把读锁的。

class MyService5{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void read(){
        try {
            try {
                lock.readLock().lock();
                System.out.println(Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "获取到读锁");
                Thread.sleep(10000);
            }finally {
                lock.readLock().unlock();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

class ThreadC extends Thread{
    private MyService5 myService5;

    public ThreadC(MyService5 myService5){
        this.myService5 = myService5;
    }

    @Override
    public void run() {
        myService5.read();
    }
}

class ThreadD extends Thread{
    private MyService5 myService5;

    public ThreadD(MyService5 myService5){
        this.myService5 = myService5;
    }

    @Override
    public void run() {
        myService5.read();
    }
}


public class Test5 {
    public static void main(String[] args) {
        MyService5 myService5 = new MyService5();
        ThreadC threadC = new ThreadC(myService5);
        threadC.setName("C");
        ThreadD threadD = new ThreadD(myService5);
        threadD.setName("D");
        threadC.start();
        threadD.start();
    }
}

读锁和写锁之间的互斥：同一时刻只有一个线程都是可以获取到这一把写锁的，在这个时候读的时候就不能写，写的时候就不能读

class MyService5{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void read(){
        try {
            try {
                lock.readLock().lock();
                System.out.println(Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "获取到读锁");
                Thread.sleep(10000);
            }finally {
                lock.readLock().unlock();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    public void write(){
        try {
            try {
                lock.writeLock().lock();
                System.out.println(Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "获取到写锁");
                Thread.sleep(10000);
            }finally {
                lock.writeLock().unlock();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

class ThreadC extends Thread{
    private MyService5 myService5;

    public ThreadC(MyService5 myService5){
        this.myService5 = myService5;
    }

    @Override
    public void run() {
        myService5.read();
    }
}

class ThreadD extends Thread{
    private MyService5 myService5;

    public ThreadD(MyService5 myService5){
        this.myService5 = myService5;
    }

    @Override
    public void run() {
        myService5.write();
    }
}


public class Test5 {
    public static void main(String[] args) throws InterruptedException {
        MyService5 myService5 = new MyService5();
        ThreadC threadC = new ThreadC(myService5);
        threadC.setName("C");
        threadC.start();
        Thread.sleep(1000);
        ThreadD threadD = new ThreadD(myService5);
        threadD.setName("D");
        threadD.start();
    }
}

写锁之间的互斥：同一时刻只有一个线程都是可以获取到这一把写锁的。

class MyService5{
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void write(){
        try {
            try {
                lock.writeLock().lock();
                System.out.println(Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "获取到写锁");
                Thread.sleep(10000);
            }finally {
                lock.writeLock().unlock();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

class ThreadC extends Thread{
    private MyService5 myService5;

    public ThreadC(MyService5 myService5){
        this.myService5 = myService5;
    }

    @Override
    public void run() {
        myService5.read();
    }
}

class ThreadD extends Thread{
    private MyService5 myService5;

    public ThreadD(MyService5 myService5){
        this.myService5 = myService5;
    }

    @Override
    public void run() {
        myService5.read();
    }
}


public class Test5 {
    public static void main(String[] args) {
        MyService5 myService5 = new MyService5();
        ThreadC threadC = new ThreadC(myService5);
        threadC.setName("C");
        ThreadD threadD = new ThreadD(myService5);
        threadD.setName("D");
        threadC.start();
        threadD.start();
    }
}
拾忆最初的理想
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程之lock详解
qq_39497281的博客
08-16 1190
多线程锁的使用，包括lock和ReadWriteLock
描述C#多线程中lock关键字的使用分析
12-25
本文介绍C# lock关键字，C#提供了一个关键字lock，它可以把一段代码定义为互斥段（critical section），互斥段在一个时刻内只允许一个线程进入执行，而其他线程必须等待。每个线程都有自己的资源，但是代码区是共享...
Java多线程基础——Lock类
08-31
Lock类是Java类来提供的功能，丰富的api使得Lock类的同步功能比synchronized的同步更强大。本文对此进行详细介绍，下面跟着小编一起来看下吧
Lock锁以及线程
qq_44872329的博客
08-25 194
Lock（接口）： void lock() 获得锁，加锁 void unlock() 释放锁 子类： ReentrantLock 这是解决线程同步安全的第二种方式 class SellTick1 implements Runnable{ //定义票的个数 private int tickets = 100; //定义锁对象 private Lock lock = new ReentrantLock(); @Override public void ru
C# Lock 解读
热门推荐
vincent_zhanglb的专栏
01-01 2万+
最近在研究.NET分布式缓存代码，正好涉及Lock，看了网上的文章，总结了一些Lock相关的知识，供大家一起学习参考。  一、Lock定义     lock 关键字可以用来确保代码块完成运行，而不会被其他线程中断。它可以把一段代码定义为互斥段（critical section），互斥段在一个时刻内只允许一个线程进入执行，而其他线程必须等待。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。
Java多线程之Lock使用深入理解
tian830937的专栏
03-19 1696
Lock锁的使用
Java多线程中Lock锁的使用总结
08-18
主要介绍了Java多线程中Lock锁的使用总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
c#多线程中Lock()关键字的用法小结
09-04
本篇文章主要是对c#多线程中Lock()关键字的用法进行了详细的总结介绍，需要的朋友可以过来参考下，希望对大家有所帮助
随缘笔记——一个线程不能释放另一个线程的ReentrantLock锁
Judy_zzd的博客
11-23 828
ReentrantLock可重入锁 大概解析一下ReentrantLock可重入锁，具体的描述网上很多大神有更加详细切专业的解答。 可重入锁即你可以对一个线程加10（最大是2147483647，int的最大值）把锁，但是你在释放锁的时候同样也要释放这10把锁。 发现问题 在学习ReentrantLock时写一段这样的代码： public class Reentrant_Demo { static Lock lock = new ReentrantLock(); public static
线程中释放锁的方式
菜鸟的逆袭
11-20 5319
# 调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) {...} 代码段内。 # 调用obj.wait()后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized(obj) {...} 代码段内唤醒A。 # 当obj.wait()方法返回后，线程A需要再次获得obj锁，才能继续执行
java 多线程&出现异常，锁自动释放——28
爱的叹息的专栏
06-07 673
当一个线程执行的代码出现异常时，其所持有的锁会自动释放。 线程a出现异常并释放锁，线程b进入方法正常输出。本示 例说明，当出现异常时，锁可以自动释放。 要注意，类Thread.java中的suspend()方法和sleep（millis）方法被调用后并不释放锁。...
Java多线程中Lock的使用
crg18438610577的博客
04-27 869
Java多线程中Lock的使用
java多线程学习之——多线程中几种释放锁和不释放锁的操作
Mus_Li的博客
08-12 2202
在学习java多线程这一块知识的时候，遇到了很多个关于线程锁什么时候释放的问题，现总结几种释放锁和不释放锁的操作如下
pthread_cancel 线程取消以及锁的释放
weixin_34313182的博客
09-24 234
2019独角兽企业重金招聘Python工程师标准>>> ...
多线程安全中的Lock锁使用
weixin_57228276的博客
09-08 162
在多线程共享数据中，必须要进行加锁操作如果不进行加锁就会出现数据错误。那么Lock锁就可以很方便的让我们看出，在哪里加了锁，在哪里释放锁。
多线程-锁（Lock）
Artisan_w
06-09 306
锁的分类 1，公平锁/非公平锁 公平锁是指线程按照申请顺序获得锁。如果休眠队列上有线程了，那新进入的竞争线程一定要在休眠队列上排队。 非公平锁是指线程能够无视休眠队列，直接竞争锁，使后申请的线程可能先占有锁。可能会导致优先级反转或者饥饿现象。非公平锁的优点在于吞吐量比公平锁大。 对于Java ReetrantLock而言，通过构造函数指定该锁是公平锁，默认是非公平锁。 2，可重入锁 又名递归锁。是指在同一个线程在外层方法获取锁的时候，进入内层会自动获取锁，sychronized和Java ReetrantL
多线程-Lock锁
weixin_46751741的博客
02-20 251
synchronized和Lock锁的区别 Lock是显示锁（手动开启和关闭锁，必须关闭锁）, synchronized是隐式锁，出了作用域自动释放. Lock锁只有代码块锁，synchronized有代码块锁和方法锁 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩充性（提供更多主类） 优先使用顺序： Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外） Lock（锁） 从JDK 5.0开始，Java提供了强大的线程
c#-多线程中lock用法的经典实例
你要明白，任何问题都不是孤立存在的，一定有人曾经遇到过，并且已经有更好的解决办法了，只是我还不知道。我不应该在黑暗中独自前行，去重新发明轮子，也许我的顿悟，只是别人的基本功！我应该要站在巨人的肩膀上，学习更成熟的经验和方法，然后再来解决这个问题
03-14 1601
一、Lock定义 lock 关键字可以用来确保代码块完成运行，而不会被其他线程中断。它可以把一段代码定义为互斥段（critical section），互斥段在一个时刻内只允许一个线程进入执行，而其他线程必须等待。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。 在多线程中，每个线程都有自己的资源，但是代码区是共享的，即每个线程都可以执行相同的函数。这可能带来的问题就是几...
C#学习相关系列之多线程---lock线程锁的用法
最新发布
qiaodahua的博客
10-31 3767
本文介绍了多线程中lock锁的相关用法，lock锁可以保证多线程中依次运行相关代码，保证数据安全
java多线程lock
10-10
在Java中，多线程的锁机制可以使用Lock接口来实现。Lock接口提供了比synchronized关键字更灵活的锁定机制，并且支持更多的功能。使用Lock接口可以实现更细粒度的同步控制。 下面是一个使用Lock接口实现的简单示例：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值