JUC-Lock锁

最新推荐文章于 2023-06-18 23:40:47 发布
最新推荐文章于 2023-06-18 23:40:47 发布
阅读量128 收藏
点赞数
分类专栏： # JUC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hxy1625309592/article/details/113946277
版权

4.1 传统方式(同步方法)

传统的 synchronized

package cn.guardwhy.test01;

// 1.并发:多线程操作同一个资源类，把线程拿进线程中
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        // 函数式接口
        new Thread(()->{
            for(int i = 1; i < 30; i++){
                ticket.saleTicket();
            }
        }, "kobe").start();
        new Thread(()->{
            for(int i = 1; i < 30; i++){
                ticket.saleTicket();
            }
        }, "Curry").start();
        new Thread(()->{
            for(int i = 1; i < 30; i++){
                ticket.saleTicket();
            }
        }, "James").start();
    }
}

// oop资源类
class Ticket{
    private int number = 30;

    // synchronized 本质: 队列, 锁
    public synchronized void saleTicket(){
        // 条件判断
        if(number > 0){
            System.out.println(Thread.currentThread().getName() + "卖出第" + (number--)
                    + "票, 还剩下:" + number + "张票");
        }
    }
}

4.2 Lock锁

使用 juc.locks 包下的类操作 Lock 锁
在这里插入图片描述

4.2.1接口实现类

在这里插入图片描述

4.2.2 公平锁和非公平锁

公平锁: 十分公平, 可以先来后到。

非公平锁: 十分不公平,可以插队(默认是非公平锁)。
在这里插入图片描述

代码示例

package cn.guardwhy.test02;

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

public class SaleTicketDemo01 {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        // 函数式接口
        new Thread(()->{for(int i = 1; i < 30; i++) ticket.saleTicket();}, "kobe").start();
        new Thread(()->{for(int i = 1; i < 30; i++) ticket.saleTicket();}, "Curry").start();
        new Thread(()->{for(int i = 1; i < 30; i++) ticket.saleTicket(); }, "James").start();
    }
}

/*
* lock锁使用:
*   1.new ReentrantLock();
*   2.Lock.lock(); // 加锁
*   3. finally=> lock.unlock(); // 解锁
*/
class Ticket{
    private int number = 30;

    // 锁对象
    Lock lock = new ReentrantLock();

    public  void saleTicket(){
        // 加锁操作
        lock.lock();

        try {
            // 条件判断
            if(number > 0){
                System.out.println(Thread.currentThread().getName() + "卖出第" + (number--)
                        + "票, 还剩下:" + number + "张票");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放锁
            lock.unlock();
        }
    }
}
4.2.3 synchronized和lock 区别

1、原始构成

  • synchronized是java内置关键字，属于JVM层面。
  • lock是具体类(java.util.concurrent.locks.Lock)是API层面的锁。

2、使用方法

  • synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁。
  • synchronized不需要用户去手动释放锁，当synchronized代码执行完后系统会自动的让线程释放对锁的占用。
  • ReentrantLock则需要用户去手动释放锁，若用户没有主动释放锁，就可能出现死锁现象。需要lock( )和unlock()方法配合try/finally语句块来完成。

3、等待是否中断

  • synchronized不可中断，除非抛出异常或者正常运行完成。
  • ReentrantLock可中断。
1.设置超时方法: tryLock(long timeout, TimeUnit unit);
2.lockInterruptibly()放入代码块中,调用interrupt()方法可中断。

4、加锁是否公平

  • synchronized的锁可重入、不可中断、非公平。
  • ReentrantLock两者都可以，默认非公平锁，构造方法可以传入boolean值，true为公平锁，false为非公平锁。
  • Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

5、实现等待通知

  • 关键字synchronized通过与wait( )和notify( )/notifyAll( )方法相结合可以实现等待/通知
  • ReentrantLock实现等待/通知，需要借助于Condition对象。用来精确唤醒线程，而不是像synchronized那样要么随机唤醒一个，要么就是全部唤醒。

4.3 生产者和消费者

4.3.1 synchroinzed实现

代码示例

package cn.guardwhy.test02;

/*
* 线程之间的通信问题: 生产者和消费者问题, 等待唤醒，通知唤醒
* 线程交替执行，两个线程操作同一个变量    number=0
*/
public class ThreadDemo02 {
    public static void main(String[] args) {
        // 创建线程对象
        Data data = new Data();
        new Thread(()->{
            for (int i=1; i<=8; i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "kobe").start();

        new Thread(()->{
            for (int i=1; i<=8; i++){
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "curry").start();
    }
}

// 资源类
class Data{
    // 判断等待，业务， 通知
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        // 判断是否该线程执行操作
        if(number != 0){
            // 等待操作
            this.wait();
        }
        // 执行操作+1
        number++;
        System.out.println(Thread.currentThread().getName() + "===>" + number);
        // 通知其他线程，num+1执行完毕
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        // 判断是否该线程执行操作
        if(number == 0){
            // 等待操作
            this.wait();
        }
        // 执行操作+1
        number--;
        System.out.println(Thread.currentThread().getName() + "===>" + number);
        // 通知其他线程，num-1执行完毕
        this.notifyAll();
    }
}
4.3.2 防止虚假唤醒

if 和while 的区别

多个线程同时操作，存在线程虚假唤醒

​

代码示例

package cn.guardwhy.test02;

public class ThreadDemo03 {
    public static void main(String[] args) {
        // 创建线程对象
        Account accout = new Account();
        new Thread(()->{
            for (int i=1; i<=8; i++){
                try {
                    accout.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "kobe").start();

        new Thread(()->{
            for (int i=1; i<=8; i++){
                try {
                    accout.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "curry").start();

        new Thread(()->{
            for (int i=1; i<=8; i++){
                try {
                    accout.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "james").start();

        new Thread(()->{
            for (int i=1; i<=8; i++){
                try {
                    accout.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "rondo").start();
    }

}

// 资源类
class Account {
    // 判断等待，业务， 通知
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        // 判断是否该线程执行操作
        while (number != 0){
            // 等待操作
            this.wait();
        }
        // 执行操作+1
        number++;
        System.out.println(Thread.currentThread().getName() + "===>" + number);
        // 通知其他线程，num+1执行完毕
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        // 判断是否该线程执行操作
        while(number == 0){
            // 等待操作
            this.wait();
        }
        // 执行操作+1
        number--;
        System.out.println(Thread.currentThread().getName() + "===>" + number);
        // 通知其他线程，num-1执行完毕
        this.notifyAll();
    }
}
4.3.3 Lock锁实现

精准通知，唤醒线程。

Lock接口

​

Condition对象

​

常用方法

​

两者方式区别

​

代码示例

package cn.guardwhy.test03;

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

/*
* 精确通知顺序访问
*/
public class LockDemo01 {
    public static void main(String[] args) {
        // 1.创建数据资源对象
        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.print1();
            }
        }, "curry").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.print2();
            }
        }, "kobe").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.print3();
            }
        }, "james").start();
    }
}

// 资源类
class Data{
    // 创建锁对象
    private Lock lock = new ReentrantLock();
    // 创建Condition对象
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    // 定义计数器
    private int number = 1;

    // 打印方法
    public void print1(){
        // 调用锁对象
        lock.lock();
        try {
            // 业务，判断->执行-> 通知
            while (number != 1){
                // 等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "===>curry");
            // 指定唤醒的线程
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void print2(){
        // 调用锁对象
        lock.lock();
        try {
            // 业务，判断->执行-> 通知
            while (number != 2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "===>kobe");
            // 唤醒指定的线程
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void print3(){
        // 调用锁对象
        lock.lock();
        try {
            // 业务，判断->执行-> 通知
            while (number != 3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "===>james");
            // 唤醒指定的线程
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

执行结果

4.4 ReadWriteLock(读写锁)

4.4.1 基本概念

4.5.2 代码示例
package cn.guardwhy.juc01;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/*
* 独占锁(写锁)：一次只能被一个线程占有
* 共享锁(读锁)：多个线程可以同时占有
* ReadWriteLock
* 读-读   可以共存！！！
* 读-写   不能共存！！！
* 写-写   不能共存！！！
*/
public class ReadWriteLockDemo01 {
    public static void main(String[] args) {
        // 创建MyCache对象
        MyCacheLock myCache = new MyCacheLock();

        // 写入操作
        for (int i = 1; i <=3 ; i++) {
            int temp = i;
            new Thread(()->{
                myCache.put(temp + "", temp+ "");
            }, String.valueOf(i)).start();
        }

        // 读取操作
        for (int i = 1; i <=3 ; i++) {
            int temp = i;
            new Thread(()->{
                myCache.get(temp + "");
            }, String.valueOf(i)).start();
        }
    }
}

/*
加锁自定义缓存
*/
class MyCacheLock{
    // volatile能保证顺序性和可见性，但是不能保证原子性，避免机读重新排序。
    private volatile Map<String, Object> map = new HashMap<>();
    // 读写锁: 更加细粒度的控制
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    // 存，写入操作的时候，只希望同时只有一个线程写入
    public void put(String key, Object value){
        // 加锁操作
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "写入" + key);
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "写入成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 解锁
            readWriteLock.writeLock().unlock();
        }
    }

    // 取，读操作，所有人都可以读取
    public void get(String key){
        // 加锁
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "读取" + key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

执行结果
​

guardwhy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常见的Java笔试题-JVM-JUC-Core:JUCJVM核心知识点
06-02
Synchronized和Lock的区别 CountDownLatch/CyclicBarrier/Semaphore CountDownLatch 枚举类的使用 CyclicBarrier Semaphore 阻塞队列 SynchronousQueue Callable接口 阻塞队列的应用——生产者消费者 传统模式 阻塞...
java抢票系统源码-distributed-lock-redis:手把手教你设计并实现一个基于Redis的分布式锁
06-05
java抢票系统源码 本项目是以学习的目的来一步一步实现一个最简单的基于Redis实现的分布式锁 ...进一步实现锁的高级特性和JUC并发工具类似功能更好：可重入、阻塞与非阻塞、公平与非公平、JUC的并发工具（Semaphore, Co
JUC详解 | JUC Lock
蕤荥的成长博客
11-03 376
锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。
JUC——Lock详解
qq_33983753的博客
02-20 283
Lock是一种用于控制多个线程对共享资源访问的工具。通常情况下，锁提供对共享资源的独占访问（独占锁，即一次只有一个线程能获取锁），并且对共享资源的所有访问都必须先获取到锁。但是，有些锁也可能允许对共享资源的并发访问（共享锁，例如ReadWriteLock中的读锁）。
高并发基础——JUC（Lock（锁））
weixin_42596778的博客
06-19 1095
引入： 之前Java基础学习了使用synchronized来做锁来实现线程安全问题，今天学习使用JUC中的Lock，他比synchronized更加灵活。 1.Lock的实现类ReentrantLock - 重入锁 锁在释放之后允许被其他线程抢占或者被一个线程重复抢占。 main方法中： static int i = 0; public static void main(String[] args) throws InterruptedException { //声明Reentr
JUC的Lock以及各种工具类
zhang_qing_yun的博客
07-21 607
JUC的Lock以及各种工具类
JUC并发工具类--锁（Lock类）的使用
qq_41139119的博客
06-18 314
JUC并发工具类--锁（Lock类）的使用
JUC多线程学习个人笔记
最新发布
07-08
锁机制：JUC提供了Lock接口和Condition接口，可以实现更细粒度的锁控制和线程的等待和唤醒机制。 并发工具类：JUC提供了一些并发编程的工具类，如Semaphore、CountDownLatch、CyclicBarrier等，可以实现线程间的协作...
这就是标题—— JUC.pdf
05-19
使用Lock锁 可重入锁 公平锁 / 非公平锁 Synchronized / Lock 线程通讯 wait()、notify()和notifyAll() 虚假唤醒 Condition 定制化通信 多线程锁 并发下的集合类 List Set Map Callable接口 线程创建的方式 callable...
尚硅谷Java视频_JUC 视频教程
02-17
尚硅谷_JUC线程高级_同步锁 Lock ·8. 尚硅谷_JUC线程高级_生产者消费者案例-虚假唤醒 ·9. 尚硅谷_JUC线程高级_Condition 线程通信 ·10. 尚硅谷_JUC线程高级_线程按序交替 ·11. 尚硅谷_JUC线程高级_...
【Java开发】JUC进阶 01：Lock锁详解
尹煜的博客
03-04 838
本文主要介绍Lock锁、公平锁和非公平锁、Condition 精准通知和唤醒线程
Java学习 --- JUC的lock接口
qq_46093575的博客
03-22 535
一、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锁
qq_50596778的博客
01-27 1453
Lock详解 简介 java.util.concurrent.locks包下常用的类与接口（lock是jdk 1.5后新增的） Lock和ReadWriteLock是两大锁的根接口： Lock代表实现类是ReentrantLock（可重入锁） ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock 同步实现原理 lock只能被一个线程获取,当一个线程执行lock.lock()后其他线程再尝试获取会进入lock对象中的等待队列,从而达到同步效果，ReenT
JUC并发包之 Lock详解
pengli
10-25 304
java.util.concurrent，并发编程常用的工具类：包含了线程池、阻塞队列、计时器、同步器、并发集合等 作者：Dong Lea。 Lock Lock 本质上是一个接口，它定义了释放锁和获得锁的抽象方法，定义成接口就意 味着它定义了锁的一个标准规范，也同时意味着锁的不同实现。 Lock 有很多的锁的实现，但是直观的实现是 ReentrantLock 重入锁。 1.ReentrantLock： 表示重入锁，表示支持重新进入的锁，它是唯一一个实现了 Lock 接口的类。重入锁指的是线程在获得锁之后，再
JUC并发编程基础（6）--Lock锁
qq_42194397的博客
06-28 180
Lock简单介绍
JUC之Lock接口
weixin_38568503的博客
03-04 3021
说明:sync的上锁和解锁是自动完成的，当然我们也可以手动上锁和解锁 Lock和synchronized的选择 总结来说，Lock和synchronized有以下几点不同： 1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现； 2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在fi...
JUC之Lock的学习
MineCodelife的博客
06-13 157
Lock接口的主要方法 //尝试获取锁，超时就放弃当前锁 boolean tryLock(long time, TimeUnit unit) throws InterruptedException; //相当于把超时时间设置为无限，在等待的过程中，线程可以被打断 void lockInterruptibly() throws InterruptedException; //注意不遵守公平原则，会获取到锁不管是否会有其它线程等待 boolean tryLock(); //最佳实践 if (loc
JUC编程之锁详解
以梦为马，不负韶华
11-02 305
Juc简称是并发包的简写。在jdk1.5之后，并发包新增了Lock接口，以及很多Lock锁的实现类用来实现锁的功能，Lock锁提供了和Synchroized类似的功能，要手动加锁和释放锁。
JUC并发编程（三）-Lock锁详解
二总的猫
02-26 667
3、Lock锁 3.1. 多线程的编程模型 多线程编程的代码编写模型： 1、高内聚，低耦合 :必须保证业务代码的高内聚、低耦合； 2、线程去操作(调用对外暴露的方法) 资源类。 3.2. 使用传统的关键字synchronized实现Lock锁 要按照多线程的编程模型来实现Lock锁。如下方式，在企业中静止这样写。 package com.interview.concurrent.lock; ...
synchronized JUC的区别
06-13
JUC（Java Util Concurrent）是 Java 并发编程的工具包，提供了一系列并发编程工具类，如 ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier 等，可以更灵活地实现线程同步和协作，支持公平锁和非公平锁，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值