RabbitMQ_00000

MQ的相关概念

RabbitMQ官网地址：https://www.rabbitmq.com

RabbitMQ API地址：https://rabbitmq.github.io/rabbitmq-java-client/api/current/

什么是MQ？

MQ(message queue)本质是个队列，FIFO先入先出，只不过队列中存放的内容是message 而已，还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ 是一种非常常见的上下游“逻辑解耦+物理解耦”的消息通信服务。使用了MQ之后，消息发送上游只需要依赖 MQ，不用依赖其他服务。

为什么要用MQ？

1.流量消峰。
举个例子，如果订单系统最多能处理一万次订单，这个处理能力应付正常时段的下单时绰绰有余，正常时段我们下单一秒后就能返回结果。但是在高峰期，如果有两万次下单操作系统是处理不了的，只能限制订单超过一万后不允许用户下单。使用消息队列做缓冲，我们可以取消这个限制，把一秒内下的订单分散成一段时间来处理，这时有些用户可能在下单十几秒后才能收到下单成功的操作，但是比不能下单的体验要好。

2.应用解耦
以电商应用为例，应用中有订单系统、库存系统、物流系统、支付系统。用户创建订单后，如果耦合调用库存系统、物流系统、支付系统，任何一个子系统出了故障，都会造成下单操作异常。当转变成基于消息队列的方式后，系统间调用的问题会减少很多，比如物流系统因为发生故障，需要几分钟来修复。在这几分钟的时间里，物流系统要处理的内存被缓存在消息队列中，用户的下单操作可以正常完成。当物流系统恢复后，继续处理订单信息即可，中单用户感受不到物流系统的故障，提升系统的可用性。

3.异步处理
有些服务间调用是异步的，例如A调用B，B需要花费很长时间执行，但是A需要知道B什么时候可以执行完，以前一般有两种方式，A过一段时间去调用B的查询api查询。或者A提供一个callback api，
B 执行完之后调用api通知A服务。这两种方式都不是很优雅，使用消息总线，可以很方便解决这个问题，A调用B服务后，只需要监听B处理完成的消息，当B处理完成后，会发送一条消息给MQ，MQ会将此消息转发给A服务。这样A服务既不用循环调用B的查询api，也不用提供callback api。同样B服务也不用做这些操作。A服务还能及时的得到异步处理成功的消息。

RabbitMQ

2007 年发布，是一个在 AMQP(高级消息队列协议)基础上完成的，可复用的企业消息系统，是当前最主流的消息中间件之一。

生产者
产生数据发送消息的程序是生产者。

交换机
交换机是RabbitMQ非常重要的一个部件，一方面它接收来自生产者的消息，另一方面它将消息推送到队列中。交换机必须确切知道如何处理它接收到的消息，是将这些消息推送到特定队列还是推送到多个队列，亦或者是把消息丢弃，这个得有交换机类型决定。

队列
队列是RabbitMQ内部使用的一种数据结构，尽管消息流经RabbitMQ和应用程序，但它们只能存储在队列中。队列仅受主机的内存和磁盘限制的约束，本质上是一个大的消息缓冲区。许多生产者可以将消息发送到一个队列，许多消费者可以尝试从一个队列接收数据。这就是我们使用队列的方式

消费者
消费与接收具有相似的含义。消费者大多时候是一个等待接收消息的程序。请注意生产者，消费
者和消息中间件很多时候并不在同一机器上。同一个应用程序既可以是生产者又可以是消费者。

RabbitMQ的下载、安装

安装

1、在官网下载Linux版RabbitMQ安装文件。
erlang-21.3-1.el7.x86_64.rpm
rabbitmq-server-3.8.8-1.el7.noarch.rpm
2、将文件上传至Linux系统中。
上传到/usr/local/software目录下（如果没有software目录，则创建。）。
3、安装文件（按照以下顺序安装。）。
rpm -ivh erlang-21.3-1.el7.x86_64.rpm
yum install socat -y
rpm -ivh rabbitmq-server-3.8.8-1.el7.noarch.rpm
4、（1）添加开机启动RabbitMQ服务。
chkconfig rabbitmq-server on
（2）启动服务。
/sbin/service rabbitmq-server start
（3）查看服务状态。
/sbin/service rabbitmq-server status
（4）开启web管理插件
rabbitmq-plugins enable rabbitmq_management

停止服务：
/sbin/service rabbitmq-server stop
5、在浏览器地址栏中输入：http://ip:15672
例如：http://192.168.6.128:15672
输入默认：username:guest password:guest
点击登陆出现如下提示：
在这里插入图片描述
（1）添加一个新用户。
rabbitmqctl add_user 用户名 密码
例如：rabbitmqctl add_user admin 123
（2）设置用户角色。
rabbitmqctl set_user_tags admin administrator
（3）设置用户权限。

set_permissions [-p <vhostpath>] <user> <conf> <write> <read>
命令：rabbitmqctl set_permissions -p "/" admin ".*" ".*" ".*"

6、查看当前用户和角色。
rabbitmqctl list_users
7、使用添加的用户和对应的密码再次登陆。
8、关闭应用的命令：
rabbitmqctl stop_app
清除的命令：
rabbitmqctl reset
重新启动命令：
rabbitmqctl start_app

案例

在idea开发工具中创建一个project，在该project中创建module。
引入依赖：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.company</groupId>
  <artifactId>rabbitmq_00000</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>rabbitmq_00000</name>

  <dependencies>

    <!--RabbitMQ依赖客户端-->
    <dependency>
      <groupId>com.rabbitmq</groupId>
      <artifactId>amqp-client</artifactId>
      <version>5.20.0</version>
    </dependency>

    <!--操作文件流的一个依赖-->
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.15.1</version>
    </dependency>

  </dependencies>

  <build>

    <plugins>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>8</source>
          <target>8</target>
        </configuration>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>3.0.0</version>
        <configuration>
          <skipTests>true</skipTests>
        </configuration>
      </plugin>

    </plugins>

  </build>

</project>

工具类

package com.company.rabbitmq.utils;

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

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

public class RabbitMQUtils {

    public static Channel getChannel() {

        ConnectionFactory connectionFactory = new ConnectionFactory();

        connectionFactory.setHost("192.168.6.128");
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("123");

        Channel channel = null;

        try {

            Connection connection = connectionFactory.newConnection();
            channel = connection.createChannel();

        } catch (IOException | TimeoutException e) {
            e.printStackTrace();
        }

        return channel;

    }

}

生产者

package com.company.rabbitmq.one;

import com.company.rabbitmq.utils.RabbitMQUtils;
import com.rabbitmq.client.Channel;

import java.io.IOException;

public class Producer {

    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args){

        Channel channel = RabbitMQUtils.getChannel();

        /*
        生成一个队列
        1.队列名称。
        2.队列里面的消息是否持久化。默认消息存储在内存中。
        3.该队列是否只供一个消费者进行消费。是否进行共享：true：可以多个消费者消费。
        4.是否自动删除。最后一个消费者断开连接以后，该队列是否自动删除。true：自动删除。
        5.其他参数。

        Queue.DeclareOk queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments) throws IOException;
        */
        try {

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

            String message="hello world";
            /*
            发送一个消息。
            1.发送到哪个交换机。
            2.路由的key是哪个。
            3.其他的参数信息。
            4.发送消息的消息体。

            void basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body) throws IOException;
            */
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());

            System.out.println("消息发送成功！");

        } catch (IOException ioException) {
            ioException.printStackTrace();
        }

    }

}

消费者

package com.company.rabbitmq.one;

import com.company.rabbitmq.utils.RabbitMQUtils;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer {

    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args){

        Channel channel = RabbitMQUtils.getChannel();

        System.out.println("等待接收消息......");

        //推送的消息如何进行消费的接口回调。
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {

            String message= new String(delivery.getBody());
            System.out.println(message);

        };

        //取消消费的一个回调接口。如在消费的时候队列被删除掉了。
        CancelCallback cancelCallback = consumerTag -> {

            System.out.println(" 消息消费被中断。");

        };

        /*
        消费者消费消息
        1.消费哪个队列。
        2.消费成功之后是否要自动应答。true：代表自动应答 false：代表手动应答。
        3.消费者未成功消费的回调。
        
        String basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallback cancelCallback) throws IOException;
        */
        try {

            channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);

        } catch (IOException ioException) {
            ioException.printStackTrace();
        }

    }

}

Work Queues

工作队列(又称任务队列)的主要思想是避免立即执行资源密集型任务，而不得不等待它完成。相反我们安排任务在之后执行。我们把任务封装为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行作业。当有多个工作线程时，这些工作线程将一起处理这些任务。

轮训分发消息

生产者：消息发送者。

package com.company.rabbitmq.two;

import com.rabbitmq.client.Channel;

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

import com.company.rabbitmq.utils.RabbitMQUtils;

public class Task01 {

    private static final String QUEUE_NAME = "hello";

    public static void main(String[] args) {

        Channel channel = RabbitMQUtils.getChannel();

        try {

            //Queue.DeclareOk queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments) throws IOException;
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);

            //从控制台当中接收信息。
            Scanner scanner = new Scanner(System.in);
            while(scanner.hasNext()){
                String message = scanner.next();
                //void basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body) throws IOException;
                channel.basicPublish("",QUEUE_NAME,null,message.getBytes());

                System.out.println("发送消息完成：" + message);

            }

        } catch (IOException ioException) {
            ioException.printStackTrace();
        }

    }

}

消费者：消息接收者。

package com.company.rabbitmq.two;

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;

import com.company.rabbitmq.utils.RabbitMQUtils;

public class Worker01 {

    //队列名称。
    public static final String QUEUE_NAME = "hello";

    public static void main(String[] args) {

        Channel channel = RabbitMQUtils.getChannel();

        //消息的接收
        DeliverCallback deliverCallback = (consumerTag, message) -> {

            System.out.println("接收到的消息：" + new String(message.getBody()));

        };

        //消息接收被取消时，执行下面的内容。
        CancelCallback cancelCallback = consumerTag -> {

            System.out.println(consumerTag + "消息者取消消费接口回调逻辑");

        };

        try {

            System.out.println("C1等待接收消息......");
            //String basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallback cancelCallback) throws IOException;
            channel.basicConsume(QUEUE_NAME,true, deliverCallback, cancelCallback);

        } catch (IOException ioException) {
            ioException.printStackTrace();
        }

    }

}

结果：
通过程序执行发现生产者总共发送4个消息，消费者1和消费者2分别分得两个消息，并且是按照有序的一个接收一次消息。
在这里插入图片描述

消息应答

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

自动应答

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

消息应答的方法

  • Channel.basicAck （用于肯定确认。）
    RabbitMQ已知道该消息并且成功的处理消息，可以将其丢弃了。
  • Channel.basicNack（用于否定确认。）
  • Channel.basicReject（用于否定确认。）
    与Channel.basicNack相比少一个参数，不处理该消息了直接拒绝，可以将其丢弃了。
    在这里插入图片描述
    multiple的true和false代表不同意思：
    true：代表批量应答channel上未应答的消息。

消息自动重新入队

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

package com.company.rabbitmq.utils;

public class SleepUtils {

    public static void sleep(int second){

        try {
            Thread.sleep(1000*second);
        } catch (InterruptedException _ignored) {
            Thread.currentThread().interrupt();
        }

    }

}

package com.company.rabbitmq.three;

import com.rabbitmq.client.Channel;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

import com.company.rabbitmq.utils.RabbitMQUtils;

/*
消息在手动应答时是不丢失的，放回队列中重新消费。
*/
public class Task2 {

    //队列名称
    private static final String TASK_QUEUE_NAME = "ack_queue";

    public static void main(String[] args) {

        Channel channel = RabbitMQUtils.getChannel();

        //声明队列
        try {

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

            //从控制台中输入信息。
            Scanner scanner = new Scanner(System.in);
            while(scanner.hasNext()){
                String message = scanner.next();
                channel.basicPublish("", TASK_QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
                System.out.println("生产者发出消息：" + message);

            }

        } catch (IOException ioException) {
            ioException.printStackTrace();
        }

    }

}

package com.company.rabbitmq.three;

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;

import com.company.rabbitmq.utils.RabbitMQUtils;
import com.company.rabbitmq.utils.SleepUtils;

/*
消息在手动应答时是不丢失的，放回队列中重新消费。
*/
public class Work03{

        //队列名称
        private static final String TASK_QUEUE_NAME = "ack_queue";

        public static void main(String[] args) {

            Channel channel = RabbitMQUtils.getChannel();
            System.out.println("C1等待接收消息处理时间较短。");

            DeliverCallback deliverCallback = (consumerTag, message) -> {

                //沉睡1秒
                SleepUtils.sleep(1);

                System.out.println("接收到的消息：" + new String(message.getBody(), "UTF-8"));

                //采用手动应答
                /*
                1、消息的标记：tag
                2、是否批量应答。false:不批量应答信道中的消息。true：批量应答。
                */
                //void basicAck(long deliveryTag, boolean multiple) throws IOException;
                channel.basicAck(message.getEnvelope().getDeliveryTag(), false);

            };

            //void handle(String consumerTag) throws IOException;
            /*CancelCallback cancelCallback = consumerTag -> {
                System.out.println(consumerTag + "消费者取消消费接口回调逻辑。");
            };*/

            try {

                //String basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallback cancelCallback) throws IOException;
                channel.basicConsume(TASK_QUEUE_NAME, false, deliverCallback,(consumerTag -> {
                    System.out.println(consumerTag + "消费者取消消费接口回调逻辑。");
                }));

            } catch (IOException ioException) {
                ioException.printStackTrace();
            }

        }

}

package com.company.rabbitmq.three;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

import com.company.rabbitmq.utils.RabbitMQUtils;
import com.company.rabbitmq.utils.SleepUtils;

/*
消息在手动应答时是不丢失的，放回队列中重新消费。
*/
public class Work04 {

        //队列名称
        private static final String TASK_QUEUE_NAME = "ack_queue";

        public static void main(String[] args) {

            Channel channel = RabbitMQUtils.getChannel();
            System.out.println("C2等待接收消息处理时间较长。");

            DeliverCallback deliverCallback = (consumerTag, message) -> {

                //沉睡30秒。
                SleepUtils.sleep(30);

                System.out.println("接收到的消息：" + new String(message.getBody(), StandardCharsets.UTF_8));

                //采用手动应答
                /*
                1、消息的标记：tag。
                2、是否批量应答。false：不批量应答信道中的消息。true：批量应答。
                */
                channel.basicAck(message.getEnvelope().getDeliveryTag(), false);

            };

            try {

                channel.basicConsume(TASK_QUEUE_NAME, false, deliverCallback, (consumerTag ->

                    System.out.println(consumerTag + "消费者取消消费接口回调逻辑。")

                ));

            } catch (IOException ioException) {
                ioException.printStackTrace();
            }

        }

}

正常情况下消息发送方发送两个消息C1和C2，分别接收到消息并进行处理。
在这里插入图片描述
在发送者发送消息dd，发出消息之后把C2消费者停掉，按理说该C2来处理该消息，但是由于它处理时间较长，在还未处理完，也就是说 C2还没有执行ack代码的时候，C2被停掉了，此时会看到消息被C1接收到了，说明消息dd被重新入队，然后分配给能处理消息的C1处理了。
在这里插入图片描述

RabbitMQ持久化

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

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

相关文章

Jmeter 基于Docker 实现分布式测试

Jmeter 基于Docker 实现分布式测试

基于Docker 实现分布式测试 制作Jmeter基础镜像制作工作节点镜像启动工作节点启动控制节点遇到的问题 使用Docker 部署Jmeter非常方便&#xff0c;可以省略软件的安装以及配置&#xff0c;比如jdk、jmeter。需要部署多个工作节点可以节省时间。 制作Jmeter基础镜像 下载jmeter…
阅读更多...
Kubernetes集群搭建

Kubernetes集群搭建

一、概述 Kubernetes是一个Google开源的全新的分布式容器集群管理系统&#xff0c;由于从第一个字母到字母s中间有8个字母&#xff0c;所以简称K8s。 二、准备 ip角色内存192.168.187.130master4G192.168.187.131node2G192.168.187.132node2G 小提示&#xff1a; 设置静态i…
阅读更多...
【课程作业_01】国科大2023模式识别与机器学习实践作业

【课程作业_01】国科大2023模式识别与机器学习实践作业

国科大2023模式识别与机器学习实践作业 作业内容 从四类方法中选三类方法&#xff0c;从选定的每类方法中 &#xff0c;各选一种具体的方法&#xff0c;从给定的数据集中选一 个数据集&#xff08;MNIST&#xff0c;CIFAR-10&#xff0c;电信用户流失数据集 &#xff09;对这…
阅读更多...
TCP TIME_WAIT 过多怎么处理

TCP TIME_WAIT 过多怎么处理

文章目录 1.什么是 TCP TIME_WAIT&#xff1f;2.为什么要 TIME_WAIT?3.TIME_WAIT 过多的影响4.解决办法4.1 调整短连接为长连接4.2 调整系统内核参数 5.小结参考文献 1.什么是 TCP TIME_WAIT&#xff1f; TCP 断开连接四次挥手过程中&#xff0c;主动断开连接的一方&#xff…
阅读更多...
ctfshow——文件包含

ctfshow——文件包含

文章目录 web 78——php伪协议第一种方法——php://input第二种方法——data://text/plain第三种方法——远程包含&#xff08;http://协议&#xff09; web 78——str_replace过滤字符php第一种方法——远程包含&#xff08;http://协议&#xff09;第二种方法——data://&…
阅读更多...
游戏被DDOS攻击无法访问时该如何处理

游戏被DDOS攻击无法访问时该如何处理

游戏行业随着时代的发展有着突飞猛进的变化&#xff0c;尤其是互联网时代智能手机的普及&#xff0c;让游戏行业发展上了一个新的台阶。因为游戏带来的巨大利润&#xff0c;游戏行业一直是DDoS攻击的首选目标。 DDoS是Distributed Denial of Service的缩写&#xff0c;即分布式…
阅读更多...
学习Android的第二天

学习Android的第二天

目录 Android User Interface 用户界面 UI Android View与ViewGroup的概念 Android View android.view.View android.view.View XML 属性 android:id 属性 Android ViewGroup android.view.ViewGroup ViewGroup.LayoutParams ViewGroup.MarginLayoutParams ViewGr…
阅读更多...
Redis核心技术与实战【学习笔记】 - 19.Pika：基于SSD实现大容量“Redis”

Redis核心技术与实战【学习笔记】 - 19.Pika：基于SSD实现大容量“Redis”

前言 随着业务数据的增加&#xff08;比如电商业务中&#xff0c;随着用户规模和商品数量的增加&#xff09;&#xff0c;就需要 Redis 能保存更多的数据。你可能会想到使用 Redis 切片集群&#xff0c;把数据分散保存到不同的实例上。但是这样做的话&#xff0c;如果要保存的…
阅读更多...
java社区养老年人服务系统springboot+vue

java社区养老年人服务系统springboot+vue

为了帮助用户更好的了解和理解程序的开发流程与相关内容&#xff0c;本文将通过六个章节进行内容阐述。 第一章&#xff1a;描述了程序的开发背景&#xff0c;程序运用于现实生活的目的与意义&#xff0c;以及程序文档的结构安排信息&#xff1b; 第二章&#xff1a;描述了程序…
阅读更多...
uniapp 高德地图显示

uniapp 高德地图显示

1. uniapp 高德地图显示 使用前需到**高德开放平台&#xff08;https://lbs.amap.com/&#xff09;**创建应用并申请Key   登录 高德开放平台&#xff0c;进入“控制台”&#xff0c;如果没有注册账号请先根据页面提示注册账号   打开 “应用管理” -> “我的应用”页面…
阅读更多...
Leetcode 85. 最大矩形

Leetcode 85. 最大矩形

题目信息 LeetoCode地址: 力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 题目理解 该题是84题的升级版。84题给出了一个一维数组&#xff0c;即一行数据&#xff0c;每个元素是高度。而该题则是给出了二维数组&#xff0c;只需我们将每一行的高度…
阅读更多...
太强了，AI数字人从制作到变现一次搞定

太强了，AI数字人从制作到变现一次搞定

AI数字人从制作到变现 如果说GPT类大模型是我们人类的第二大脑&#xff0c;数字人就是我们人类在互联网上的第二个身体。随着 AI 的迅速发展&#xff0c;2024 年 AI 模型开始从大型语言模型向大型视觉模型转变。数字人技术作为其分支之一&#xff0c;正日益成为科技、娱乐、教…
阅读更多...
【GAMES101】Lecture 14 15 辐射度量学

【GAMES101】Lecture 14 15 辐射度量学

目录 辐射度量学 Radiant flux&#xff08;光通量&#xff09; intensity&#xff08;发光强度&#xff09; irradiance radiance 辐射度量学 主要讲述了物理学中的Basic radiometry (辐射度量学)&#xff0c;就是我们在之前的计算光照中没有用具体的物理单位去衡量和描述…
阅读更多...
C++新特性 协程

C++新特性 协程

本篇文章我们来讲述一下C协程 协程&#xff08;Coroutine&#xff09;是一种能够挂起个恢复的函数过程 是一种轻量级的并发编程方式&#xff0c;也称为用户级线程。它与传统的线程&#xff08;Thread&#xff09;相比&#xff0c;具有更低的开销和更高的执行效率。 协程通常运…
阅读更多...
爬虫学习笔记-scrapy爬取汽车之家

爬虫学习笔记-scrapy爬取汽车之家

1.终端运行scrapy startproject scrapy_carhome,创建项目 2.接口查找 3.终端cd到spiders,cd scrapy_carhome/scrapy_carhome/spiders,运行 scrapy genspider audi https://car.autohome.com.cn/price/brand-33.html 4.打开audi,编写代码,xpath获取页面车型价格列表 5.运行项目…
阅读更多...
深度学习技巧应用35-L1正则化和L2正则在神经网络模型训练中的应用

深度学习技巧应用35-L1正则化和L2正则在神经网络模型训练中的应用

大家好，我是微学AI，今天给大家介绍一下深度学习技巧应用35-L1 正则化和L2正则在神经网络模型训练中的应用。L1正则化和L2正则化是机器学习中常用的两种正则化方法，用于防止模型过拟合并提高模型的泛化能力。这两种正则化方法通过在损失函数中添加惩罚项来控制模型的复杂性。…
阅读更多...
面试八股文（4）

面试八股文（4）

文章目录 1.sleep和wait区别2.为什么调用start()方法会执行run()方法&#xff0c;为什么不能直接调用run()方法3.synchronized关键字4.并发编程的三个重要特性5.synchronized和volatile关键字区别6.ThreadLocal7.为什么要用线程池&#xff1f;8.实现Runnable接口和Callable接口…
阅读更多...
课时13：变量基础_变量场景

课时13：变量基础_变量场景

2.1.1 变量场景 学习目标 这一节&#xff0c; 我们从 数据存储、变量场景、小结 三个方面来学习。 数据存储 数据存储 所谓的数据存储&#xff0c;我们从三方面来理解这句话&#xff1a;1、数据保存到哪里 -- 各种媒介&#xff0c;CPU、内存、磁盘、磁带、网盘...2、数据保…
阅读更多...
react+ts+antd-mobile 动态tabs➕下拉加载

react+ts+antd-mobile 动态tabs➕下拉加载

1.初始化项目 //搭建项目 npm create vitelatest react-jike-mobile -- --template react-ts//安装依赖 npm i //运行 npm run dev清理项目目录结构 安装ant design mobile ant design mobile是ant design家族里专门针对于移动端的组件库 npm install --save antd-mobile测试…
阅读更多...
日志报错 git -c dif.mnemonicprefix=false -c core.guotepath=false 解决方法

日志报错 git -c dif.mnemonicprefix=false -c core.guotepath=false 解决方法

前言： 在进行下面操作前，必须确保，你是否安装了Git。 查看Git 在命令行窗口中输入`git --version`： 如果这个命令成功显示了Git的版本信息，这表明Git已经被安装。 1. 使用Sourcetree SourceTree 是 Windows 和Mac OS X 下免费的 Git 和 Hg 客户端…
阅读更多...
最新文章

Copyright @ 2022~2023