RabbitMQ-API

这里写目录标题

  • Hello word 模式
    • 添加依赖
    • 生产者
    • 消费者
    • 获取信道工具类
  • Work Queues模式
    • 消费者代码 C1
    • 开启多线程运行
    • 启动 消费者代码 C2
    • 生产者代码
  • 消息应答
    • 自动应答
    • 消息应答的方法
    • Multiple 的解释
    • 消息自动重新入队
    • 消息手动应答代码
    • 消费者API
  • 队列持久化
  • 消息持久化
  • 不公平分发
  • 消息预取值
  • 确认发布
    • 单个确认发布
    • 批量确认发布
    • 异步批量确认发布
    • 如何处理异步未确认消息

Hello word 模式

“ P”是我们的生产者，“ C”是我们的消费者。中间的框是一个队列-RabbitMQ 代表使用者保留的消息缓冲区
在这里插入图片描述

添加依赖

<!--rabbitmq 依赖客户端-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.8.0</version>
        </dependency>
        <!--操作文件流的一个依赖-->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>

生产者

package com.wlj.rabbitmq.one;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.wlj.rabbitmq.util.MQUtil;

import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
 *@创建人 wlj
 *@创建时间 2023/7/20
 *@描述 消息生产者 Hello World简单队列模式
 */
public class Producer {
    private static String QUEUE_NAME="hello";
    public static void main(String[] args) {
        //创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //工厂IP连接MQ的队列
        factory.setHost("localhost");
        //设置用户名
        factory.setUsername("guest");
        factory.setPassword("guest");

        try {
            //创建连接
            Connection connection = factory.newConnection();
            //获取信道
            Channel channel = connection.createChannel();
            //生成一个队列
            /**
             * 生成一个队列
             * 1.队列名称
             * 2.队列里面的消息是否持久化 默认消息存储在内存中
             * 3.该队列是否只供一个消费者进行消费 是否进行共享 true 可以多个消费者消费
             * 4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除 true 自动删除
             * 5.其他参数
             */
            channel.queueDeclare(QUEUE_NAME,false,false,false,null);
            String message="hello world2";
            /**
             * 发送一个消息
             * 1.发送到那个交换机
             * 2.路由的 key 是哪个
             * 3.其他的参数信息
             * 4.发送消息的消息体
             */
            channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
            System.out.println("消息发送完毕");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }

}

消费者

package com.wlj.rabbitmq.one;

import com.rabbitmq.client.*;
/**
 *@创建人 wlj
 *@创建时间 2023/7/20
 *@描述 消息消费者 Hello World简单队列模式
 */
public class Consumer {
    private static String QUEUE_NAME="hello";
    public static void main(String[] args) {
        //创建有一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //工厂IP连接MQ的队列
        factory.setHost("localhost");
        //设置用户名
        factory.setUsername("guest");
        factory.setPassword("guest");
        //创建连接
        try {
            Connection connection = factory.newConnection();
            //获取信道
            Channel channel = connection.createChannel();
            /**
             *消费者消费消息
             * 1.消费那个队列
             * 2. 消费成功之后 是否手动应答 true 自动应答 false 手动应答
             * 3.消费者成功消费的回调
             * 4. 消费者取消消费的回调
             */

            //接收消息
            DeliverCallback deliverCallback=(conusmerTag,message)->{
                System.out.println("消费的消息======="+ new String( message.getBody()));
            };
            //取消接收消息的回调
            CancelCallback cancelCallback =(e)->{
                System.out.println("消费消息被中断=======");
            };
            channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

获取信道工具类

package com.wlj.rabbitmq.util;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @创建人 wlj
 * @创建时间 2023/7/19
 * @描述 连接MQ获取信道工具类
 */
public class MQUtil {
    public static  Channel    getMQ( ) {
        //创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //工厂IP连接MQ的队列
        factory.setHost("localhost");
        //设置用户名
        factory.setUsername("guest");
        factory.setPassword("guest");

        try {
            //创建连接
            Connection connection = factory.newConnection();
            //获取信道
            Channel channel = connection.createChannel();
           return channel;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        return null;
    }

}

Work Queues模式

在这里插入图片描述

一个生产者对应多个消费者。每个消费者是竞争关系，一个消息只能被一个消费者消费

消费者代码 C1

package com.wlj.rabbitmq.two;

import com.rabbitmq.client.Channel;
import com.wlj.rabbitmq.util.MQUtil;

import java.io.IOException;

/**
 *@创建人 wlj
 *@创建时间 2023/7/20
 *@描述 这是一个工作线程 也是一个消费者
 */
public class WorkerConsumer {
    private static String QUEUE_NAME="hello";

    public static void main(String[] args) {
        Channel channel = MQUtil.getMQ();
        System.out.println("C1");
        //消息的接收
        try {
            channel.basicConsume(QUEUE_NAME,true,(tag,msg)->{
                System.out.println("消费的消息====="+ new String(msg.getBody()));
            },e->{
                System.out.println("消费取消");
            });
        } catch (IOException e) {


        }
    }
}

开启多线程运行

在这里插入图片描述

启动 消费者代码 C2

只需要更改输出语句即可

System.out.println("C2");

生产者代码

从控制台输入 发送消息

package com.wlj.rabbitmq.two;

import com.rabbitmq.client.*;
import com.wlj.rabbitmq.util.MQUtil;

import java.util.Scanner;

/**
 *@创建人 wlj
 *@创建时间 2023/7/20
 *@描述 消息消费者 工作线程模式
 */
public class WorkerProducer {
    private static String QUEUE_NAME="hello";
    public static void main(String[] args) {
        Channel channel = MQUtil.getMQ();
        try {
 channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            //从控制台当中接受信息
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNext()){
                String message = scanner.next();
                /**
                 * 生成一个队列
                 * 1.队列名称
                 * 2.队列里面的消息是否持久化 默认消息存储在内存中
                 * 3.该队列是否只供一个消费者进行消费 是否进行共享 true 可以多个消费者消费
                 * 4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除 true 自动删除
                 * 5.其他参数
                 */
                channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
                System.out.println("发送消息完成:"+message);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

启动C1、C2和生产者进行测试

消息应答

消费者完成一个任务可能需要一段时间，如果其中一个消费者处理一个长的任务并仅只完成
了部分突然它挂掉了，会发生什么情况。RabbitMQ 一旦向消费者传递了一条消息，便立即将该消
息标记为删除。在这种情况下，突然有个消费者挂掉了，我们将丢失正在处理的消息。以及后续
发送给该消费这的消息，因为它无法接收到。
为了保证消息在发送过程中不丢失，rabbitmq 引入消息应答机制，消息应答就是:消费者在接
收到消息并且处理该消息之后，告诉 rabbitmq 它已经处理了，rabbitmq 可以把该消息删除了。

自动应答

消息发送后立即被认为已经传送成功，这种模式需要在高吞吐量和数据传输安全性方面做权
衡,因为这种模式如果消息在接收到之前，消费者那边出现连接或者 channel 关闭，那么消息就丢
失了,当然另一方面这种模式消费者那边可以传递过载的消息，没有对传递的消息数量进行限制，
当然这样有可能使得消费者这边由于接收太多还来不及处理的消息，导致这些消息的积压，最终
使得内存耗尽，最终这些消费者线程被操作系统杀死，所以这种模式仅适用在消费者可以高效并
以某种速率能够处理这些消息的情况下使用。

消息应答的方法

  • Channel.basicAck(用于肯定确认)
    RabbitMQ 已知道该消息并且成功的处理消息，可以将其丢弃了
  • Channel.basicNack(用于否定确认)
  • Channel.basicReject(用于否定确认)
    与 Channel.basicNack 相比少一个参数
    不处理该消息了直接拒绝，可以将其丢弃了

Multiple 的解释

手动应答的好处是可以批量应答并且减少网络拥堵
在这里插入图片描述

multiple 的 true 和 false 代表不同意思
true 代表批量应答 channel 上未应答的消息
比如说 channel 上有传送 tag 的消息 5,6,7,8 当前 tag 是 8 那么此时
5-8 的这些还未应答的消息都会被确认收到消息应答
false 同上面相比
只会应答 tag=8 的消息 5,6,7 这三个消息依然不会被确认收到消息应答

消息自动重新入队

如果消费者由于某些原因失去连接(其通道已关闭，连接已关闭或 TCP 连接丢失)，导致消息
未发送 ACK 确认，RabbitMQ 将了解到消息未完全处理，并将对其重新排队。如果此时其他消费者
可以处理，它将很快将其重新分发给另一个消费者。这样，即使某个消费者偶尔死亡，也可以确
保不会丢失任何消息。
在这里插入图片描述

消息手动应答代码

默认消息采用的是自动应答，所以我们要想实现消息消费过程中不丢失，需要在接收消息是把自动应答改
为手动应答。之后需要在消息处理完成之后进行手动应答

消费者API

** 首先是消费消息时，取消自动应答**
消费消息完成时，进行手动应答

package com.wlj.rabbitmq.two;

import com.rabbitmq.client.Channel;
import com.wlj.rabbitmq.util.MQUtil;

import java.io.IOException;

/**
 *@创建人 wlj
 *@创建时间 2023/7/20
 *@描述 这是一个工作线程 也是一个消费者
 */
public class WorkerConsumer {
    private static String QUEUE_NAME="hello";

    public static void main(String[] args) {
        Channel channel = MQUtil.getMQ();
        System.out.println("C2");
        //消息的接收
        try {
            /**
             *消费者消费消息
             * 1.消费那个队列
             * 2. 消费成功之后 是否手动应答 true 自动应答 false 手动应答
             * 3.消费者成功消费的回调
             * 4. 消费者取消消费的回调
             */
            //取消自动应答
            channel.basicConsume(QUEUE_NAME,false,(tag,msg)->{
                System.out.println("消费的消息====="+ new String(msg.getBody()));
                //进行手动应答 参数一：消息标记tag ，参数二：false代表只应答接收到的那个传递的消息。true代表为应答所有消息包括传递过来的消息
                channel.basicAck(msg.getEnvelope().getDeliveryTag(),true);
            },e->{
                System.out.println("消费取消");
            });
        } catch (IOException e) {


        }
    }
}

队列持久化

队列为开启持久化时。MQ重启队列就会被删除掉，如果想要队列实现持久化，需要在声明队列的时候吧durable参数设置为持久化（true）

 boolean durable =true;
  channel.queueDeclare(QUEUE_NAME,durable,false,false,null);

需要注意的是,如果之前生声明的队列不是持久化的,需要把原来的队列删除之后,重新声明持久化队列
查看mq队列列表，出现D就是持久化成功
在这里插入图片描述

消息持久化

要想让消息实现持久化需要在消息生产者修改代码,，MessageProperties.PERSISTENT_TEXT_PLAIN 添
加这个属性 可以理解为告诉队列把消息实现持久化保存到磁盘上

 boolean durable =true;
            channel.queueDeclare(QUEUE_NAME,durable,false,false,null);
            String message="hello world2";
            /**
             * 发送一个消息
             * 1.发送到那个交换机
             * 2.路由的 key 是哪个
             * 3.其他的参数信息
             * 4.发送消息的消息体
             */
            channel.basicPublish("",QUEUE_NAME,MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());

将消息标记为持久化并不能完全保证不会丢失消息。尽管它告诉 RabbitMQ 将消息保存到磁盘，但是
这里依然存在当消息刚准备存储在磁盘的时候 但是还没有存储完，消息还在缓存的一个间隔点。此时并没
有真正写入磁盘。持久性保证并不强，但是对于我们的简单任务队列而言，这已经绰绰有余了。如果需要
更强有力的持久化策略，参考MQ的发布确认。

不公平分发

MQ默认是采用轮询的方式分发消息，但是有的消费者处理很慢，就会导致消息积压，可以设置不公平分发，消费者进行应答之后，才会接收下一条消息

生产者代码无变动

package com.wlj.rabbitmq.bugongpingfenfa;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;

import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;

/**
 *@创建人 wlj
 *@创建时间 2023/7/20
 *@描述 消息生产者 Hello World简单队列模式
 */
public class Producer {
    private static String QUEUE_NAME="hello3";
    public static void main(String[] args) {
        //创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //工厂IP连接MQ的队列
        factory.setHost("localhost");
        //设置用户名
        factory.setUsername("guest");
        factory.setPassword("guest");

        try {
            //创建连接
            Connection connection = factory.newConnection();
            //获取信道
            Channel channel = connection.createChannel();
            //生成一个队列
            /**
             * 生成一个队列
             * 1.队列名称
             * 2.队列里面的消息是否持久化 默认消息存储在内存中
             * 3.该队列是否只供一个消费者进行消费 是否进行共享 true 可以多个消费者消费
             * 4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除 true 自动删除
             * 5.其他参数
             */
            //从控制台当中接受信息
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNext()) {
                String message = scanner.next();
               //发布消息
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
                System.out.println("发送消息完成:" + message);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }

}

消费者代码 在消息消费之前 channel.basicQos(1); 同时开通了手动应答，手动应答应该先启动消费者，在启动生产者

package com.wlj.rabbitmq.bugongpingfenfa;

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.wlj.rabbitmq.util.MQUtil;
import com.wlj.rabbitmq.util.ThreadSleep;

import java.io.IOException;

/**
 *@创建人 wlj
 *@创建时间 2023/7/20
 *@描述 进行不公平分发测试，处理慢的消费者接受的消息少，处理快的消费者处理的消息多
 */
public class WorkerConsumer {
    private static String QUEUE_NAME="hello3";

    public static void main(String[] args) {
        Channel channel = MQUtil.getMQ();

        System.out.println("50秒消费的消息=====");        //消息的接收
        try {
             channel.basicQos(1);
            /**
             *消费者消费消息
             * 1.消费那个队列
             * 2. 消费成功之后 是否手动应答 true 自动应答 false 手动应答
             * 3.消费者成功消费的回调
             * 4. 消费者取消消费的回调
             */
            //接收消息
            DeliverCallback deliverCallback=(conusmerTag, message)->{
                System.out.println("消费的消息======="+ new String( message.getBody()));
                ThreadSleep.sleep(50000);
                 channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
                System.out.println("应答结束");
            };
            //取消接收消息的回调
            CancelCallback cancelCallback =(e)->{
                System.out.println("消费消息被中断=======");
            };
            channel.basicConsume(QUEUE_NAME,false,deliverCallback,cancelCallback);
        } catch (IOException e) {


        }
    }
}

进行测试

  • 启动消费者一，获取消息之后，睡眠十秒再应答。
  • 启动消费者二，获取消息之后，睡眠二十秒再应答。
  • 启动生产者
  • 测试发送第一条消息，由第一个消费者消费。再发送第二条消息，此时消费者二是空闲的，所以消费者二消费消息
  • 发送第三条数据，如果第一个消费者十秒结束，进行应答，那么会得到第三条消息。如果没有进行应答，则不能接收到消息
    所以得出结论，不公平分发，是消费者消息处理完应答之后，才会接收到下一条消息

消息预取值

确认发布

这是一种简单的确认方式。他是一种同步确认发布的方式，也就是发布一个消息之后，只有它被确认发布，后续的消息才能被发布。waitForCnfirmsOrDie(long)这个方法只有在消息被确认的时候才返回，如果指定时间内没有被确认，则会抛出异常

单个确认发布

生产者API
需要使用 信道开启发布确认

package com.wlj.rabbitmq.three;

import com.rabbitmq.client.Channel;
import com.wlj.rabbitmq.util.MQUtil;

import java.util.Scanner;

/**
 * @创建人 wlj
 * @创建时间 单个发布确认模式
 * @描述
 */
public class ComfirmSelecr {
    private static String QUEUE_NAME = "confirms";

    public static void main(String[] args) {
        Channel channel = MQUtil.getMQ();
      
        try {
          //开启发布确认
            channel.confirmSelect();
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);

            long l = System.currentTimeMillis();
            for (int i = 0; i < 1000; i++) {
            	//发送消息
                channel.basicPublish("", QUEUE_NAME, null, (i+"").getBytes());
                System.out.println("发布确认模式:" + i);
                boolean b = channel.waitForConfirms(1000);
                if (b) {
                    System.out.println("发布成功");
                }
            }
            long l1 = System.currentTimeMillis();
            System.out.println("发布时长= === " + (l1 - l));

        } catch (
                Exception e) {
            e.printStackTrace();
        }
    }
}

批量确认发布

package com.wlj.rabbitmq.three;

import com.rabbitmq.client.Channel;
import com.wlj.rabbitmq.util.MQUtil;

/**
 * @创建人 wlj
 * @创建时间 批量发布确认模式
 * @描述
 */
public class BatchComfirmSelecr {
    private static String QUEUE_NAME = "confirms";

    public static void main(String[] args) {
        Channel channel = MQUtil.getMQ();
        //开启发布确认
        try {
            channel.confirmSelect();
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);

            long l = System.currentTimeMillis();
            for (int i = 0; i < 1000; i++) {


                /**
                 * 生成一个队列
                 * 1.队列名称
                 * 2.队列里面的消息是否持久化 默认消息存储在内存中
                 * 3.该队列是否只供一个消费者进行消费 是否进行共享 true 可以多个消费者消费
                 * 4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除 true 自动删除
                 * 5.其他参数
                 */
                channel.basicPublish("", QUEUE_NAME, null, (i + "").getBytes());
                System.out.println("发布确认模式:" + i);
                // 每一百个一次确认发布
                if (i % 100 == 0) {
                    boolean b = channel.waitForConfirms(1000);
                    if (b) {
                        System.out.println("发布成功");
                    }
                }

            }
            long l1 = System.currentTimeMillis();
            System.out.println("发布时长= === " + (l1 - l));

        } catch (
                Exception e) {
            e.printStackTrace();
        }
    }
}

异步批量确认发布

需要添加添加一个异步确认的监听器 处理已被处理的消息或者是未被处理的消息 channel.addConfirmListener(ackCallback, nackCallback);

package com.wlj.rabbitmq.three;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmCallback;
import com.wlj.rabbitmq.util.MQUtil;

import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;

/**
 * @创建人 wlj
 * @创建时间 批量发布确认模式
 * @描述
 */
public class SyncBatchComfirmSelecr {
    private static String QUEUE_NAME = "confirms";

    public static void main(String[] args) {
        Channel channel = MQUtil.getMQ();
        //开启发布确认
        try {
            channel.confirmSelect();
            /**
             * 线程安全有序的一个哈希表，适用于高并发的情况
             * 1.轻松的将序号与消息进行关联
             * 2.轻松批量删除条目 只要给到序列号
             * 3.支持并发访问
             */
            ConcurrentSkipListMap<Long, String> outstandingConfirms = new
                    ConcurrentSkipListMap<>();
            /**
             * 确认收到消息的一个回调
             * 1.消息序列号
             * 2.true 可以确认小于等于当前序列号的消息
             * false 确认当前序列号消息
             */
            ConfirmCallback ackCallback = (sequenceNumber, multiple) -> {
                String message = outstandingConfirms.get(sequenceNumber);
                System.out.println("发布的消息---------------" + message + "已被确认，序列号" + sequenceNumber);
                //是否是批量确认
                if (multiple) {
                    //返回的是小于等于当前序列号的未确认消息 是一个 map
                    ConcurrentNavigableMap<Long, String> confirmed =
                            outstandingConfirms.headMap(sequenceNumber, true);
                    //清除该部分未确认消息
                    confirmed.clear();
                } else {
                    //只清除当前序列号的消息
                    outstandingConfirms.remove(sequenceNumber);
                }
            };


            ConfirmCallback nackCallback = (sequenceNumber, multiple) -> {
                String message = outstandingConfirms.get(sequenceNumber);
                System.out.println("发布的消息*************" + message + "未被确认，序列号" + sequenceNumber);
            };
            /**
             * 添加一个异步确认的监听器
             * 1.确认收到消息的回调
             * 2.未收到消息的回调
             */
            //  channel.addConfirmListener(ackCallback, null);
            channel.addConfirmListener(ackCallback, nackCallback);

            channel.queueDeclare(QUEUE_NAME, false, false, false, null);

            long l = System.currentTimeMillis();
            for (int i = 0; i < 1000; i++) {
                String message = "消息" + i;
                /**
                 * channel.getNextPublishSeqNo()获取下一个消息的序列号
                 * 通过序列号与消息体进行一个关联
                 * 全部都是未确认的消息体
                 */
                outstandingConfirms.put(channel.getNextPublishSeqNo(), message);

                /**
                 * 生成一个队列
                 * 1.队列名称
                 * 2.队列里面的消息是否持久化 默认消息存储在内存中
                 * 3.该队列是否只供一个消费者进行消费 是否进行共享 true 可以多个消费者消费
                 * 4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除 true 自动删除
                 * 5.其他参数
                 */
                channel.basicPublish("", QUEUE_NAME, null, (i + "").getBytes());



            }
            long l1 = System.currentTimeMillis();
            System.out.println("异步批量确认发布时长= === " + (l1 - l));

        } catch (
                Exception e) {
            e.printStackTrace();
        }
    }
}

如何处理异步未确认消息

最好的解决的解决方案就是把未确认的消息放到一个基于内存的能被发布线程访问的队列，
比如说用 ConcurrentLinkedQueue 这个队列在 confirm callbacks 与发布线程之间进行消息的传
递.上面代码就是用了此方法,发消息是进行记录,在未确认回调函数里面进行处理

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

一文带你深入了解JMM（Java内存模型）

一文带你深入了解JMM（Java内存模型）

JMM&#xff08;Java内存模型&#xff09;详解 为什么要有内存模型&#xff1f; 要想回答这个问题&#xff0c;我们需要先弄懂传统计算机硬件内存架构。 硬件内存架构 &#xff08;1&#xff09;CPU 去过机房的同学都知道&#xff0c;一般在大型服务器上会配置多个CPU&…
阅读更多...
edge://settings/defaultbrowser default ie

edge://settings/defaultbrowser default ie

Microsoft Edge 中的 Internet Explorer 模式 有些网站专为与 Internet Explorer 一起使用&#xff0c;它们具有 Microsoft Edge 等新式浏览器不支持的功能。 如果你需要查看其中的某个网站&#xff0c;可使用 Microsoft Edge 中的 Internet Explorer 模式。 大多数网站在新…
阅读更多...
数据库数据恢复-Oracle数据库文件出现坏块的数据恢复案例

数据库数据恢复-Oracle数据库文件出现坏块的数据恢复案例

Oracle数据库故障&初检&分析&#xff1a; 打开Oracle数据库时报错&#xff0c;报错信息&#xff1a;“system01.dbf需要更多的恢复来保持一致性&#xff0c;数据库无法打开”。用户急需恢复zxfg用户下的数据。 出现上述报错的可能原因包括&#xff1a;控制文件损坏、数…
阅读更多...
微信小程序如何引入Iconfont

微信小程序如何引入Iconfont

在小程序中引入 Iconfont 可以通过以下步骤进行操作&#xff1a; 打开 Iconfont 网站&#xff08;https://www.iconfont.cn/&#xff09;并登录账号&#xff0c;创建一个项目并添加所需的图标到项目中。 在项目中选中需要使用的图标&#xff0c;点击右上角的 “下载代码” 按钮…
阅读更多...
TBB库中实现协程(coroutine)的源码说明

TBB库中实现协程(coroutine)的源码说明

源码请见: https://github.com/oneapi-src/oneTBB/blob/master/src/tbb/co_context.h 在windows系统&#xff0c;TBB(也就是intel 的 oneTBB库)&#xff0c;通过windwos fiber(纤程)来实现协程(coroutine)。 创建一个协程,代码很简洁: inline void create_coroutine(corouti…
阅读更多...
接口测试—知识速查（Postman）

接口测试—知识速查（Postman）

文章目录 接口测试1. 概念2. 原理3. 测试流程4. HTTP协议4.1 URL的介绍4.2 HTTP请求4.2.1 请求行4.2.2 请求头4.2.3 请求体4.2.4 完整的HTTP请求示例 4.3 HTTP响应4.3.1 状态行4.3.2 响应头4.3.3 响应体4.3.4 完整的HTTP请求示例 5. RESTful接口规范6. 测试用例的设计思路6.1 单…
阅读更多...
Spring boot 集成 Skywalking 配置 || Skywalking 打不开【已解决】

Spring boot 集成 Skywalking 配置 || Skywalking 打不开【已解决】

一、Skywalking官网 Apache SkyWalking 1.下载Skywalking APM &#xff08;如果下载最新的&#xff0c;双击打开闪退&#xff0c;选老点的版本&#xff09; 2. 下载 Skywalking Agents 如果下载太慢&#xff0c;建议复制下载链接&#xff0c;然后用下载器下载&#xff0c;比…
阅读更多...
BeanFactory和ApplicationContext容器

BeanFactory和ApplicationContext容器

1.BeanFactory容器 在Spring容器中&#xff0c;BeanFactory是IOC容器中的最顶级的接口&#xff0c;是最基础的版本&#xff0c;里面定义了管理bean的基本方法&#xff0c;如&#xff1a;获取bean、判断是否存在等等方法。 BeanFactory下面有很多的实现类&#xff0c;各有职责&…
阅读更多...
js：使用LetterAvatar通过canvas实现浏览器中生成字母头像

js：使用LetterAvatar通过canvas实现浏览器中生成字母头像

实现效果 LetterAvatar的原理就是利用了浏览器对象canvas 在线体验&#xff1a;https://mouday.github.io/tools/pages/letter-avatar/index.html LetterAvatar.js 完整代码 /** LetterAvatar* * Artur Heinze* Create Letter avatar based on Initials* based on https:/…
阅读更多...
保留网络：大型语言模型的Transformer继任者

保留网络：大型语言模型的Transformer继任者

原文信息 原文题目&#xff1a;《Retentive Network: A Successor to Transformer for Large Language Models》 原文引用&#xff1a;Sun Y, Dong L, Huang S, et al. Retentive Network: A Successor to Transformer for Large Language Models[J]. arXiv preprint arXiv:2…
阅读更多...
装饰器模式（C++）

装饰器模式（C++）

定义 动态(组合)地给一个对象增加一些额外的职责。就增加功能而言&#xff0c;Decorator模式比生成子类(继承)更为灵活(消除重复代码&减少子类个数)。 一《设计模式》 GoF 装饰器模式&#xff08;Decorator Pattern&#xff09;允许向一个现有的对象添加新的功能&#xf…
阅读更多...
MongoDB 6.0.8 安装配置

MongoDB 6.0.8 安装配置

一、前言 MongoDB是一个基于分布式文件存储的数据库。由C语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。在高负载的情况下&#xff0c;添加更多的节点&#xff0c;可以保证服务器性能。 MongoDB 将数据存储为一个文档&#xff0c;数据结构由键值(key>value…
阅读更多...
【Linux:线程池】

【Linux:线程池】

文章目录 1 线程池概念2 第一个版本的线程池3 第二个版本的线程池4 第三个版本的线程池5 STL中的容器以及智能指针的线程安全问题6 其他常见的各种锁7 读者写者问题(了解) 1 线程池概念 一种线程使用模式。线程过多会带来调度开销&#xff0c;进而影响缓存局部性和整体性能。而…
阅读更多...
【绪论0】

【绪论0】

#pic_center R 1 R_1 R1​ R 2 R^2 R2 目录 知识框架No.0 引言No.1 操作系统的概念功能和定义一、操作系统的概念和定义1、电脑的演变 二、操作系统的功能和目标 No.2 操作系统的特征一、并发二、共享三、虚拟四、异步 No.3 操作系统的发展与分类一、手工操作阶段二、批处理阶段…
阅读更多...
elementui Cascader 级联选择使用心得

elementui Cascader 级联选择使用心得

相信大家对于elementui并不陌生&#xff0c;作为适配Vue的优秀UI框架之一&#xff0c;一直被所有的开发者痛并快乐着。今天要记录的就是里边的主角之一Cascader。 首先先介绍一下Cascader ---> 当一个数据集合有清晰的层级结构时&#xff0c;可通过级联选择器逐级查看并选择…
阅读更多...
IDEA超强XSD文件编辑插件-XSD / WSDL Visualizer

IDEA超强XSD文件编辑插件-XSD / WSDL Visualizer

前言 XSD / WSDL Visualizer可以简化XML架构定义(XSD)和WSDL文件编辑过程; 通过使用与IntelliJ无缝集成的可视化编辑器&#xff0c;转换处理XSD和WSDL文件的方式。告别导航复杂和难以阅读的代码的挫败感&#xff0c;迎接流线型和直观的体验。 插件安装 在线安装 IntelliJ IDE…
阅读更多...
6.物联网操作系统信号量

6.物联网操作系统信号量

一。信号量的概念与应用 信号量定义 FreeRTOS信号量介绍 FreeRTOS信号量工作原理 1.信号量的定义 多任务环境下使用&#xff0c;用来协调多个任务正确合理使用临界资源。 2.FreeRTOS信号量介绍 Semaphore包括Binary&#xff0c;Count&#xff0c;Mutex&#xff1b; Mutex包…
阅读更多...
【面试题】位图

【面试题】位图

文章目录 位图如何添加数据如何删除数据代码实现给100亿个整数&#xff0c;如何找到只出现一次的数字代码实现给两个文件&#xff0c;分别有100亿个整数&#xff0c;但只有1g内存&#xff0c;如何找到文件的交集&#xff1f;1个文件有100亿个int&#xff0c;1G内存&#xff0c;…
阅读更多...
EventBus 开源库学习（一）

EventBus 开源库学习（一）

一、概念 EventBus是一款在 Android 开发中使用的发布-订阅事件总线框架&#xff0c;基于观察者模式&#xff0c;将事件的接收者和发送者解耦&#xff0c;简化了组件之间的通信&#xff0c;使用简单、效率高、体积小。 一句话&#xff1a;用于Android组件间通信的。 二、原理…
阅读更多...
插入排序讲解

插入排序讲解

插入排序&#xff08;Insertion-Sort&#xff09;一般也被称为直接插入排序。对于少量元素的排序&#xff0c;它是一个有效的算法。插入排序是一种最简单的排序方法&#xff0c;它的基本思想是将一个记录插入到已经排好序的有序表中&#xff0c;从而一个新的、记录数增1的有序表…
阅读更多...
最新文章

Copyright @ 2022~2023