01Lock锁

最新推荐文章于 2022-11-23 03:13:39 发布
最新推荐文章于 2022-11-23 03:13:39 发布
阅读量560 收藏 1
点赞数
分类专栏： JUC并发编程 文章标签： java Lock锁 生产者与消费者 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/niannujiao6/article/details/125692148
版权
1.进程及线程

进程：一个程序的集合，一个进程包含多个线程，至少一个。
线程：对于Java而言，Thread 、Runnable、Callable

Java是开启不了线程的，需要调用本地C++的方法启动硬件来开启线程。

2.并发及并行

并发：多线程操作同一个资源（CPU单核）
并行：多条任务一起行走（CPU多核）

获取CPU核数
在这里插入图片描述
并发编程本质：要充分利用CPU资源处理任务

3.线程状态
  1. NEW:新生状态
  2. BLOCKED:阻塞状态
  3. WAITING:等待状态
  4. TIME_WAITING:超时等待状态
  5. TERMINTED:终止状态

sleep与wait的区别

  1. sleep来自Thread类，wait来自Object类
  2. wait会释放锁，sleep不会释放锁
  3. wait必须在同步代码块中使用，sleep可以在任何地方使用
  4. wait不需要捕获异常，sleep需要捕获异常
Synchronized锁与Lock锁

以多线程卖票为例：

public class Test {
    public static void main(String[] args) {
        Ticket ticket=new Ticket();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"B").start();
    }
}
class Ticket{
    private int num=40;
    public void sale(){
        if (num>0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(num--)+"的票,剩余票数"+num);
        }
    }
}

在这里插入图片描述
不难看出，多线程卖票在不加锁的情况下操作统一资源很容易出错。
解决1：传统解决方法是在同步代码中加入Sychronized锁：
在这里插入图片描述
运行如下：
在这里插入图片描述
解决2：加Lock锁
在这里插入图片描述
新建Lock锁，先加锁，业务代码用try catch包裹捕获异常，执行完之后在解锁，保证数据一致性。

    public void sale(){
        Lock lock=new ReentrantLock();
        try {
            lock.lock();
        }catch (Exception e){
            if (num>0){
                System.out.println(Thread.currentThread().getName()+"卖出了第"+(num--)+"的票,剩余票数"+num);
            }
        }
        finally {
            lock.unlock();
        }

执行结果：
在这里插入图片描述
sychronized锁与Lock锁的区别

  1. sychronized是一个关键字，lock是一个类
  2. sychronized无法获取锁的状态，lock通过加锁和解锁可以
  3. sychronized会自动释放锁，lock需要手动解锁，更加灵活，如果不释放锁，会造成死锁
  4. sychronized锁阻塞时，另一个线程会一直等待下去，lock锁通过 lock.tryLock()来尝试获取锁，不会一直等待
  5. sychronized可重入锁 、不可中断、非公平。lock可重入锁，可以判断，通过加入参数设置是否可公平。
  6. sychronized适合锁少量的同步代码，lock适合大量的锁同步代码
提供者与消费者

sychronized版

package com.wang.JUC;

/**
 * @author 
 * @Date 2022/7/9
 * @apiNote
 */
public class Procom {
    public static void main(String[] args) {
        Provider provider=new Provider();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    provider.incr();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"消费者A").start();
        
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    provider.decr();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"消费者B").start();

    }
/*
等待 业务 唤醒
 */
static class Provider{
        private int num=0;
        public synchronized void incr() throws InterruptedException {
            if (num!=0){
                this.wait();
            }
            num++;
            System.out.println("正在执行加操作"+num);
            this.notifyAll();
        }
        public synchronized void decr() throws InterruptedException {
            if (num==0){
                this.wait();
            }
            num--;
            System.out.println("正在执行减操作"+num);
            this.notifyAll();
        }

    }
}

执行：在这里插入图片描述

若四个线程同时进行，两个线程进行加操作，两个线程进行减操作，则会出现虚假唤醒问题，即线程可以唤醒，而不会被通知。中断或者超时：
在这里插入图片描述
解决方法：等待应该出现在循环当中，即用while来替代if进行判断
在这里插入图片描述
执行解决：在这里插入图片描述
JUC版本：


/**
 * @author wangchangjun
 * @Date 2022/7/9
 * @apiNote
 */
public class Procom {
    public static void main(String[] args) {
        Provider provider=new Provider();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    provider.incr();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"消费者A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    provider.decr();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"消费者B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    provider.incr();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"消费者C").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    provider.decr();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"消费者D").start();

    }
/*
等待 业务 唤醒
 */
static class Provider{
        private int num=0;
        Lock lock=new ReentrantLock();
        Condition condition= lock.newCondition();
        public void incr() throws InterruptedException {
            lock.lock();//上锁
            try {
                while (num!=0){
                   condition.await();//代替等待
                }
                num++;
                System.out.println("正在执行加操作"+num);
                condition.signalAll();//代替唤醒
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();//解锁
            }
        }
        public  void decr() throws InterruptedException {
            lock.lock();

            try {
                while (num==0){
                    condition.await();
                }
                num--;
                System.out.println("正在执行减操作"+num);
                condition.signalAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }


        }

    }
}

执行：
在这里插入图片描述
缺陷：线程执行不是按顺序唤醒，需要通过Condition来优化


/**
 * @author 
 * @Date 2022/7/9
 * @apiNote
 */
public class Procom {
    public static void main(String[] args) {
        Provider provider=new Provider();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    provider.incr();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"消费者A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    provider.decr();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"消费者B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    provider.decr1();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"消费者C").start();
//
//        new Thread(()->{
//            for (int i = 0; i < 10; i++) {
//                try {
//                    provider.decr();
//                }catch (Exception e){
//                    e.printStackTrace();
//                }
//            }
//        },"消费者D").start();

    }
/*
等待 业务 唤醒
 */
static class Provider{
        private int num=1;
        Lock lock=new ReentrantLock();
        Condition conditionA= lock.newCondition();//分别监控
        Condition conditionB= lock.newCondition();
        Condition conditionC= lock.newCondition();
        public  void incr() throws InterruptedException {
            lock.lock();
            try {
                while (num!=1){
                    conditionA.await();
                }
                num=2;
                System.out.println(Thread.currentThread().getName()+"正在执行加操作"+num);
                conditionB.signal();//A执行完唤醒指定线程B
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
        public  void decr() throws InterruptedException {
            lock.lock();

            try {
                while (num!=2){
                    conditionB.await();
                }
                num=3;
                System.out.println(Thread.currentThread().getName()+"正在执行减操作"+num);
                conditionC.signal();//B执行完唤醒指定线程C
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }


        }

    public  void decr1() throws InterruptedException {
        lock.lock();

        try {
            while (num!=3){
                conditionC.await();
            }
            num=1;
            System.out.println(Thread.currentThread().getName()+"正在执行减操作"+num);
            conditionA.signal();//C线程执行完再次唤醒线程A
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }

    }
}

执行
在这里插入图片描述

念奴娇6
关注
专栏目录
高薪程序员&面试题精讲系列65之你熟悉Lock锁吗？公平锁和非公平锁怎么回事？
一一哥
02-18 577
一. 面试题及剖析 1. 今日面试题 你熟悉Lock锁吗？ 说一下Lock锁有哪些常用API方法吧 ReentrantLock锁你了解吗？ 公平锁和非公平锁怎么回事？ 2. 题目剖析 在上一篇文章中，壹哥给大家重点讲解了synchronized锁的特性及底层原理。今天壹哥会继续给大家讲解另一个锁相关的面试题，即Lock锁相关的面试题。Lock锁也是我们开发时非常常用的锁，所以面试时，Lock锁也是被提问的重点。那么Lock锁有什么特性、怎么使用、底层原理如何，这些都是面试的重点，接下来请看
关于Lock锁的讲解，与不懂之处
m0_56469434的博客
04-27 704
synchronized和Lock的区别
Lock锁 Condition 和线程的关系详解
zcw4237256的博客
11-16 1968
一、锁的作用和比较 1、Lock接口及其类图 Lock接口：是Java提供的用来控制多个线程访问共享资源的方式。 ReentrantLock：Lock的实现类，提供了可重入的加锁语义 ReadWriteLock:读写锁的接口 ReentrantReadWriteLock: ReadWriteLock的实现类，维护一对锁，一个读锁（ReentrantReadWriteLoc
线程补充（Lock锁、死锁、线程状态）
weixin_42279465的博客
02-18 522
目录 Lock锁 死锁 线程状态 Lock锁 java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。 Lock锁也称同步锁，加锁与释放锁方法化了 接口实现类：java.util.locks.lock.ReentrantLock public void lock() :加同步锁。 public void
如何看锁状态
xlnaan的博客
04-08 1711
dumpsys powersys/power/wake_lock
详解Java锁机制：看完你就明白的锁系列之锁的状态
Javazhoumou的博客
10-23 2335
详解Java锁机制：看完你就明白的锁系列之锁的状态 前言: 看完你就会知道，线程如果锁住了某个资源，致使其他线程无法访问的这种锁被称为悲观锁，相反，线程不锁住资源的锁被称为乐观锁，而自旋锁是基于 CAS 机制实现的，CAS又是乐观锁的一种实现，那么对于锁来说，多个线程同步访问某个资源的流程细节是否一样呢？换句话说，在多线程同步访问某个资源时，锁的状态会如何变化呢？本篇文章来探讨一下。 ...
SQL Server查询使用键查找时锁申请及释放顺序
qq_39824154的博客
05-27 126
当然看的过程中，其实自己有个疑问： 　　对于键查找这类查询，会申请哪些锁，锁申请和释放的顺序是怎样的？ 　　准备 　　备注：测试表仍然使用高兄文中创建的测试表testklup 　　在开始之前，使用dbcc ind 命令先看下测试表的数据组织情况 　　然后语句执行计划图如下： 　　查看申请了哪些锁 　　为了得到查询会申请哪些锁，通过如下这条查询就可以得...
Java-Lock锁
u014230945的博客
01-10 2338
1、JDK1.5以后，Java提供了Lock同步锁，相对与需要JVM隐士获取和释放锁Synchronized 同步锁，Lock同步锁需要显示获取和释放锁，这就为获取和释放锁提供了更多的灵活性。 2、Lock锁的基本操作通过乐观锁来实现，但是由于Lock锁也会在阻塞的时候被挂起，因此它依然属于悲观锁。 对比Synchronized和Lock如下图 Synchronized Lock 实现方式 ...
可重入锁--sychronized锁和lock锁代码详解
陌上人如玉，公子世无双
08-06 539
可重入锁--sychronized锁和lock锁代码详解
synchronized与Lock锁
qq_41920244的博客
04-24 220
为了保证每个线程之间的安全，通过同步锁来对线程进行管理。 这里为狂神打个广告：B站狂神说讲解的基础很不错，没怎么学过或者基础不牢固的同学可以看看。 1.面经（synchronized和Lock锁的区别） Lock是显示锁（需要手动开启和关闭锁，调用其lock()方法和unlock()方法）； synchronized是隐式锁,出了其作用域自动释放锁资源。 Lock只有代码块锁；synchronized有代码块锁和方法锁。 使用Lock锁，JVM可以将花费较少的时间来调度线程，性能更好。并且具有更
java多线程释放锁顺序,java基础知识总结——多线程与锁
weixin_42180863的博客
03-15 486
1、线程与进程的区别？进程是资源(CPU、内存等)分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。线程是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量...
并发编程的艺术--第五章-Java中的锁
qq_40722284的博客
05-28 478
内容主要围绕两个方面：使用，通过示例演示这些组件的使用方法以及详细介绍与锁相关的API；实现，通过分析源码来剖析实现细节，因为理解实现的细节方能更加得心应手且正确地使用这些组件。Lock接口锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁能够防止多个线程同时访问共享资源（但是有些锁可以允许多个线程并发的访问共享资源，比如读写锁）。它提供了与synchronized关键字类似的同步功能，只是...
ReentrantLock获取锁、释放锁的流程
最新发布
qq_40931553的博客
11-23 889
juc
synchronized 和 Lock详解总结
闫兆昌的博客
04-27 5525
1 synchronized 和 Lock的区别 a)存在层次 synchronized是关键字，在jvm层面上，由内置语言实现。 Lock是接口、类。 b) 锁的释放 synchronized在线...
java多线程之-死锁
RunningXiaoHei的博客
12-02 318
当两个或多个线程竞争试图获取对方持有的同步锁时，它们都会处于阻塞状态，除非某个线程主动释放自己所持有的同步锁，这时，死锁就出现了。用下面这张图很好理解： 如图，线程Thread1和Thread2都有两个同步方法Operation1()、Operation2(),Operation1()中会调用Operation2().当某个时候，Thread1获取了A的对像锁，然后失去了CPU时间片，Thre
JavaSE（20）——java锁机制
phg739436146的博客
08-11 370
java锁机制 1. synchronized锁 1.1 定义 synchronized是java的一个关键字，它能够将代码块(方法)锁起来 它使用起来是非常简单的，只要在代码块(方法)添加synchronized，即可以实现同步功能。 public sychronized void test(){} synchronized是一种互斥锁 一次只能允许一个线程进入被锁住的代码块 synchronized是一种内置锁/监视器锁 Java中每一个对象都有一个内置锁 (监视器，也可以理解成锁标
详解JDK锁01：结合源码一文弄懂Lock接口！
周三不Coding的博客
10-12 278
结合经典并发书籍《Java并发编程艺术》以及JDK源码，尽可能将JDK锁解释清楚！
浅析可重入锁的加锁释放锁过程
Remember_Z的博客
04-23 841
一、AQS AQS：AbstractQueuedSynchronizer，抽象队列同步器，是juc的基础，如常用的ReentrantLock、Semaphore、CountDownLatch、ReentrantReadWriteLock等都是基于AQS来进行设计的。 AQS通过维护一个同步状态state和一个双向队列CLH来实现加锁释放锁。 CLH队列中存放的Node结点主要关注如下几个属性： waitStatus：等待状态，取值分别为CANCELLED = 1，SIGNAL = -1，CONDITION
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值