并发编程-锁

最新推荐文章于 2021-09-03 10:46:54 发布
最新推荐文章于 2021-09-03 10:46:54 发布
阅读量80 收藏
点赞数
分类专栏： java 并发编程 文章标签： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33932482/article/details/109219500
版权

锁

ReentrantLock

在Java多线程中，可以使用synchronized关键字来实现线程之间的同步互斥，但在JDK1.5中新增加ReentranLock类也可以达到同样的效果，并且在扩展功能上更加强大，比如具有嗅探锁定、多路分支通知等，而且在使用上也比synchronized更加灵活。从运行结果来看，当前线程打印完毕之后将锁进行释放，其它线程才可以继续 打印。线程打印的数组是分级打印，因为当前线程已经持有锁，但线程之间打印的顺序是随机的。调用lock方法的线程就会持有对象锁，其它的线程只能等待锁被释放(调用unlock方法)才可以再次争抢锁。效果和synchronized关键字一样，线程之间还是按照顺序执行

public class TestReentrantLock {
    private Lock lock;
    public TestReentrantLock(Lock lock) {
        this.lock = lock;
    }

    public  void printNumber() {
        try {
            lock.lock();
            for (int i = 0; i <= 6; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        TestReentrantLock reentrantLock = new TestReentrantLock(lock);
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                reentrantLock.printNumber();
            }).start();
        }
    }
}

ReentrantLock实现wait和notifty

ReentrantLock 实现了 Lock 接口，并提供了与synchronized 相同的互斥性和内存可见性，ReentrantLock也可以实现等待/通知模式的功能，但需要借助Condition对象。Condition类是在JDK5中出现的技术。synchronized就相当于整个Lock对象中只有一个单一Condition对象，所有的线程都是注册在它一个对象的身上。线程开始notifyAll时需要通知所有正在等待的线程，没有选择权，会出现相当大效率问题。

public class TestReentrantLock {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLockService service = new ReentrantLockService();
        Thread thread = new AwaitThread(service);
        thread.start();
        TimeUnit.SECONDS.sleep(3);
        service.signal();
    }
}
class ReentrantLockService {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void await() {
        lock.lock();
        System.out.println(Thread.currentThread().getName() + "begin await:" + System.currentTimeMillis());
        try {
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.unlock();
    }

    public void signal() {
        lock.lock();
        System.out.println(Thread.currentThread().getName() + "begin signal:" + System.currentTimeMillis());
        condition.signal();
        lock.unlock();
    }
}
class AwaitThread extends Thread {
    private ReentrantLockService service;
    public AwaitThread(ReentrantLockService service) {
        this.service = service;
    }
    @Override
    public void run() {
        service.await();
    }
}

Condition接口来实现多路通知

在一个Lock对象里面可以创建多个Condition实例（Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得Condition 实例，使用其 newCondition() 方法），线程对象可以注册在指定的Condition中，从而可以有选择性地进行线程通知，在调试线程上更加灵活。在使用notify/notifyAll方法进行通知时，被通知线程是由JVM随机选择的，但使用ReentrantLock结合Condition类可以实现选择性通知，这个功能是非常重要的，而且在Condition在中是默认提供的,单个Lock可能与多个Condition对象关联

public class TestMultiReentrantLock {

    public static void main(String[] args) throws InterruptedException {
        MultiReentrantLockService service = new MultiReentrantLockService();
        new Thread((service::await1)).start();
        new Thread((service::await2)).start();

        TimeUnit.SECONDS.sleep(5);
        service.signal();
    }
}

class MultiReentrantLockService {
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();//单个Lock可能与多个Condition对象关联
    private Condition condition2 = lock.newCondition();//单个Lock可能与多个Condition对象关联

    public void await1() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " begin await1...");
            condition1.await();
            System.out.println(Thread.currentThread().getName() + " signal await1...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }

    public void await2() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " begin await2...");
            condition2.await();
            System.out.println(Thread.currentThread().getName() + " signal await2...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }

    public void signal() {
        try {
            lock.lock();
            condition1.signalAll();
            System.out.println(Thread.currentThread().getName() + " begin signal...");
        } catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }
}

PS：
在 Condition 对象中，与 wait、notify 和 notifyAll 方法对应的分别是await、signal 和 signalAll

面试题：开启3个线程，这三个线程的Name分别为A、B、C，每个线程将自己的Name在屏幕上打印5遍

public class TestReentrantLock {

    public static void main(String[] args) {
        Print print = new Print();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                print.printA();
            }
        }, "A").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                print.printB();
            }
        }, "B").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                print.printC();
            }
        }, "C").start();

    }
}

class Print {
    private String flag = "A";
    final ReentrantLock lock = new ReentrantLock();
    final Condition conditionA = lock.newCondition();
    final Condition conditionB = lock.newCondition();
    final Condition conditionC = lock.newCondition();

    public void printA() {
        try {
            lock.lock();
            if (!"A".equals(flag)) {
                conditionA.await();
            }
            System.out.print(Thread.currentThread().getName());
            flag = "B";
            conditionB.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }

    public void printB() {
        try {
            lock.lock();
            if (!"B".equals(flag)) {
                conditionB.await();
            }
            System.out.print(Thread.currentThread().getName());
            flag = "C";
            conditionC.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }

    public void printC() {
        try {
            lock.lock();
            if (!"C".equals(flag)) {
                conditionC.await();
            }
            System.out.print(Thread.currentThread().getName());
            flag = "A";
            conditionA.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }
}

tryLock和TryLock(time, uint)

public class TestTryLock {

    public static void main(String[] args) {
        TryLockService tryLockService = new TryLockService();
        Thread A = new Thread(tryLockService::tryLock);
        A.setName("A");
        A.start();

        Thread B = new Thread(() -> tryLockService.tryLockTime(4L));
        B.setName("B");
        B.start();
    }
}

class TryLockService {
    final ReentrantLock lock = new ReentrantLock();
    public void tryLock() {
        System.out.println(Thread.currentThread().getName() + " start.....");
        if (lock.tryLock()) {
            System.out.println(Thread.currentThread().getName() + " 获取到锁！");
        }
        else {
            System.out.println(Thread.currentThread().getName() + " 未获取到锁！");
        }
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            System.out.println(Thread.currentThread().getName() + " 释放锁！！");
            lock.unlock();
        }
    }

    public void tryLockTime(Long time) {
        try {
            System.out.println(Thread.currentThread().getName() + " start.....");
            if (lock.tryLock(time, TimeUnit.SECONDS)) {
                System.out.println(Thread.currentThread().getName() + " 获取到锁！");
            }
            else {
                System.out.println(Thread.currentThread().getName() + " 未获取到锁！");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            System.out.println(Thread.currentThread().getName() + " 释放锁！！");
            lock.unlock();
        }
    }
}

公平锁和非公平锁

在java的锁机制中，公平和非公平的参考物是什么，简单的来说，如果一个线程组里，能保证每个线程都能拿到锁，那么这个锁就是公平锁。相反，如果保证不了每个线程都能拿到锁，也就是存在有线程饿死，那么这个锁就是非公平锁。
那如何能保证每个线程都能拿到锁呢，队列FIFO是一个完美的解决方案，也就是先进先出，java的ReenTrantLock也就是用队列实现的公平锁和非公平锁。在公平的锁中，如果有另一个线程持有锁或者有其他线程在等待队列中等待这个锁，那么新发出的请求的线程将被放入到队列中。而非公平锁上，只有当锁被某个线程持有时，新发出请求的线程才会被放入队列中（此时和公平锁是一样的）。所以，它们的差别在于非公平锁会有更多的机会去抢占锁。

public class TestReentrantLock {
    public static void main(String[] args) {
        TestReentrantLockService t1 = new TestReentrantLockService();
        for (int i = 0; i < 50; i++) {
            new Thread(t1).start();
        }
    }
}

class TestReentrantLockService extends Thread {
    final ReentrantLock lock = new ReentrantLock(true); //true公平锁，false非公平锁

    @Override
    public void run() {

        for (int i = 0; i < 50; i++) {
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + "获得锁:" + i);
            } catch (Exception e) {
                e.printStackTrace();
            }
            finally {
                lock.unlock();
            }
        }
    }
}

ReadWriteLock读写锁（写加锁，读不需要）

并发读写操作保证安全的常规解决办法是在读写操作上加入互斥锁，这种情况下并发读写效率会打折扣，因为大多数情况下我们对同一数据读操作的频率会高于写操作，而线程与线程间的并发读操作是不涉及并发安全问题的，所以没有必要给读操作加互斥锁，只要保证读写、写写并发操作上锁是互斥的就行。
ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的，ReadWriteLock 读取操作通常不会改变共享资源，但执行写入操作时，必须独占方式来获取锁。对于读取操作占多数的数据结构。 ReadWriteLock 能提供比独占锁更高的并发性。而对于只读的数据结构，其中包含的不变性可以完全不需要考虑加锁操作。
上面基本都废话，主要核心：
“读-读” 不互斥
“读-写” 互斥
“写-写” 互斥

public class TestReadWriteLock {
    public static void main(String[] args) {
        ReadWriteLockService service = new ReadWriteLockService();
        for (int i = 0; i < 20; i++) {
            char c = (char) ('A' + i);
            new Thread(() -> {
                service.read();
            }, "A").start();
            new Thread(() -> {
                service.write();
            }, "B").start();
        }

    }
}

class ReadWriteLockService {
    private String value = "";

    final ReadWriteLock lock = new ReentrantReadWriteLock();
    final Lock readLock = lock.readLock();
    final Lock writeLock = lock.writeLock();

    public void read() {
        try {
            readLock.lock();
            TimeUnit.SECONDS.sleep(1);
            System.out.println(Thread.currentThread().getName() + " read..." + value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            readLock.unlock();
        }
    }

    public void write() {
        try {
            writeLock.lock();
            TimeUnit.SECONDS.sleep(1);
            value = System.currentTimeMillis() + "";
            System.out.println(Thread.currentThread().getName() + " write..." + value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            writeLock.unlock();
        }
    }
}

LockSupport读写锁（写加锁，读不需要）

  1. LockSupport 不需要加锁就可以实现阻塞和唤醒
  2. 如果一个线程处理等待状态，连续调用了两次park方法。线程永远无法被唤醒
  3. unpark 和 park 方法不需要考虑调用先后顺序
public class TestLockSupport {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    if (i == 3) {
                        LockSupport.park();
                    }
                    System.out.println(i);
                    TimeUnit.MILLISECONDS.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A");
        thread.start();
        LockSupport.unpark(thread);
    }
}
sxz_永无止尽
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Lock
weixin_40055163的博客
09-14 109
Lock 1.1 ReentranLock 在Java多线程中，可以使用synchronized关键字来实现线程之间的同步互斥，但在JDK1.5中新增加ReentranLock类也可以达到同样的效果，并且在扩展功能上更加强大，比如具有嗅探锁定、多路分支通知等，而且在使用上也比synchronized更加灵活。 使用ReentranLock Java代码如下: @SuppressWarnings("all") // 注解警告信息 public class Demo01 { public s
悲观锁的实现方式java_并发编程--锁--悲观锁和乐观锁
weixin_30920223的博客
02-28 4951
悲观锁和乐观锁并不是某个具体的“锁”而是一种并发编程的基本概念，是根据看待并发同步的角度。乐观锁和悲观锁最早出现在数据库的设计当中，后来逐渐被 Java 的并发包所引入。悲观锁悲观锁认为对于同一个数据的并发操作一定是会发生修改的，采取加锁的形式，悲观地认为，不加锁的并发操作一定会出问题。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中...
深入理解ReentrantLock
u013322876的博客
07-31 215
http://www.cnblogs.com/zhimingyang/p/5702752.html
重入锁ReentrantLock用法以及如何实现重进入
weixin_30394669的博客
02-19 165
　　在java多线程中，可以使用synchronized实现线程之间的同步互斥，但在jdk1.5中增加了ReentrantLock类也能达到同样的效果，而且在使用上更加灵活，扩展功能上更加强大。 　　创建MyService.java类，代码如下： package com.lit.reentreantlock; import java.util.concurrent.locks.Loc...
ReentrantLock 在@Transactional事务注解内的Service方法失效
weixin_39360124的博客
09-03 537
业务场景如下: 在单体应用高并发场景, 全校所有学生开始选课, 选课大家都是抢着选择热门的选修课的, 所以会产生高并发, 热门课程的席位是有限的, 比如某个热门课程仅限 100 名学生, 但是高并发场景下,执行以下代码, 经常超过100名学生抢到该热门课程 以下代码只是大概, 并非可完整执行, 只是用于解释问题; //可重入锁,默认是非公平锁 private Lock lock = new ReentrantLock(true); @Autowired private CourseMapper cou
Java并发编程-synchronized锁优化
Java硬件工程师的博客
02-05 3998
1.小故事 synchronized工作方式是让每个对象关联一个monitor，monitor锁是由操作系统提供的，要使用它成本较高，如果是每次进入synchronized的话需要获得一个monitor锁，那么就需要很大的开销。从Java6开始对synchronized获取锁的方式进行了优化。除了可以使用轻量级锁，还可以使用偏向级锁来进行优化。 故事角色 老王 - JVM 小南 - 线程 小女 - 线程 房间 - 对象 房间门上 - 防盗锁 - Monitor 房间门上 - 小南书包
Java并发编程-读写锁
wflovejava的博客
07-31 239
Java并发编程-读写锁
Java并发编程-ReadWriteLock读写锁
Java硬件工程师的博客
01-28 2504
为什么我们有了Lock，还要用ReadWriteLock呢。我们对共享资源加锁之后，所有的线程都将会等待。Lock读操作也锁，写操作也会锁，而对共享资源读的时候，其实是不用加锁的。当然读写同时存在的情况也会有。 比如我们数据库常用操作有增删改查，增删改都是写操作，写操作必须加锁。 ...
Go并发编程-读写锁
技术原始积累
02-05 3282
一、前言go语言类似Java JUC包也提供了一些列用于多线程之间进行同步的措施，比如低级的同步措施有 锁、CAS、原子变量操作类。本节我们先来看看go中读写锁，读写锁相比互斥锁来说并发...
Java并发编程-线程池
热门推荐
千月落
02-21 1万+
Java 中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。
Go并发编程-Channel
01-07
一、前言 ...前面章节我们讲解了Go中提供的低级同步原语-锁，其实Go的并发原语 – goroutines和channels 提供了一种优雅而独特的结构化开发并发软件的方式。Go鼓励使用通道在goroutine之间传递对共享
多线程并发编程-同步与互斥-原⼦变量-并发和⽆锁 数据结构
12-30
多线程并发编程-同步与互斥-原⼦变量-并发和⽆锁 数据结构
java并发编程-AQS和JUC实战
04-29
java并发包详解，condition重入锁；Semaphore信号量；ReadWriteLock读写锁；CountDownLatch计时器；CyclicBarrier循环栅栏； 重⼊锁可以完全替代synchronized关键字。在JDK5.0的早期版本中，重⼊锁的性能远远好于 ...
深入理解高并发编程-核心技术原理
03-14
(1) 导致并发编程频繁出问题的“幕后黑手” (2)工作了3年的程序员小菜面试高并发岗位被吊打虐哭 (3)如何解决可见性和有序性问题？这次彻底懂了！ 3、实战案例篇 (1) 如何实现亿级流量下的分布式限流？这些理论你必须...
实例讲解Java并发编程之闭锁
09-03
主要介绍了实例讲解Java并发编程之闭锁,闭锁相当于一扇门,在闭锁到达结束状态之前,这扇门一直是关闭着的,没有任何线程可以通过,当到达结束状态时,这扇门才会打开并容许所有线程通过,需要的朋友可以参考下
毕业设计MATLAB_执行一维相同大小矩阵的QR分解.zip
05-27
毕业设计matlab
ipython-7.9.0.tar.gz
最新发布
05-27
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
debugpy-1.0.0b3-cp37-cp37m-manylinux2010_x86_64.whl
05-27
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
libaacs-devel-0.10.0-1.mga8.i586.rpm
05-27
rpm -i xx.rpm 只要报错遇到aacs的可以看看架构是否一致
狂神说java-juc并发编程
09-23
狂神说java-juc并发编程是指狂神在讲解Java并发编程时提到了Java Util Concurrent（简称JUC）这个包。JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值