JavaEE 【知识改变命运】03 多线程(3)

文章目录

  • 多线程带来的风险-线程安全
    • 线程不安全的举例
    • 分析产出线程安全的原因:
      • 1.线程是抢占式的
      • 2. 多线程修改同一个变量(程序的要求)
      • 3. 原子性
      • 4. 内存可见性
      • 5. 指令重排序
    • 总结线程安全问题产生的原因
    • 解决线程安全问题
      • 1. synchronized关键字的介绍(监视器锁 monitor lock)
        • a.锁的概念
        • b.synchronized的特性
        • c.synchronized的用法
        • d.针对上述问题,加synchronied解决问题,分析底层逻辑
        • e.关于synchronized的总结
        • f.不同锁对象的情况
        • g.如何判断多个线程竞争的是不是同一把锁
        • h.可重入锁
        • I.锁对象
  • Java 标准库中的线程安全类
    • 不安全类
    • 安全类
  • volatile 关键字
    • 解决线程安全的问题
      • 内存可见性
      • 实例
      • CPU层面保证可见性
      • Java层面(保证指令顺序,从而保证内存可见性)
      • 总结
  • wait() 和 notify()
    • wait和notify的基础知识
    • wait()方法
    • notify()⽅法
    • notifyAll()⽅法
    • wait 和 sleep和join的对⽐(⾯试题)
    • wait和notify的总结

多线程带来的风险-线程安全

线程不安全的举例

场景: 用两个线程对同一个变量分别自增5万次,预期结果和自增结果是一个累加和,10万次。

    public static  int count;public static void main(String[] args) {Counter counter = new Counter();Thread t1 =new Thread(()->{for(int i=0;i<5_0000;i++){counter.count();}});Thread t2 =new Thread(()->{for(int i=0;i<5_0000;i++){counter.count();}});t1.start();t2.start();try {t1.join();t2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Count: "+counter.count);}public  void count(){{count+=1;}} }

执行结果:

在这里插入图片描述
程序运行得到的结果与预期的结果值不一样,而且是一个错误的结果,而且我们程序的逻辑是正确的,这个现象所表现的问题称为线程安全问题

分析产出线程安全的原因:

1.线程是抢占式的

线程是抢占执行的(执行顺序是随机的)
由于线程的执行顺序无法为人控制,抢占式执行是造成线程安全问题的主要罪魁祸首,而且我们解决不了,完全是CPU自己调度,而且和CPU的核数有关

2. 多线程修改同一个变量(程序的要求)

单个线程修改同一个变量不会产生线程安全问题
多个线程修改不同的变量不会产生线程安全问题
多个线程修改同一个变量,会产生线程安全问题

3. 原子性

  • 什么是原⼦性
    我们把⼀段代码想象成⼀个房间,每个线程就是要进⼊这个房间的⼈。如果没有任何机制保证,A进⼊房间之后,还没有出来;B 是不是也可以进⼊房间,打断 A 在房间⾥的隐私。这个就是不具备原⼦性那我们应该如何解决这个问题呢?是不是只要给房间加⼀把锁,A
    进去就把⻔锁上,其他⼈是不是就进不来了。这样就保证了这段代码的原⼦性了。 有时也把这个现象叫做同步互斥,表⽰操作是互相排斥的。
  • ⼀条 java 语句不⼀定是原⼦的,也不⼀定只是⼀条指令 比如上面的:count++,对应的是多条CPU指令 1:从内存或者寄存器读取count值 LOAD 2:执行自增 ADD 3:把计算结果写回寄存器或者内存 STORE
  • 不保证原⼦性会给多线程带来什么问题 如果⼀个线程正在对⼀个变量操作,中途其他线程插⼊进来了,如果这个操作被打断了,结果就可能是错误的。 这点也和线程的抢占式调度密切相关. 如果线程不是 “抢占” 的, 就算没有原⼦性, 也问题不⼤.
    在这里插入图片描述

在这里插入图片描述

4. 内存可见性

  • 什么是内存可见性 一个线程对共享变量进行了修改,其他线程能感知到变量修改后的值。
  • Java内存模型(JMM) java虚拟机规范定义了Java内存模型 ⽬的是屏蔽掉各种硬件和操作系统的内存访问差异,以实现让Java程序在各种平台下都能达到⼀致的并发效果.
    在这里插入图片描述
  • 分析Java内存模型
    1.工作内存和线程之间是一一对应的
    2.java的共享变量都在主内存里面,java线程线程首先从主内存读取变量的值到自己的工作内存
    3.每个线程都有自己的工作内存,且线程工作内存直接是相互隔离的
    4.线程在工作内存修改完变量的值后,又从工作内存把变量的值刷回主内存里面。
    5.在以上执行count++操作,由于两个线程在执行,每个线程都有自己的工作内存,且相互不可见,最终导致了线程安全问题。线程对共享变量的修改线程之间相互感知不到
  • 注意: 为什么整这么多内存? 实际并没有这么多 “内存”. 这只是 Java 规范中的⼀个术语, 是属于 “抽象” 的叫法,所谓的 “主内存” 才是真正硬件⻆度的 “内存”. ⽽所谓的 “⼯作内存”, 则是指 CPU 的寄存器和⾼速缓存 为啥要这么⿇烦的拷来拷去? 因为
    CPU 访问⾃⾝寄存器的速度以及⾼速缓存的速度, 远远超过访问内存的速度(快了 3 - 4 个数量级,也就是⼏千倍,
    上万倍).那为什么不全部用寄存器,原因很简单,太贵了。
  • 关于JMM内存模型的面试题:JMM规定
    1.所以线程不直接修改主内存中的共享变量
    2.如果修改共享变量,需要把这个变量从主内存复制到自己的工作内存中,修改完之和再刷回主内存
    3.各个线程之间不能相互通信,做到了内存级别的线程隔离。

5. 指令重排序

1.什么是指令重排序 我们写的代码,在编译之后可能与代码对应的指令顺序不同,这个过程就是指令重排序(JVM层面可能重排序,CPU执行指令也可能重排序)
1.一段代码是这样的 a.代阳去教室取英语书 b.代阳去食堂吃饭 c.代阳去教室去数学书 在单线程情况下,JVM,CPU指令集会对其优化,执行顺序按a–c–b的方式执行,也是没有问题,可以少跑一次教室,这就叫指令重排序
编译器对于指令重排序的前提是 “保持逻辑不发⽣变化”. 这⼀点在单线程环境下⽐较容易判断, 但是在多线程环境下就没那么容易了,
多线程的代码执⾏复杂程度更⾼, 编译器很难在编译阶段对代码的执⾏效果进⾏预测, 因此激进的重排序很容易导致优化后的逻辑和之前不等价

总结线程安全问题产生的原因

  1. 线程是抢占式执行的
  • CPU的调度问题,硬件层面,我们解决不了
  1. 多个线程修改同一个变量
  • 在真实业务场景中,使用多线程就是为了提升效率,在并发编成中这个需求是满足的
  1. 原子性
  • 指令是在CPU上执行,怎么才能让CPU在执行时实现原子性,这个可能可以解决
  1. 内存可见性
  • java层面应该可以解决,进程之间可以进行通信,那那么在线程中应该也有这样的机制,让线程在内存中也可以彼此感知
  1. 指令重排序
  • 对于代码来说谁的优先级高,我们可以通过某种方式告诉编译器,不要对我的代码进行重排序
  1. 总结以上1,2我们不能改变,但是3,4,5我们可以进行改变,只要满足3,4,5中的一条或者多条,线程安全问题就可以解决

解决线程安全问题

1. synchronized关键字的介绍(监视器锁 monitor lock)

a.锁的概念

比如线程A拿到了锁,别的线程如果要执行被锁住的代码,那就要等到线程A释放锁之后,如果A没有释放锁,那么别的线程只能阻塞等待,这个状态就是BLOCK

b.synchronized的特性
  1. 互斥:synchronized会引起互斥效果,某个线程执行到某个对象的synchronized时,其他线程如果也执行到同一个对象sychronized就会阻塞等待
  2. 保证了原子性(通过加锁实现)
  3. 保证了内存可见性(通过串行执行实现)
  4. 不保证有序性
c.synchronized的用法

修饰方法:

  1. 修饰非静态方法:默认锁对象是this(当前对象)
  2. 修饰静态方法:默认锁对象是本身类
    修饰代码块:
    可以充当锁对象的是实例对象(new出来的对象,类对象,this)
d.针对上述问题,加synchronied解决问题,分析底层逻辑
    public synchronized void count(){ //  修饰代码块加锁synchronized(this){ //            count+=1; //        }synchronized(this){count+=1;}} }

在这里插入图片描述
如果修饰方法:其实把方法进行了串行化处理
如果修饰的是代码块:其实把修饰代码块的内容,进行了串行话处理。对于部分类似这种要修改共享变量的情况进行串行话,其他代码模块继续并行执行,这样就可以提高效率

画图分析:
在这里插入图片描述
注意的点: t1释放锁之后,也可能第二次还是t1先于t2拿到锁,因为线程是抢占式执行的,不一定是t2
由于线程在执行逻辑之前要拿到锁,当拿到锁时,上一个线程已经执行完所有的指令,并把修改的值刷新会主内存,所有当前线程永远读到的是上一个线程执行完后的值

synchronized保证了原子性
因为当前线程永远拿到的是前一个线程修改后的值,所有这样也现象上实现了内存可见性,但是并没有真正对内存可见性做出技术上的处理。
synchronized没有保证有序性(不会禁止指令重排序)

e.关于synchronized的总结
  1. 被synchronized修身的代码块会编成串行执行
  2. synchronized可以修饰方法或者代码块
  3. 被修饰的代码并不是一次性在CPU执行完,而是中途可能会被CPU调度走,当所有指令执行完后才会释放锁
  4. 只给一个线程加锁,也会出现线程安全
f.不同锁对象的情况
  1. 同·一个引用调用(静态和非静态)两个方法(一个用synchronized修饰一个不用synchronized不修饰)只加一把锁
public static  int count;public  static void main(String[] args) {Counter_Demo1 counter = new Counter_Demo1();Thread t1 =new Thread(()->{for(int i=0;i<5_0000;i++){counter.count();}});Thread t2 =new Thread(()->{for(int i=0;i<5_0000;i++){counter.count1();}});t1.start();t2.start();try {t1.join();t2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Count: "+counter.count);}public  void count(){//修饰非静态代码块synchronized(this){count+=1;}}public  void count1(){{count+=1;}}
//修饰非静态方法    
//    public void synchronized count(){
//         {
//            count+=1;
//        }
//    }
//    public  void count1(){
//        {
//            count+=1;
//        }
//    }
修饰静态的方法和代码块
//    public static void count(){
//        //修饰代码块
//        //静态方法里面不能用this
//        synchronized(Counter_Demo1.class){
//            count+=1;
//        }
//    }
//    public static void count1(){
//        {
//            count+=1;
//        }
//    }
//    public synchronized static void count(){
//        //修饰代码块
//        //静态方法里面不能用this
//        {
//            count+=1;
//        }
//    }
//    public static void count1(){
//        {
//            count+=1;
//        }
//    }

执行结果
都不符合预期
在这里插入图片描述

  1. 两个引用调用同一个方法(锁对象是实例对象new)
 public static  int count;public  static void main(String[] args) {Counter_Demo1 counter1 = new Counter_Demo1();Counter_Demo1 counter2 = new Counter_Demo1();Thread t1 =new Thread(()->{for(int i=0;i<5_0000;i++){counter1.count();}});Thread t2 =new Thread(()->{for(int i=0;i<5_0000;i++){counter2.count();}});t1.start();t2.start();try {t1.join();t2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Count: "+counter1.count);}Object object=new Object();public void count(){synchronized (object){count+=1;}}

执行结果不符合预期
在这里插入图片描述
用类对象来加锁

static Object  object= new Object();public void count(){synchronized (object){count+=1;}}

执行结果符合预期
在这里插入图片描述
结论:

  1. 只要一个线程A获得锁,没有锁竞争
  2. 线程A和线程B共同抢一把锁,谁先拿到锁就先执行谁,另一个线程就要阻塞等待,等到持有锁的线程释放锁之后再竞争锁
  3. 线程A与线程B抢的不是同一把锁,它们之间没有竞争关系,分别去拿到自己的锁,不存在锁关系
g.如何判断多个线程竞争的是不是同一把锁
  1. 实例对象:new出来的对象,每个都是单独存在
  2. 类中的属性:类没有用static修饰的变量,每个实例对象都是不同的
  3. 类中的静态成员变量:用static修饰,属于类对象,全局唯一
  4. 类对象:.class文件加载jvm之后的对象,全局唯一
  5. 线程之间是否存在锁竞争,关键是看访问的是不是同一个锁对象,如果是则存在锁竞争,如果不是则不存在锁竞争
h.可重入锁
  • 对同一个锁对象和同一个线程,如果可以重复加锁,称之为不互斥,称之为可重入。
  • 对同一个锁对象和同一线程,如果不可以重复加锁,称之为互斥,就会形成死锁。
  • 已经获取锁对象的线程,如果再多次进行加锁操作,不会产生互斥现象
    在这里插入图片描述
I.锁对象
  • 锁对象记录了获取锁的线程信息
  • 任何对象都可以做锁对象
  • java中每个对象都是由以下几个部分组成:
    – 1.markword
    – 2.类型指针
    – 3.实例数据
    – 4.对齐填充
    – 5对象默认带线啊哦是16byte
    在这里插入图片描述
    在这里插入图片描述

Java 标准库中的线程安全类

不安全类

  • Arraylist
  • LinkedList
  • HashMap
  • TreeMap
  • HashSet
  • TreeSet
  • StringBuilder

安全类

-Vector(不推荐)

  • HashTable(不推荐)

  • CocurrentHashMap

  • StringBuffer

  • String (虽然没有加锁,但是不涉及修饰仍然是线程安全的)

volatile 关键字

解决线程安全的问题

  • 真正意义上解决了内存可见性
  • 解决了指令重排序(禁止指令重排序)问题
  • 没有解决原子性问题

内存可见性

  • 我们都知道,实际工作时候,访问的数据都是工作内存里面的数据,这样是为了保证效率,但是这样有时候会产生安全问题。但是加上 volatile , 强制读写内存. 速度是慢了, 但是数据变的更准确了
  • 代码在写⼊ volatile 修饰的变量的时候
    – 改变线程⼯作内存中volatile变量副本的值
    – 将改变后的副本的值从⼯作内存刷新到主内存
  • 代码在读取volatile修改的变量时候
    –从主内存中读取volatile变量的最新值到线程的⼯作内存中
    –从⼯作内存中读取volatile变量的副本

实例

static class Counter {public volatile int flag = 0;}public static void main(String[] args) {Counter counter = new Counter();Thread t1 = new Thread(() -> {while (counter.flag == 0) {// do nothing}System.out.println("循环结束!");});Thread t2 = new Thread(() -> {Scanner scanner = new Scanner(System.in);System.out.println("输⼊⼀个整数:");counter.flag = scanner.nextInt();});t1.start();t2.start();}
// 执⾏效果
// 当⽤⼾输⼊⾮0值时, t1 线程循环不会结束. (这显然是⼀个 bug)
//static class Counter {
//    public volatile int flag = 0;
//}
// 执⾏效果
// 当⽤⼾输⼊⾮0值时, t1 线程循环能够⽴即结束.

在这里插入图片描述

  • 对于线程t1来说,只是比较flag这个变量的值,从来都没有修改过,所有认为,这个值永远也不会改变,从而也不会重新从主内存中读取值(cpu为了提升高运行效率这个值一般存在寄存器或者cpu的缓存中)

  • 在多线程环境下,就会出现出现这个问题,一个线程修改了另一个线程无法感知到的变量

CPU层面保证可见性

MESI缓存 一致协议(可以理解是一种通知机制)
在这里插入图片描述

Java层面(保证指令顺序,从而保证内存可见性)

内存屏障:作用是保证指令执行的顺序,从而保证内存可见性
在这里插入图片描述
volatile写:
在这里插入图片描述
volatile读:
在这里插入图片描述
有序性:用volatile 修改过的变量,由于前后有内存屏障,保证了指令的执行顺序,也可以理解为告诉编译器,不要进行指令重排序。

总结

volatile不保证原子性

public static volatile int count;public synchronized static void main(String[] args) {Counter counter = new Counter();Thread t1 =new Thread(()->{for(int i=0;i<5_0000;i++){counter.count();}});Thread t2 =new Thread(()->{for(int i=0;i<5_0000;i++){counter.count();}});t1.start();t2.start();try {t1.join();t2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Count: "+counter.count);}public  void count(){count+=1;}

在这里插入图片描述

volatile保证可见性:MESI缓存 一致协议(可以理解是一种通知机制)
volatile保证有序性:内存屏障:作用是保证指令执行的顺序,从而保证内存可见性

wait() 和 notify()

wait和notify的基础知识

  • wait() 和notify(),notifyAll()是object方法
  • wait()/wait(long timeout):让线程进入等待的线程
  • notify()/notifyAll():唤醒在当前对象上等待的线程

wait()方法

  • wait做的事情
    – 使当前执行代码的线程进行等待(把线程放到等待队列中)
    – 释放当前锁
    – 满足一定条件被唤醒,尝试重新获得这个锁
    – wait要搭配sychronized来使用,脱离sychronized使用wait会之间抛出异常
  • wait 结束等待的条件:
    – 其他线程调用 调用该对象的notify方法
    – wait等待时间超时(wait ⽅法提供⼀个带有 timeout 参数的版本, 来指定等待时间)
    – 其他线程调用该等待线程的interrupted方法,导致wait抛出InterruptedException 异常.
  • wait()方法代码使用
public static void main(String[] args) throws InterruptedException {Object object = new Object();System.out.println("等待中");synchronized (object) {object.wait(1000);}System.out.println("等待结束");}这样在执⾏到object.wait()之后就⼀直等待下去,那么程序肯定不能⼀直这么等待下去了。这个时候就
需要使⽤到了另外⼀个⽅法唤醒的⽅法notify()

notify()⽅法

  • notify ⽅法是唤醒等待的线程.
    – 方法notify()也要在同步方法或者同步代码块中执行,该方法是用来通知哪些可能等待该对象的对象锁的其他线程,对其发出通知,并使它们重新获取该对象对象锁
    – 如果由多个线程等待,则有线程调度器随机挑选出一个呈现wait状态的线程。(并没有 “先来后到”))
    – 在notify()方法后,当前线程不会立马释放该对象锁,需要等到notify方法线程将程序执行完,也就是退出同步代码块之后才会释放锁对象。
  • 使用notify()方法唤醒线程
static class WaitTask implements Runnable  {private Object locker;public WaitTask(Object locker) {this.locker = locker;}@Overridepublic void run() {synchronized (locker){try {System.out.println("等待开始") ;locker.wait();System.out.println("等待结束");} catch (InterruptedException e) {e.printStackTrace();}}}}static class NotifyTask implements Runnable {private Object locker;public NotifyTask(Object locker) {this.locker = locker;}@Overridepublic void run() {synchronized (locker) {System.out.println("notify 开始");locker.notify();System.out.println("notify 结束");}}}public static void main(String[] args) throws InterruptedException {Object locker = new Object();Thread t1 = new Thread(new WaitTask(locker));Thread t2 = new Thread(new NotifyTask(locker));t1.start();Thread.sleep(1000);t2.start();}

notifyAll()⽅法

  • notify⽅法只是唤醒某⼀个等待线程. 使⽤notifyAll⽅法可以⼀次唤醒所有的等待线程.
 static class WaitTask implements Runnable {private Object locker;public WaitTask(Object locker) {this.locker = locker;}@Overridepublic void run() {synchronized (locker) {try {System.out.println("等待开始");locker.wait();System.out.println("等待结束");} catch (InterruptedException e) {e.printStackTrace();}}}}static class NotifyTask implements Runnable {private Object locker;public NotifyTask(Object locker) {this.locker = locker;}@Overridepublic void run() {synchronized (locker) {System.out.println("notify 开始");locker.notifyAll();System.out.println("notify 结束");}}}public static void main(String[] args) throws InterruptedException {Object locker = new Object();Thread t1 = new Thread(new WaitTask(locker));Thread t3 = new Thread(new WaitTask(locker));Thread t4 = new Thread(new WaitTask(locker));Thread t2 = new Thread(new NotifyTask(locker));t1.start();t3.start();t4.start();sleep(1000);t2.start();}}

注意: 虽然是同时唤醒 3 个线程, 但是这 3 个线程需要竞争锁. 所以并不是同时执⾏, ⽽仍然是有先有后的执⾏

wait 和 sleep和join的对⽐(⾯试题)

  1. wait需要搭配synchronized使用 sleep,join不需要
  2. wait是Object的方法,sleep是Thread的静态方法,join是类中的方法(实例方法)
  3. 一个是用于线程之间的通信的,两个是让线程阻塞一段时间
  4. 相同点:可以让线程放弃执行一段时间

wait和notify的总结

在这里插入图片描述

  • join和wait是两个不同的操作
    –join是Thread类中的方法
    – wait和notify是Object类中的方法
    – join状态,主线程要等待子线程的结果
    – wait是等待另一个线程的资源
  • wait和notify必须跟synchronized一起使用,并且使用同一个对象
    – 否则会报错
    在这里插入图片描述
    – wait的线程进入阻塞状态,调用wait的线程会释放自己持有的锁(不再占有cpu资源)
  • notify()和notifyAll(),
    – notify随机唤醒一个线程,notifyAll唤醒所有线程,唤醒后的线程需要重新去竞争锁,拿到锁之后wait位置的代码才会继续执行。
  • 使用小结
    – wait和notify必须搭配synchronized一起使用
    – wait和notify使用的锁对象必须是同一个
    – notify执行多少次都没有关系(及时没有wait)(类似老板把包子做好空喊了一声)
  • 举例:
    – 现实举例:在这里插入图片描述
    – 指令举例
    在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/web/62364.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

【力扣】409.最长回文串

问题描述 思路解析 因为同时包含大小写字母&#xff0c;直接创建个ASCII表大小的桶来标记又因为是要回文子串&#xff0c;所以偶数个数的一定可以那么同时&#xff0c;对于出现奇数次数的&#xff0c;我没需要他们的次数-1&#xff0c;变为偶数&#xff0c;并且可以标记出现过…

计算机视觉在科学研究(数字化)中的实际应用

计算机视觉是一种利用计算机技术来解析和理解图像和视频的方法。.随着计算机技术的不断发展&#xff0c;计算机视觉被广泛应用于科学研究领域&#xff0c;为科学家提供了无限的可能。 一、生命科学领域 在生命科学领域&#xff0c;计算机视觉被广泛用于图像识别、分类和测量等…

springboot381银行客户管理系统(论文+源码)_kaic

摘 要 伴随着信息技术与互联网技术的不断发展&#xff0c;人们进到了一个新的信息化时代&#xff0c;传统管理技术性没法高效率、容易地管理信息内容。为了实现时代的发展必须&#xff0c;提升管理高效率&#xff0c;各种各样管理管理体系应时而生&#xff0c;各个领域陆续进到…

软件漏洞印象

软件漏洞印象 软件安全性检测 软件安全静态分析&#xff1a;学术界一度十分热衷的偏理论性方法软件漏洞动态挖掘&#xff0c;工程界普遍采用动态漏洞挖掘方式&#xff0c;即Fuzz技术&#xff0c;也称为模糊测试 漏洞利用 vs. 漏洞修复 对于已发现的软件漏洞 黑客会基于Meta…

计算机网络 —— HTTPS 协议

前一篇文章&#xff1a;计算机网络 —— HTTP 协议&#xff08;详解&#xff09;-CSDN博客 目录 前言 一、HTTPS 协议简介 二、HTTPS 工作过程 1.对称加密 2.非对称加密 3.中间人攻击 4.引入证书 三、HTTPS 常见问题 1.中间人能否篡改证书&#xff1f; 2.中间人能否调…

定点数的乘除运算

原码一位乘法 乘积的符号由两个数的符号位异或而成。&#xff08;不参与运算&#xff09;被乘数和乘数均取绝对值参与运算&#xff0c;看作无符号数。乘数的最低位为Yn&#xff1a; 若Yn1&#xff0c;则部分积加上被乘数|x|&#xff0c;然后逻辑右移一位&#xff1b;若Yn0&…

数据挖掘:一、Weka软件的基本操作

实验目的和要求 了解Weka软件的使用 实验环境 Windows11 Weka3.8.6 实验内容与过程 实验内容 1、了解Weka使用的一般步骤 2、利用Weka,对数据集进行关联规则挖掘及数据分类 3、记录操作步骤、使用的数据、最终的结果 实验过程 首先打开weka下载官网,选择合适

【从零开始的LeetCode-算法】383. 赎金信

给你两个字符串&#xff1a;ransomNote 和 magazine &#xff0c;判断 ransomNote 能不能由 magazine 里面的字符构成。 如果可以&#xff0c;返回 true &#xff1b;否则返回 false 。 magazine 中的每个字符只能在 ransomNote 中使用一次。 示例 1&#xff1a; 输入&#…

【第二十四周】从大语言模型到多模态大模型的发展

摘要 大语言模型&#xff08;Large Language Model, LLM&#xff09;是指一类基于深度学习的人工智能系统&#xff0c;它们被设计用来理解和生成自然语言。这些模型通常是在大量的文本数据上进行训练的&#xff0c;通过学习文本中的模式和结构&#xff0c;它们能够执行各种各样…

https ssl免费证书申请,自动续期,acme、certd

本文为个人笔记&#xff0c;方便自己需要时查阅&#xff0c;同时提供出来给大家作为免费ssl证书自动续签需求的一种参考 大部分免费证书的有效期仅有3个月&#xff0c;所以证书管理会涉及到自动续期管理的问题 一、acme证书 大佬们常用的证书证书申请管理方式&#xff0c;提…

【计算机网络】实验13:运输层端口

实验13 运输层端口 一、实验目的 本次实验旨在验证TCP和IP运输层端口号的作用&#xff0c;深入理解它们在网络通信中的重要性。通过实验&#xff0c;我将探讨端口号如何帮助区分不同的应用程序和服务&#xff0c;使得在同一台主机上能够同时运行多个网络服务而不发生冲突。此…

【Redis】Redis基础——Redis的安装及启动

一、初识Redis 1. 认识NoSQL 数据结构&#xff1a;对于SQL来说&#xff0c;表是有结构的&#xff0c;如字段约束、字段存储大小等。 关联性&#xff1a;SQL 的关联性体现在两张表之间可以通过外键&#xff0c;将两张表的数据关联查询出完整的数据。 查询方式&#xff1a; 2.…

ElK 8 收集 MySQL 慢查询日志并通过 ElastAlert2 告警至飞书

文章目录 1. 说明2. 启个 mysql3. 设置慢查询4. filebeat 设置5. 触发慢查询6. MySQL 告警至飞书 1. 说明 elk 版本&#xff1a;8.15.0 2. 启个 mysql docker-compose.yml 中 mysql&#xff1a; mysql:# restart: alwaysimage: mysql:8.0.27# ports:# - "3306:3306&q…

【服务器监控】grafana+Prometheus+node exporter详细部署文档

我们在进行测试时&#xff0c;不可能一直手动看着服务器的性能消耗&#xff0c;这时候就需要有个工具替我们监控服务器的性能消耗。这里记录下grafanaPrometheusnodeExporter的组合用于监控服务器。 简单介绍&#xff1a; grafana&#xff1a;看板工具&#xff0c;所有采集的…

第十七章 使用 MariaDB 数据库管理系统

1. 数据库管理系统 数据库是指按照某些特定结构来存储数据资料的数据仓库。在当今这个大数据技术迅速崛起的年代&#xff0c;互联网上每天都会生成海量的数据信息&#xff0c;数据库技术也从最初只能存储简单的表格数据的单一集中存储模式&#xff0c;发展到了现如今存储海量…

计算机键盘的演变 | 键盘键名称及其功能 | 键盘指法

注&#xff1a;本篇为 “键盘的演变及其功能” 相关几篇文章合辑。 英文部分机翻未校。 The Evolution of Keyboards: From Typewriters to Tech Marvels 键盘的演变&#xff1a;从打字机到技术奇迹 Introduction 介绍 The keyboard has journeyed from a humble mechanical…

Methods and Initializers

1 Method Declarations 这回不从comipler开始&#xff0c;从runtime开始。 GC也需要follow 接下来难点在于如何填充这些表 2 Compiling method declarations 难点&#xff1a; 一个类可以声明任意数量的方法。运行时需要查找并绑定所有这些方法。如果将这些方法都打包到一条…

飞飞5.4游戏源码(客户端+服务端+工具完整源代码+5.3fix+5.4patch+数据库可编译进游戏)

飞飞5.4游戏源码&#xff08;客户端服务端工具完整源代码5.3fix5.4patch数据库可编译进游戏&#xff09; 下载地址&#xff1a; 通过网盘分享的文件&#xff1a;【源码】飞飞5.4游戏源码&#xff08;客户端服务端工具完整源代码5.3fix5.4patch数据库可编译进游戏&#xff09; 链…

开源C代码之路:一、Gitee

开源c代码之路&#xff1a;一&#xff0c;Gitee 前言1、开源项目2、从哪里找&#xff1f;3、举个例子4、总结&#xff1a; 本系列回顾清单开源代码示例 前言 从开源开发的角度&#xff0c;由浅入深&#xff0c;一步步初探C语言编程的入门之路。 本篇讲解&#xff1a;Gitee 1…

基于协同过滤算法的宠物用品商城的设计与实现(计算机毕业设计)Java Spring 衍生为任何商城系统 毕业论文

系统合集跳转 源码获取链接 一、系统环境 运行环境: 最好是java jdk 1.8&#xff0c;我们在这个平台上运行的。其他版本理论上也可以。 IDE环境&#xff1a; Eclipse,Myeclipse,IDEA或者Spring Tool Suite都可以 tomcat环境&#xff1a; Tomcat 7.x,8.x,9.x版本均可 操作系统…