Lock锁

最新推荐文章于 2024-05-28 09:25:21 发布
最新推荐文章于 2024-05-28 09:25:21 发布
阅读量163 收藏
点赞数
分类专栏： JUC 文章标签： java 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43803285/article/details/115374192
版权

Lock锁与八锁现象

一、Lock

传统 synchronized

// 基本的卖票例子
/*
*  真正的多线程开发，公司中的开发、降低耦合类
* 线程就是一个单独的资源类，没有任何的附属操作
* 1、 属性、方法
*/
public class SaleTicketDemo01 {


    public static void main(String[] args) {
        //并发：多个线程操作同一个资源类，把资源类丢入线程
        Ticket2 ticket = new Ticket2();

        // @FunctionalInterface 函数式接口，jdk1.8 lambda  (参数)->{ 代码 } 
        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            };
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        },"C").start();
    }
}

//资源类 OOP
class Ticket{
    // 属性、方法
    private int number = 50;

    // 卖票的方式
    // synchronized 本质 锁、排队
    public synchronized void sale(){
        if(number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张票，剩余"+number);
        }

    }
}

Lock 接口

在这里插入图片描述
在这里插入图片描述

公平锁：十分公平，先来后到

非公平锁：十分不公平:可以插队（默认）

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

public class SaleTicketDemo02 {
    public static void main(String[] args) {
        //并发：多个线程操作同一个资源类，把资源类丢入线程
        Ticket2 ticket = new Ticket2();
   // @FunctionalInterface 函数式接口，jdk1.8  lambda表达式 (参数)->{ 代码 } 
        new Thread(()->{for (int i = 0; i < 60; i++)ticket.sale(); },"A").start();
        new Thread(()->{for (int i = 0; i < 60; i++)ticket.sale(); },"B").start();
        new Thread(()->{for (int i = 0; i < 60; i++)ticket.sale(); },"C").start();

    }
}

// Lock三部曲
// 1、new ReentrantLock
// 2、lock.lock(); 加锁
// 3、finally=>lock.unlock(); 解锁
class Ticket2 {
    // 属性、方法
    private int number = 30;

    Lock lock = new ReentrantLock();

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

    }
}

synchronized 和 Lock 区别

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

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

3、synchronized 会自动释放锁， Lock必须要手动释放锁，如果不释放，死锁

4、synchronized 线程1（获得锁，阻塞），线程2（等待，傻傻的等）；Lock就不一定会一直等待下去； lock.trylock 尝试获取

5、synchronized 可重入锁，不可以中断的，非公平的；Lock 可重入锁，可以判断锁，非公平（可以自己设置）

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

锁是什么，如何判断锁的是什么

二、生产者和消费者问题

面试：单例模式、排序算法、生产者和消费者、死锁

生产者和消费者问题 synchronized 版本

notify是随机唤醒一个等待的线程

/*
*  线程之间的通信问题： 生产者和消费者问题！  等待唤醒，通知唤醒
*  线程交替执行   A   B 操作同一个变量 num = 0
*  A num+1
*  B num-1
*/
public class ProducerConsumerSynchronized {
    public static void main(String[] args) {
        Data data = new Data();

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

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

// 判断等待，业务，通知
class Data{ // 数字 资源类

    private int number = 0;
    // +1
    public synchronized void increment() throws InterruptedException {
        if(number!=0){  // 0 
            // 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程， 我+1完毕了
        this.notifyAll();
    }

    // -1
    public synchronized void decrement() throws InterruptedException {
        if(number==0){ // 1 
            // 等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程，我-1完毕了 
        this.notifyAll();
    }
}

问题存在，A B C D 4个线程还安全么 虚假唤醒

if判断改为while唤醒

在这里插入图片描述

/*
*  线程之间的通信问题： 生产者和消费者问题！  等待唤醒，通知唤醒
*  线程交替执行   A   B 操作同一个变量 num = 0
*  A num+1
*  B num-1
*/
public class ProducerConsumerSynchronized {
    public static void main(String[] args) {
        Data data = new Data();

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

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

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

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

// 判断等待，业务，通知
class Data{ // 数字 资源类

    private int number = 0;
    // +1
    public synchronized void increment() throws InterruptedException {
        while(number!=0){  // 0 的时候干活
            // 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程， 我+1完毕了
        this.notifyAll();
    }

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

生产者消费者问题 JUC版

在这里插入图片描述

通过Lock找到Condition
在这里插入图片描述

代码实现

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

public class ProducerConsumerJUC {
    public static void main(String[] args) {
        Data2 data = new Data2();

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

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

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

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

    }
}

// 判断等待，业务，通知
class Data2{ // 数字 资源类

    private int number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
	 //condition.await(); // 等待    
     //condition.signalAll(); // 唤醒全部   
    // +1
    public void increment() throws InterruptedException {
        lock.lock();
        try {
             // 业务代码 
            while(number!=0){  // 0 
                // 等待
                condition.await();
            }
            // condition.await();   等待
            // condition.signalAll();   唤醒全部
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            // 通知其他线程， 我+1完毕了
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    // -1
    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            while(number==0){ // 1 
                // 等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            // 通知其他线程， 我-1完毕了
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

任何一个新的技术，绝对不是仅仅覆盖了原来的技术，优势和补充

Condition 精准的通知和唤醒进程

在这里插入图片描述

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
*  A执行完调用B B->C C->A
*  A 执行完调用B，B执行完调用C，C执行完调用A 
*/
public class ProducerConsumerJUCShun {

    public static void main(String[] args) {
        Data3 data = new Data3();

        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 Data3{ // 资源类  Lock

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int number = 1;  //1A 2B 3C

    public void printA(){
        lock.lock();
        try {
            //业务，判断->执行->通知
            while (number!=1){
                // 等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAAAAAAA");
            // 唤醒， 唤醒指定的人，B
            number = 2;
            //唤醒指定进程 condition2 B
            condition2.signal();  

        } 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");
            // 唤醒， 唤醒指定的人，C
            number = 3;
            condition3.signal();  //唤醒指定进程 condition3 C
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC(){
        lock.lock();
        try {
            //业务，判断->执行->通知
            while (number!=3){
                // 等待
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>CCCCCCCCC");
            // 唤醒， 唤醒指定的人，c
            number = 1;
            condition1.signal();  //唤醒指定进程 condition1 A
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

三、8锁现象

如何判断锁的是谁。永远的知道什么是锁，锁到地锁的是谁！

深刻理解锁

import java.util.concurrent.TimeUnit;
/*** 8锁，就是关于锁的8个问题 
   * 1、标准情况下，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话 
   * 1、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话 
   * synchronized 放在方法上锁的是方法调用者，这里只有一个调用者 phone
   */
public class Synchronized {
    public static void main(String[] args) {
        Phone phone = new Phone();
         //锁的存在
        new Thread(()->{
            // 捕获 
            try {
                phone.send();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1").start();
        // 延迟执行下面t2线程，但是结果无影响，因为他们用的是同把锁。
        try {
            TimeUnit.SECONDS.sleep(1); 
        } catch (InterruptedException e) {
                e.printStackTrace(); 
        }
        new Thread(()->{
            phone.call();
        },"t2").start();
    }
    //两个线程持有的是同一个锁，谁先拿到谁先执行完,另一个才执行
}

class Phone {
     // synchronized 锁的对象是方法的调用者！、    
    // 两个方法用的是同一个锁，谁先拿到谁执行！ 
    public synchronized void send() throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + "sendMessage");
        TimeUnit.SECONDS.sleep(2);
        call();//与send（）是同一把锁 this，锁的是方法调用者，不是两把锁
    }

    public synchronized void call() {
        System.out.println(Thread.currentThread().getName() + "call");
    }
}

/**
 * 3、 增加了一个普通方法后！先执行发短信还是Hello？ 普通方法
 * 4.  两个对象，两个同步方法， 发短信还是 打电话？ // 打电话
 */
public class Test2 {
    public static void main(String[] args) {
         // 两个对象，两个调用者，两把锁
        Phone1 phone = new Phone1();
        Phone1 phone2 = new Phone1();
		 //锁的存在 
        new Thread(() -> {
            phone.sendMessage();
        }, "A").start();
		// 捕获 
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
//            phone.hello();
            phone2.call();
        }, "B").start();
    }
}

class Phone1 {
	 // synchronized 锁的对象是方法的调用者！ 
    public synchronized void sendMessage() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "sendMessage");
    }
	 // 这里没有锁！不是同步方法，不受锁的影响 
    public synchronized void call() {
        System.out.println(Thread.currentThread().getName() + "call");
    }
    //这里没有锁,不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}


/**
 * 5.增加两个静态的同步方法
 * synchronized 锁的是方法调用者
 * static 静态方法类一加载就有了 锁的是CLass
 *
 * 6. 两个对象,两个静态同步方法,先发短信还是先打电话  //发短信
 *
 */
public class Test3 {

    public static void main(String[] args) {
        // 两个对象的Class类模板只有一个，static锁的是Class
        Phone2 phone2 = new Phone2();
        Phone2 phone3 = new Phone2();
		 //锁的存在 
        new Thread(() -> {
            phone2.sendMessage();
        }, "A").start();
		 // 捕获 
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone3.call();
        }, "B").start();
    }
}
// Phone2唯一的一个 Class 对象
class Phone2 {
	 // synchronized 锁的对象是方法的调用者！    
    // static 静态方法    
    // 类一加载就有了！锁的是Class 
    public static synchronized void sendMessage() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "sendMessage");
    }

    public static synchronized void call() {
        System.out.println(Thread.currentThread().getName() + "call");
    }
}


/**
 * 7.一个静态同步方法,一个普通同步方法 ,一个对象,先输出哪一个   //打电话
 *
 * 8. 一个静态同步方法,一个普通同步方法, 两个对象,先打印哪一个  //B打电话
 */
public class Test4 {
    public static void main(String[] args) {
        
        // 两个对象的Class类模板只有一个，static，锁的是Class 
        Phone3 phone3 = new Phone3();
        Phone3 phone4 = new Phone3();
		 //锁的存在 
        new Thread(() -> {
            phone3.sendMessage();
        }, "A").start();
		 // 捕获 
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone4.call();
        }, "B").start();
    }
}
// Phone3唯一的一个 Class 对象 
class Phone3 {
	// 静态的同步方法 锁的是 Class 类模板
    public static synchronized void sendMessage() {
        try {
            TimeUnit.SECONDS.sleep(4);  //延迟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "sendMessage");
    }

     // 普通的同步方法  锁的调用者
    public synchronized void call() {
        System.out.println(Thread.currentThread().getName() + "call");
    }

}

小结：

  • synchronized 方法锁的是调用者 new this 具体的一个手机
  • static 方法锁的是模板 static Class 唯一的一个模板
    在这里插入图片描述
LatteCK
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Lock锁操作机制
m0_54202121的博客
04-21 2008
什么是Lock锁 Lock 锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允 许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对 象。Lock 提供了比 synchronized 更多的功能。 Lock 与的 Synchronized 区别 Lock 不是 Java 语言内置的，synchronized 是 Java 语言的关键字，因此是内置特性。Lock 是一个类，通过这个类可以实现同步访问； Lock 和 synchronized 有一点非常大的不同，采用 synch
Java-Lock锁
u014230945的博客
01-10 2282
1、JDK1.5以后，Java提供了Lock同步锁，相对与需要JVM隐士获取和释放锁Synchronized 同步锁，Lock同步锁需要显示获取和释放锁，这就为获取和释放锁提供了更多的灵活性。 2、Lock锁的基本操作通过乐观锁来实现，但是由于Lock锁也会在阻塞的时候被挂起，因此它依然属于悲观锁。 对比Synchronized和Lock如下图 Synchronized Lock 实现方式 ...
lock锁
m0_48273471的博客
04-01 2609
1. lock 基本用法 lock.lock(); try { } finally { lock.unlock() } 或者 try { lock.lock(); } finally { lock.unlock() } public class ThreadLock1 { public static void main(String[] args) { //1. 创建锁对象 Lock lock = new Reent...
Java Lock锁
xiangxiongfly
02-20 1921
文章目录Java Lock锁概述ReentrantLockLock#lock()Lock#tryLock()Lock#lockInterruptibly()await() & signal() & signalAll()await() 使用：await() & signal() 使用：await() & signalAll() 使用：读写锁（ReadWriteLock）论证读锁是共享锁论证写锁是独占的使用读写锁实现高并发容器 Java Lock锁 概述 synchronize
Lock锁的使用
chen13333336677的博客
08-22 1万+
在Java多线程中，可以使用synchronized关键字实现线程之间的同步互斥，在jdk1.5后新增的ReentrantLock类同样可达到此效果，且在使用上比synchronized更加灵活。 观察ReentrantLock类可以发现其实现了Lock接口 public class ReentrantLock implements Lock,java.io.Serializable 1、使用Re...
【Lock锁的使用与原理】
Java程序员廖志伟
06-17 1480
Lock锁是Java Concurrency API中的重要机制，它提供了更为灵活和强大的同步控制能力，并支持可重入锁、公平锁等特性。Lock锁的核心原理是基于AQS框架实现的，它通过操作系统提供的原语来控制锁的获取和释放，从而实现线程同步。在使用Lock锁时需要小心谨慎，以免出现死锁和其他同步问题。
C# Lock锁
lvxingzhe3的博客
12-11 9642
在多线程应用环境中，经常遇到互相抢占资源的情况，导致程序出现不可预料的异常，这时可以通过lock避免这样的冲突。
Lock锁和ReentrantLock锁
如何心安理得的在老板眼皮下摸鱼
06-03 1万+
Lock实现提供了比使用Synchronized方法和语句更广泛的搜定操作，此操作允许更灵活的结构，可以具有很大的属性，可以支持多个相关的Condition对象。
java中的Lock锁
纯洁的小魔鬼
07-15 1万+
一. 概述 Lock 是 java.util.concurrent.locks 包 下的接口，Lock 实现提供了比 synchronized 关键字 更广泛的锁操作，它能以更优雅的方式处理线程同步问题。Lock提供了比synchronized更多的功能。 1.Lock和ReadWriteLock是两大锁的根接口，Lock代表实现类是ReentrantLock（可重入锁），ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock。 　2.Lock 接口支...
Lock锁底层原理
热门推荐
Linias的博客
01-07 4万+
当多个线程需要访问某个公共资源的时候，我们知道需要通过加锁来保证资源的访问不会出问题。java提供了两种方式来加锁， 一种是关键字：synchronized，一种是concurrent包下的lock锁。 synchronized是java底层支持的，而concurrent包则是jdk实现。   关于synchronized的原理可以阅读再有人问你synchronized是什么，就把这篇文章...
lock锁，lock锁和synchronized的对比
11-19
lock锁，lock锁和synchronized的对比 # Lock锁 JDK5.0后Java提供了一种更加强大的线程同步机制。一种显式定义同步锁对象来实现锁，提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问...
Java多线程中Lock锁的使用总结
08-18
主要介绍了Java多线程中Lock锁的使用总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Lock锁的底层原理完整版
11-21
Lock锁，一种线程同步机制，其主要功能是防止多个线程同时访问同一代码块，从而避免因并发问题引发的数据不一致或其他错误。Lock锁的灵活性相比synchronized更高，它支持手动获取和释放锁，能够中断的获取锁以及超时...
kill lock解锁.sql
12-01
kill lock解锁.sql
java的Lock锁原理详解.docx
07-04
同样是锁，先说说synchronized和lock的区别： 1.synchronized是java关键字，是用c++实现的；而lock是用java类，用java可以实现 2.synchronized可以锁住代码块，对象和类，但是线程从开始获取锁之后开发者不能进行...
java学习和项目总结
2301_79390585的博客
05-24 617
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
Java高级面试精粹：问题与解答集锦（一）
Layla_c的博客
05-23 1361
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
数据访问与Spring Data JPA
无远弗届
05-25 472
假设我们要处理一个用户表（users），可以创建一个User@Entity // 标识这是一个实体类 public class User {@Id // 标识这是主键字段 @GeneratedValue(strategy = GenerationType . AUTO) // 主键生成策略 private Long id;// Getter 和 Setter ... }@Entity // 标识这是一个实体类 public class User {
operator ＜=＞ (spaceship operator)
最新发布
janeqi1987的专栏
05-28 575
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
unique_lock解锁
04-24
在C++中，unique_lock是一个用于管理互斥锁的RAII（资源获取即初始化）类。它提供了一种更灵活的方式来管理互斥锁的加锁和解锁操作。 unique_lock的解锁操作非常简单，只需要调用其成员函数unlock()即可。例如： ```cpp #include <iostream> #include <mutex> std::mutex mtx; void foo() { std::unique_lock<std::mutex> lock(mtx); // 互斥锁已经在构造unique_lock对象时被加锁 // 执行一些需要保护的操作 // 解锁互斥锁 lock.unlock(); // 在解锁后可以执行一些不需要互斥保护的操作 // 再次加锁互斥锁 lock.lock(); // 执行一些需要保护的操作 // 解锁互斥锁 lock.unlock(); } int main() { foo(); return 0; } ``` 在上面的示例中，我们首先创建了一个std::mutex对象mtx，然后在函数foo()中创建了一个unique_lock对象lock，并将mtx作为参数传递给它。在unique_lock对象的构造函数中，互斥锁会被自动加锁。然后我们可以执行一些需要保护的操作。当我们调用lock.unlock()时，互斥锁会被解锁，这样我们就可以执行一些不需要互斥保护的操作。最后，我们可以再次调用lock.lock()来重新加锁互斥锁，并执行一些需要保护的操作。最后，当unique_lock对象超出作用域时，析构函数会自动解锁互斥锁。 需要注意的是，unique_lock对象的unlock()和lock()成员函数可以在任何时候调用，而不仅仅是在构造函数和析构函数中。这使得我们可以更灵活地控制互斥锁的加锁和解锁操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值