JUC-01-Lock锁

最新推荐文章于 2024-07-13 13:55:40 发布
最新推荐文章于 2024-07-13 13:55:40 发布
阅读量126 收藏
点赞数
分类专栏： JavaSE-高级 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44900198/article/details/106799879
版权

线程的状态

public enum State {
        // 新建
        NEW,

      	// 运行
        RUNNABLE,

        // 阻塞
        BLOCKED,

       	// 等待
        WAITING,

       	// 超时等待
        TIMED_WAITING,

        // 终止 
        TERMINATED;
    }

Lock锁

传统的Synchronized



// 基本的买票例子
public class SaleTicketDemo01 {

    // 真正的线程开发，都会降低耦合性
    // 线程就是一个资源类（属性，方法），没有任何附属操作

    public static void main(String[] args) {

        // 并发 多个线程操作同一资源类
        final Ticket ticket = new Ticket();

        // FunctionInterface 函数式接口 lambda表达式
        // (参数)->{方法}
        new Thread(()->{
            for (int i = 0; i < 400; i++) {
                ticket.sale();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 400; i++) {
                ticket.sale();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 400; i++) {
                ticket.sale();
            }
        },"C").start();
    }

}

// 资源类
class Ticket{

    private int number = 300; // 30张票
	
	// synchronized 锁
    public synchronized void sale(){
        if(number > 0){
            System.out.println(Thread.currentThread().getName() + "卖出了："+ number-- + "张票，剩余票数："+number);
        }
    }

}

Lock 锁

在这里插入图片描述
Lock l = …; l.lock(); try { // access the resource protected by this lock } finally { l.unlock(); }

当在不同范围内发生锁定和解锁时，必须注意确保在锁定时执行的所有代码由try-finally或try-catch保护，以确保在必要时释放锁定。

实现的接口

ReentrantLock  可重入锁
ReentrantReadWriteLock.ReadLock  读锁
ReentrantReadWriteLock.WriteLock  写锁

Lock三部曲

1. Lock lock = new ReentrantLock();
2. lock.lock(); // 加锁
3. lock.unlock(); // 解锁

package com.it;

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

/**
 * @author shkstart
 * @create 2020-06-17 9:25
 */
public class SaleTicketDemo02 {

    public static void main(String[] args) {

        // 并发 多个线程操作同一资源类
        Ticket2 ticket = new Ticket2();

        // FunctionInterface 函数式接口 lambda表达式
        // (参数)->{方法}
        new Thread(()->{
            for (int i = 0; i < 400; i++) {
                ticket.sale();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 400; i++) {
                ticket.sale();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 400; i++) {
                ticket.sale();
            }
        },"C").start();
    }

}

// 资源类
class Ticket2{

    private int number = 300; // 30张票

    Lock lock = new ReentrantLock();

    public void sale(){
        try{
            lock.lock(); // 加锁
            if(number > 0){
                System.out.println(Thread.currentThread().getName() + "卖出了："+ number-- + "张票，剩余票数："+number);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock(); // 解锁
        }

    }
}

Lock和Synchronized区别

1、 Synchronized是Java内置的关键字，Lock是一个Java类

2、 Synchronized无法获取锁的状态，Lock可以判断是否获取到了锁

3、 Synchronized会自动释放锁，Lock需要手动释放(如果不释放会死锁)

4、 Synchronized的线程发生阻塞其余线程会一直等待，而Lock不一定会等待

5、 Synchronized 可重入锁，不可以中断，非公平。Lock 可重入锁，可以判断锁，非公共（可以自己设置）

 Lock 设置 公平 | 非公平 锁操作
 Lock lock = new ReentrantLock(boolean fair); 
 如果参数fair为true为公平锁 false为非公平锁

6、 Synchronzied 适合少量代码的同步问题，Lock适合大量代码的同步问题

生产者消费者

虚假唤醒

摘抄自：https://www.cnblogs.com/tqyysm/articles/9765667.html

举个例子，我们现在有一个生产者-消费者队列和三个线程。
1） 1号线程从队列中获取了一个元素，此时队列变为空。

2） 2号线程也想从队列中获取一个元素，但此时队列为空，2号线程便只能进入阻塞(cond.wait())，等待队列非空。

3） 这时，3号线程将一个元素入队，并调用cond.notify()唤醒条件变量。

4） 处于等待状态的2号线程接收到3号线程的唤醒信号，便准备解除阻塞状态，执行接下来的任务(获取队列中的元素)。

5） 然而可能出现这样的情况：当2号线程准备获得队列的锁，去获取队列中的元素时，此时1号线程刚好执行完之前的元素操作，返回再去请求队列中的元素，1号线程便获得队列的锁，检查到队列非空，就获取到了3号线程刚刚入队的元素，然后释放队列锁。

6） 等到2号线程获得队列锁，判断发现队列仍为空，1号线程“偷走了”这个元素，所以对于2号线程而言，这次唤醒就是“虚假”的，它需要再次等待队列非空。

解决方法

if 改为 while 判断
如果用if判断，多个等待线程在满足if条件时都会被唤醒(虚假的)，但实际上条件并不满足，生产者生产出来的消费品已经被第一个线程消费了。
这就是我们使用while去做判断而不是使用if的原因：因为等待在条件变量上的线程被唤醒有可能不是因为条件满足而是由于虚假唤醒。所以，我们需要对条件变量的状态进行不断检查直到其满足条件，
在这里插入图片描述

Synchronized版生产者消费者

在这里插入图片描述

1. synchronized 方法或代码块
2. wait();等待
3. notifyAll(); 唤醒全部

package com.it;

/**
 * @author shkstart
 * @create 2020-06-17 10:11
 */

public class ProCus {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        new Thread(()->{
            try {
                for(int i = 0 ; i <= 10 ;i++){
                    clerk.dev();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    clerk.sale();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    clerk.dev();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"C").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    clerk.sale();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"D").start();
    }
}

class Clerk{

    private int product = 0;

    // 生产
    public synchronized void dev () throws InterruptedException {

        while(product != 0){
            wait();
        }
        product++;
        System.out.println(Thread.currentThread().getName() + ">>>" + product);
        notifyAll();
    }

    // 销售
    public synchronized void sale() throws InterruptedException {
        while(product == 0){
            wait();
        }
        product--;
        System.out.println(Thread.currentThread().getName() + ">>>" +product);
        notifyAll();
    }
}

Lock版生产者消费者

1. Lock lock = new RenntrantLock(); //创建
2. Condition condition = lock.newCondition(); 
3. lock.lock();  //加锁
4. condition.await(); //等待
5. condition.signall(); //唤醒
6. lock.unlock(); //解锁

在这里插入图片描述

package com.it;

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

/**
 * @author shkstart
 * @create 2020-06-17 17:20
 */
public class PC {

    public static void main(String[] args) {
        Clerk2 clerk2 = new Clerk2();

        new Thread(()->{for(int i = 0; i <= 10; i++) {
            try {
                clerk2.dev();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        },"A").start();

        new Thread(()->{for(int i = 0; i <= 10; i++) {
            try {
                clerk2.sale();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        },"B").start();

        new Thread(()->{for(int i = 0; i <= 10; i++) {
            try {
                clerk2.dev();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        },"C").start();

        new Thread(()->{for(int i = 0; i <= 10; i++) {
            try {
                clerk2.sale();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        },"D").start();
    }


}

class Clerk2{

    private int product = 0;

    Lock lock = new ReentrantLock();

    Condition condition = lock.newCondition();


    // 生产
    public  void dev () throws InterruptedException {
        lock.lock(); // 加锁 
        try{
            while(product != 0){
                condition.await(); //等待
            }
            product++;
            System.out.println(Thread.currentThread().getName() + ">>>" + product);
            condition.signalAll(); // 唤醒
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    // 销售
    public  void sale() throws InterruptedException {

        lock.lock(); 
        try{
            while(product == 0){
                condition.await();
            }
            product--;
            System.out.println(Thread.currentThread().getName() + ">>>" +product);
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }

    }
}

Condition实现精准唤醒

package com.it;

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

/**
 * @author shkstart
 * @create 2020-06-17 18:00
 */

// 按顺序执行
    // A --> B --> C
public class PC2 {

    public static void main(String[] args) {

        Print print = new Print();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
               print.printA();
            }
        },"A").start();

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

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

}

class Print{
    private int number = 1;


    Lock lock = new ReentrantLock();

    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();

    // 1A  2B  3C

    public void printA(){
        lock.lock();
        // 业务，判断-> 执行-> 通知
        try{
            while (number != 1){
                condition1.await();
            }
            number = 2;
            System.out.println(Thread.currentThread().getName() + "=>AAAAAAAAAAA");
            condition2.signal(); // 唤醒指定的B
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();
        try{
            while (number != 2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>BBBBBBBBB");
            number = 3;
            condition3.signal(); // 唤醒指定的C
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void printC(){
        lock.lock();
        try{
            while(number != 3){
                condition3.await();
            }
            number = 1;
            System.out.println(Thread.currentThread().getName() + "=>CCCCCCCCC");
            condition1.signal(); // 唤醒指定的A
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
}
六道佩奇。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
个人学习-JUC-笔记
02-25
- **Lock接口**：ReentrantLock是其典型实现，提供公平锁、非公平锁以及更细粒度的控制。 - **volatile**：保证变量在多线程环境中的可见性，但不保证原子性。 5. **并发容器** - **ConcurrentHashMap**：线程...
Java-JUC-多线程 进阶
07-05
Lock 锁可以分为独占锁（Exclusive Lock）和共享锁（Shared Lock）两种，独占锁只能被一个线程持有，共享锁可以被多个线程持有。Java 中提供了多种 Lock 实现，包括 ReentrantLock、LockSupport 等。 生产者和消费...
JUC----Lock框架
machine_Heaven的博客
02-27 171
JUC指java中并发编程常用的包，即java.util.concurrent。比如常见的原子类，lock框架，线程池，阻塞队列等，都在这个包内。有关于JUC的其他内容我会在后续的文章中阐述，这篇文章的主题是其中的lock框架，也是我们经常用到的并发安全框架。（写的不对的地方请大家多多指教） 为什么出现Lock框架 已经有了synchronized为什么还要有Lock的出现？ 1、首先性能方面早已...
JUC-Lock锁
m0_37329981的博客
10-28 117
JUC-Lock锁
JUC-- synchronized锁 以及 lock锁
方圆师兄
01-13 731
一段代码说明锁的作用 public class Test { private static int a; private static int b; private static int c; static Lock lock = new ReentrantLock(); private synchronized static void incrOfa() { a++; } private static void incrOfb() { b++; } private s
JUC并发编程-Lock锁
qq_50596778的博客
01-27 1471
Lock详解 简介 java.util.concurrent.locks包下常用的类与接口（lock是jdk 1.5后新增的） Lock和ReadWriteLock是两大锁的根接口： Lock代表实现类是ReentrantLock（可重入锁） ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock 同步实现原理 lock只能被一个线程获取,当一个线程执行lock.lock()后其他线程再尝试获取会进入lock对象中的等待队列,从而达到同步效果，ReenT
JUC-StampedLock
u011569827的博客
05-15 2553
该类自JDK8加入，是为了进一步优化读性能，他的特点是在使用读锁、写锁时都必须配合【戳】使用 加解读锁 long stamp = lock.readLock(); lock.unlockRead(stamp); 加解写锁 long stamp = lock.writeLock(); lock.unlockWrite(stamp); 乐观读，StampedLock支持typeOptimisticRead()方法（乐观读），读取完毕之后需要做一次戳校验，如果校验通过，表示这期间确实没有写操作，数据可以安全使
JUC-Lock锁与Synchronized
凹凸曼的博客
12-18 173
文章目录Lock锁（重点）生产者和消费者问题 Lock锁（重点） 先来回顾下传统的Synchronized实现卖票案例： public class SaleTicketDemo01 { public static void main(String[] args) { // 并发：多线程操作同一个资源类, 把资源类丢入线程 Ticket ticket = new Ticket(); new Thread(()->{for (int i = 1; i
JUC ----- 显示锁 Lock
Stephen GS的博客
08-27 296
JUC ----- 显示锁 Lock
JUC- Synchronized和lock锁的区别
m0_46276938的博客
05-24 138
Synchronized锁 防止并发访问时，多个消费者消费同一个资源类，导致资源错乱的现象 Lock 锁 lock l l.lock() 加锁 l.unlokc() 解锁 lock 使用 public class SaleTickDemo { public static void main(String[] args) { //并发：多线程操作同一个资源类，把资源类丢入线程 Tick tick = new Tick(); new Thr
Java学习 --- JUC的lock接口
qq_46093575的博客
03-22 539
一、juc的概述 在 Java 5.0 提供了 java.util.concurrent （简称JUC ）包，在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步 IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的 Collection 实现等。 二、线程 1、用户线程 package com.cjc.juc; public class Main { public static void main(String[
juc-lock
nice_good_boy的博客
12-16 94
lock锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。衙门允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。lock提供了比synchronized更多的功能。 lock与synchronized区别 1.lock不是java语言内置的，synchronized是java语言的关键字，因此是内置特性。 2.lock是一个类，通过这个类可以实现同步访问。 3.ock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synch
juc-1(2).docx
03-29
而 `Lock` 接口（如 `ReentrantLock`）提供了更细粒度的锁控制，如可中断的锁等待、公平锁和非公平锁选择、以及条件变量等，但使用起来更复杂。 【线程间通讯】 线程间通信是为了协调不同线程对共享资源的访问顺序...
juc-learn:juc相关源码的分析以及使用介绍
03-23
ReentrantLock提供了比synchronized更灵活的锁控制，例如公平锁和非公平锁的选择，以及tryLock方法。 7. **并发工具类** CyclicBarrier（回环栅栏）和CountDownLatch（计数器门锁）用于多线程间的同步，Semaphore...
Java 多线程与并发(7-26)-JUC - 类汇总和学习指南.pdf
07-22
JUC 框架包含多个部分，包括 Lock 框架、Tools 类、Collections、Atomic、Executors 等。下面是每个部分的详细解释： 1.Lock 框架和 Tools 类： Lock 框架提供了一种更灵活的锁定机制，可以代替 synchronized 方法...
Elsaticsearch java基本操作
最新发布
qq_62383709的博客
07-13 354
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 384
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 448
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1450
在 Java 中，可以通过多种方法将一个Object转换为Integer。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值