JUC —— Lock锁

最新推荐文章于 2022-11-02 17:51:38 发布
最新推荐文章于 2022-11-02 17:51:38 发布
阅读量349 收藏 1
点赞数
分类专栏： JUC 文章标签： juc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46540606/article/details/122807017
版权

真正的多线程(公司)开发，不会去创建一个类，用该类去继承Thread类或实现Runnable接口，线程就是一个单独的资源类，没有任何附属的操作！

Synchronized传统锁

public class SynchronizedTest {
    public static void main(String[] args) {
        //创建资源类
        Ticket ticket = new Ticket();
        //函数式接口使用lambda表达式
        new Thread(()->{
            for(int i=1;i<40;i++){
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for(int i=1;i<40;i++){
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for(int i=1;i<40;i++){
                ticket.sale();
            }
        },"C").start();
    }
}
//资源类，只有属性和方法
class Ticket{
    private int number = 30;
    //买票 synchronized 本质：队列，锁
    public synchronized void sale(){
        if(number > 0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张票，剩余"+number+"张票");
        }
    }
}

测试结果：

A卖出了第30张票，剩余29张票
B卖出了第29张票，剩余28张票
B卖出了第28张票，剩余27张票
B卖出了第27张票，剩余26张票
B卖出了第26张票，剩余25张票
B卖出了第25张票，剩余24张票
B卖出了第24张票，剩余23张票
B卖出了第23张票，剩余22张票
B卖出了第22张票，剩余21张票
B卖出了第21张票，剩余20张票
B卖出了第20张票，剩余19张票
B卖出了第19张票，剩余18张票
B卖出了第18张票，剩余17张票
B卖出了第17张票，剩余16张票
B卖出了第16张票，剩余15张票
B卖出了第15张票，剩余14张票
B卖出了第14张票，剩余13张票
B卖出了第13张票，剩余12张票
B卖出了第12张票，剩余11张票
B卖出了第11张票，剩余10张票
B卖出了第10张票，剩余9张票
B卖出了第9张票，剩余8张票
B卖出了第8张票，剩余7张票
B卖出了第7张票，剩余6张票
B卖出了第6张票，剩余5张票
B卖出了第5张票，剩余4张票
B卖出了第4张票，剩余3张票
B卖出了第3张票，剩余2张票
B卖出了第2张票，剩余1张票
B卖出了第1张票，剩余0张票

Lock锁

点击ReentrantLock查看源码可以看到

public ReentrantLock() {
        sync = new NonfairSync();
    }
    public ReentrantLock(boolean fair) {
    	//                公平锁           非公平锁
        sync = fair ? new FairSync() : new NonfairSync();
    }

公平锁： 十分公平，可以先来后到
非公平锁： 十分不公平，可以插队（ReentrantLock默认非公平锁）

使用Lock锁三步骤：

  • 创建lock对象 Lock lock = new ReentrantLock();
  • 加锁 lock.lock();
  • 解锁 lock.unlock();
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockTest {
    public static void main(String[] args) {
        //创建资源类
        Ticket2 ticket = new Ticket2();
        //函数式接口使用lambda表达式
        new Thread(()->{ for(int i=1;i<40;i++) ticket.sale();},"A").start();
        new Thread(()->{ for(int i=1;i<40;i++) ticket.sale();},"B").start();
        new Thread(()->{ for(int i=1;i<40;i++) ticket.sale();},"C").start();
    }
}

//资源类，只有属性和方法
class Ticket2{
    private int number = 30;
    //买票 使用lock锁
    Lock lock = new ReentrantLock();
    public void sale(){
        //加锁
        lock.lock();
        try{
            if(number > 0){
                System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张票，剩余"+number+"张票");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //解锁
            lock.unlock();
        }
    }
}

测试结果：

A卖出了第30张票，剩余29张票
A卖出了第29张票，剩余28张票
C卖出了第28张票，剩余27张票
C卖出了第27张票，剩余26张票
C卖出了第26张票，剩余25张票
C卖出了第25张票，剩余24张票
B卖出了第24张票，剩余23张票
B卖出了第23张票，剩余22张票
B卖出了第22张票，剩余21张票
B卖出了第21张票，剩余20张票
B卖出了第20张票，剩余19张票
B卖出了第19张票，剩余18张票
B卖出了第18张票，剩余17张票
B卖出了第17张票，剩余16张票
B卖出了第16张票，剩余15张票
B卖出了第15张票，剩余14张票
B卖出了第14张票，剩余13张票
B卖出了第13张票，剩余12张票
B卖出了第12张票，剩余11张票
B卖出了第11张票，剩余10张票
B卖出了第10张票，剩余9张票
B卖出了第9张票，剩余8张票
B卖出了第8张票，剩余7张票
B卖出了第7张票，剩余6张票
B卖出了第6张票，剩余5张票
B卖出了第5张票，剩余4张票
B卖出了第4张票，剩余3张票
B卖出了第3张票，剩余2张票
B卖出了第2张票，剩余1张票
B卖出了第1张票，剩余0张票

Synchronized和Lock区别

区别：

  • Synchronized是关键字；Lock是一个java类
  • Synchronized无法判断锁的状态；Lock是可以判断是否获取到了锁
  • Synchronized会自动释放锁；Lock必须要手动释放锁，如果不释放锁会出现 死锁
  • Synchronized 线程1（获取锁，阻塞） 线程2（一直等待）；Lock锁不会一直等待
  • Synchronized可重入锁，不可以中断的，非公平；Lock可重入锁，可以判断锁，默认非公平（可以手动设置）
  • Synchronized适合锁少量的代码同步问题；Lock适合锁大量的同步代码

生产者和消费者

Synchronized版解决：

/**
 * 线程之间的通信问题，生产者和消费者问题  等待唤醒，具体业务，通知换线
 * 线程交替执行 A B操作同一个变量 num=0
 * A num+1
 * B num-1
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            try {
                for(int i=0;i<10;i++)data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{
            try {
                for(int i=0;i<10;i++)data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}
//资源类
class Data{
    private int num = 0;
    //+1
    public synchronized  void increment() throws InterruptedException {
        //等待
        if(num != 0) {
            this.wait();
        }
        num ++;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        //通知其他线程，+1完毕
        this.notify();
    }
    //-1
    public synchronized void decrement() throws InterruptedException {
        if(num == 0){
            //等待
            this.wait();
        }
        num --;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        //通知其他线程，-1完毕
        this.notify();
    }
}

执行结果：

A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0

存在问题：如果此时在添加两个线程 C,D，再次查看结果

Data data = new Data();
        new Thread(()->{
            try {
                for(int i=0;i<10;i++)data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{
            try {
                for(int i=0;i<10;i++)data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
        new Thread(()->{
            try {
                for(int i=0;i<10;i++)data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"C").start();
        new Thread(()->{
            try {
                for(int i=0;i<10;i++)data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"D").start();
    }

执行结果：

A=>1
B=>0
A=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
D=>0
B=>-1
D=>-2
D=>-3
D=>-4
D=>-5
D=>-6
D=>-7
D=>-8
D=>-9
D=>-10
A=>-9
C=>-8
A=>-7
C=>-6
A=>-5

可以看到数据存在一些问题，原因就是我们在判断等待的时候使用的if
在官方文档的wait()方法解释中可以找到：
线程也可以唤醒，而不会被通知，中端或超时，即所谓的虚假唤醒。虽然这在实践中很少会发生，但应用程序必须通过测试应该是线程被唤醒的条件来防范，并且如果条件不满足则继续等待。换句话说，等待应该总是出现在循环中，可以使用while
解决办法：将判断等待条件用的if修改为在while循环中判断等待条件

    //+1
    public synchronized  void increment() throws InterruptedException {
        //等待
        while (num != 0) {
            this.wait();
        }
        num ++;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        //通知其他线程，+1完毕
        this.notify();
    }
    //-1
    public synchronized void decrement() throws InterruptedException {
        while (num == 0){
            //等待
            this.wait();
        }
        num --;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        //通知其他线程，-1完毕
        this.notify();
    }

执行结果：

A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0

JUC版解决：

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

public class B {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            try {
                for(int i=0;i<10;i++)data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{
            try {
                for(int i=0;i<10;i++)data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
        new Thread(()->{
            try {
                for(int i=0;i<10;i++)data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"C").start();
        new Thread(()->{
            try {
                for(int i=0;i<10;i++)data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"D").start();
    }
}
//资源类
class Data{
    private int num = 0;
    //使用lock锁
    Lock lock = new ReentrantLock();
    //JUC中配合lock提供的用于做现成通讯的接口
    Condition condition = lock.newCondition();
    //+1
    public  void increment() throws InterruptedException {
        //加锁
        lock.lock();
        try {
            while (num != 0) {
                //等待
                condition.await();
            }
            num ++;
            System.out.println(Thread.currentThread().getName()+"=>"+num);
            //通知其他线程，+1完毕
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //解锁
            lock.unlock();
        }
    }
    //-1
    public void decrement() throws InterruptedException {
        //加锁
        lock.lock();
        try {
            while (num == 0){
                //等待
                condition.await();
            }
            num --;
            System.out.println(Thread.currentThread().getName()+"=>"+num);
            //通知其他线程，-1完毕
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //解锁
            lock.unlock();
        }
    }
}

执行结果：

A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
D=>0
A=>1
D=>0
A=>1
D=>0
A=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0

从上述代码测试结果可以发现lock+condition使用和synchronized+wait效果一样，但任何一个新的技术，绝对不是仅仅只是覆盖原来的技术，一定会有优势和补充。
condition的优势和补充： 精准的通知和唤醒线程

//A执行完调用B，B执行完调用C，C执行完调用A
public class C {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{for(int i=0;i<10;i++)data.printA();},"A").start();
        new Thread(()->{for(int i=0;i<10;i++)data.printB();},"B").start();
        new Thread(()->{for(int i=0;i<10;i++)data.printC();},"C").start();
    }
}

//资源类
class Data{
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    private int num = 1; //1的时候A执行，2的时候B执行，3的时候C执行

    public void printA(){
        lock.lock();
        try{
            while (num != 1){
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"执行");
            num = 2;
            //唤醒指定的人B
            condition2.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();
        try{
            while (num != 2){
                //等待
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"执行");
            num = 3;
            //唤醒C
            condition3.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void printC(){
        lock.lock();
        try{
            while (num != 3){
                //等待
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"执行");
            num = 1;
            //唤醒A
            condition1.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

执行结果：

A执行
B执行
C执行
A执行
B执行
C执行
A执行
B执行
C执行
A执行
B执行
C执行
A执行
B执行
C执行
A执行
B执行
C执行
A执行
B执行
C执行
A执行
B执行
C执行
A执行
B执行
C执行
A执行
B执行
C执行
始於心勭丶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程以及juc,lock
07-20
多线程以及juc,lock
Java——JUC
12-29
- `AtomicInteger`、`AtomicLong`等原子类提供了一种在不使用锁的情况下实现线程安全的方式，通过底层的CAS（Compare and Swap）操作保证了原子性，适用于简单的原子更新操作。 5. **Future和Callable接口** - `...
Java学习 --- JUC的lock接口
qq_46093575的博客
03-22 542
一、juc的概述 在 Java 5.0 提供了 java.util.concurrent （简称JUC ）包，在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步 IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的 Collection 实现等。 二、线程 1、用户线程 package com.cjc.juc; public class Main { public static void main(String[
JUC并发编程基础（6）--Lock锁
qq_42194397的博客
06-28 184
Lock简单介绍
JUC编程之锁详解
以梦为马，不负韶华
11-02 309
Juc简称是并发包的简写。在jdk1.5之后，并发包新增了Lock接口，以及很多Lock锁的实现类用来实现锁的功能，Lock锁提供了和Synchroized类似的功能，要手动加锁和释放锁。
JUC-Lock锁
hxy1625309592的博客
02-22 132
4- Lock锁 4.1 传统方式(同步方法) 传统的 synchronized package cn.guardwhy.test01; // 1.并发:多线程操作同一个资源类，把线程拿进线程中 public class SaleTicketDemo01 { public static void main(String[] args) { Ticket ticket = new Ticket(); // 函数式接口 new Thread(()-&gt
JUC包下各种锁使用详解
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
02-03 1658
相对之下公平锁由于是有序执行，所以相对非公平锁来说执行更慢，吞吐量更小一些。而非公平锁可以在特定场景下实现插队，所以很有可能出现某些线程被频繁插队而导致"线程饥饿"的情况。
JUC线程锁框架
12-31
ReentrantLock相比synchronized具有更细粒度的控制，支持公平性和非公平性，并提供了tryLock()方法来尝试获取锁，以及lockInterruptibly()方法使锁获取可以响应中断。ReadWriteLock则分为读锁和写锁，允许多个线程...
JUC基石——Unsafe类
12-21
《JUC基石——Unsafe类详解》 在Java并发编程领域，`Unsafe`类扮演着一个特殊的角色，尽管它被标记为“不安全”，但却是Java并发库（JUC）中的重要基石，尤其在高并发场景下，如`ConcurrentHashMap`、`Atomic`系列...
这就是标题—— JUC.pdf
05-19
使用Lock锁 可重入锁 公平锁 / 非公平锁 Synchronized / Lock 线程通讯 wait()、notify()和notifyAll() 虚假唤醒 Condition 定制化通信 多线程锁 并发下的集合类 List Set Map Callable接口 线程创建的方式 callable...
JUC-Lock工具解析
l_dongyang的博客
04-21 232
一、简介 我们在进行多线程编程的时候，考虑的最多的问题之一就是并发的问题，也就是多线程对于共享变量的操作问题。许多的时候我们会借助于锁这个工具来控制多线程并发对于共享变量的操作，是一种牺牲时间的并发保障机制。在java中关于同步工具有自带的关键字synchronized，也有juc下利用AQS同步框架封装的Lock工具，关于AQS可以在JUC-AQS框架解析文章中进行源码级别的分析，本文章在AQ...
JUC(5): 各种锁重点汇总
BaiHang111的博客
07-08 515
各种锁重点汇总：公平锁、自旋锁、死锁、乐观悲观锁、锁升级、锁粗化、读写锁、锁降级、邮戳锁
JUC学习（二）：Lock的介绍及使用（实现多线程卖票）
m0_49499183的博客
03-20 516
一、Lock简介 Lock 锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。Lock 提供了比 synchronized 更多的功能。 Lock 与的 Synchronized 区别： Lock 不是 Java 语言内置的，synchronized 是 Java 语言的关键字，因此是内置特性。Lock 是一个类，通过这个类可以实现同步访问； Lock 和 synchronize...
JUC并发编程（三）-Lock锁详解
二总的猫
02-26 670
3、Lock锁 3.1. 多线程的编程模型 多线程编程的代码编写模型： 1、高内聚，低耦合 :必须保证业务代码的高内聚、低耦合； 2、线程去操作(调用对外暴露的方法) 资源类。 3.2. 使用传统的关键字synchronized实现Lock锁 要按照多线程的编程模型来实现Lock锁。如下方式，在企业中静止这样写。 package com.interview.concurrent.lock; ...
JUC-Lock
维多利亚少年
08-23 1432
Lock （JUC锁） 1、概述 2、Lock与ReentrantLock 1、概述 2、API 3、代码 3、AQS 1、概述 2、总结 4、Condition 5、ReentrantReadWriteLock 1、概述 2、使用场景 3、特性 6、StampedLock 1、概述 2、代码 3、StampedLock 原理 7、CountDownLatch、Semaphor...
java并发编程（四）----（JUC）Lock锁初探
a2225791的博客
12-26 250
首先我们来回忆一下上一节讲过的synchronized关键字，该关键字用于给代码段或方法加锁，使得某一时刻它修饰的方法或代码段只能被一个线程访问。那么试想，当我们遇到这样的情况：当synchronized修饰的方法或代码段因为某种原因（IO异常或是slee...
JUC—Lock锁
showadwalker的博客
12-16 192
文章目录一、Lock二、ReentrantLock用法三、 Lock 锁和 Synchronized 的区别四、 传统 Synchronized 生产者和消费者问题五、Lock 和 Condition 生产者消费者问题六、Condition 精准唤醒七、 一、Lock Lock 是一个接口，主要实现类包括： ReentrantLock 可重入锁（常用） ReentrantReadWriteLock.ReadLock 读锁 ReentrantReadWriteLock.WriteLock 写锁 二、Ree
JUC之各种锁
Y_Ace的博客
04-15 579
公平锁和非公平锁 回头看一下之前的一个多线程买票案例 public class LockSaleTicket { public static void main(String[] args) { LockTicket lockTicket = new LockTicket(); new Thread(()->{ for (int i = 0; i < 20; i++) { lockTicket.sal
JUC锁-锁的分类
oheg2010的博客
05-15 2351
锁的分类 悲观锁：在进入同步方法的时候都会获取当前同步锁对象，直到退出同步方法时才会释放同步锁对象。如果有线程A和线程B,同他们都会访问obj对象的同步方法。当线程A获取到obj对象的同步锁，在执行某些方法的时候，这时候线程B企图获取 obj对象的同步锁就会失败，这个时候必须等待，直到线程A释放掉 obj对象的同步锁，线程B才能执行obj的同步方法 java中的悲观锁是synchronized，A...
juc的公平锁与非公平锁
最新发布
10-17
JUC中的公平锁和非公平锁都是ReentrantLock类的实现。公平锁和非公平锁的区别在于获取锁的方式不同。 公平锁：线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的原则。当一个线程释放锁时，等待时间最长...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值