Android Handler用法

Android Handler用法

  • 为什么要设计Handler机制？
  • Handler的用法
    • 1、创建Handler
    • 2、Handler通信
      • 2.1 sendMessage 方式
      • 2.2 post 方式
  • Handler常用方法
    • 1、延时执行
    • 2、周期执行
  • HandlerThread用法
    • 主线程-创建Handler
    • 子线程-创建Handler
  • FAQ
    • Message是如何创建
    • 主线程中Looper的轮询死循环为何没有阻塞主线程
    • Handler内存泄漏问题及解决方案
    • Handler为什么会持有Activity的引用？

参考文档：https://developer.android.google.cn/guide/components/processes-and-threads?hl=zh-cn#java
在这里插入图片描述

Android UI操作并非线程安全。因此，请不要在工作线程(即子线程)中操纵界面。您可以通过界面线程对界面进行所有操作。Android 的单线程模型有以下两条规则：

  • 请勿阻塞UI线程
  • 请勿从UI线程以外的线程进行UI操作

为什么要设计Handler机制？

一个耗时的操作，比如需要联网读取数据或者读取本地较大的一个文件或者数据库查询，如果把这些操作放在主线程中，界面会出现假死现象， 如果5秒钟还没有完成的话，阻塞了UI线程会收到Android系统的一个错误提示 “强制关闭”，这糟糕的体验会造成严重的损失，所以不能阻塞UI线程，以确保应用界面的响应能力。
这时候就需要把这些耗时的操作，放到子线程中去执行，但是在子线程执行完以后，又需要将结果更新到UI页面，此时就涉及到子线程UI更新的操作。那为什么安卓规定不能在子线更新UI？ 最根本的原因是多线程并发的问题，假设在一个Activity中，有多个线程去更新UI，并且都没有加锁机制，就会产生更新界面错乱，所以子线程中更新UI是不安全的，而在一个线程中更新UI是变得比较合理，那自然就是主线程了，当然主线程也可以叫UI线程了。
综上所述，所以安卓应用需要这样的机制：

  1. 只能在主线程更新UI，并且所有更新UI的操作，都要在主线程的消息队列当中去轮询处理。
  2. 耗时的操作在子线程，更新UI的操作在主线程，他们之间的交互需要实现线程间通信。

Handler用于实现多线程通信和管理UI线程的消息处理。它为开发者提供了一种简单有效的方法来处理异步任务和更新UI界面。
当然，Android已经提供了多种从其他线程访问UI线程的方式。以下列出了几种有用的方法：

  • Activity.runOnUiThread(Runnable)
  • View.post(Runnable)
  • Handler.post(Runnable)

Activity.runOnUiThread(Runnable)方法：如果在UI线程，直接更新UI；如果非UI线程，使用的是post。

new Thread(new Runnable() {@Overridepublic void run() {// todo 在子线程中进行耗时操作doSomethings();runOnUiThread(new Runnable() {@Overridepublic void run() {// todo UI更新代码doSomethingsAboutUI();}});}
}).start();

View.post(Runnable) 方法：

new Thread(new Runnable() {@Overridepublic void run() {// todo 在子线程中进行耗时操作doSomethings();findViewById(R.id.button_send).post(new Runnable() {@Overridepublic void run() {// todo UI更新代码doSomethingsAboutUI();}});}
}).start();

Handler.post(Runnable)方法

private Handler mHandler =new Handler();  //默认主线程
...
new Thread(new Runnable() {@Overridepublic void run() {// todo 在子线程中进行耗时操作doSomethings();mHandlers.post(new Runnable() {@Overridepublic void run() {// todo UI更新代码doSomethingsAboutUI();}});}
}).start();

随着操作变得越来越复杂，这种代码也会变得复杂且难以维护。为了处理与工作线程(子线程)的更复杂的交互，建议在UI线程中使用 Handler 处理从子线程传送的消息。

工作原理：Handler运行在主线程(UI线程)中， 它与子线程可以通过Message对象来传递数据和消息，然后把这些消息放入主线程队列中，按照先进先出的原则配合主线程逐个进行更新UI的操作。另外，驱动这套机制运行的核心是Looper.loop() 里的死循环。

@Override
public void run() {mTid = Process.myTid();Looper.prepare(); // 创建Looper的子线程，然后创建MessageQueue，最后进行绑定。synchronized (this) {mLooper = Looper.myLooper();  // 获取准备好的Looper对象notifyAll();}Process.setThreadPriority(mPriority);onLooperPrepared();Looper.loop();  // 启动LoopermTid = -1;
}

Handler的用法

下面的这种写法是可以实现刷新UI的功能，但是它违背了单线程模型：Android UI操作并不是线程安全的，并且这些操作必须在UI线程中执行。但是如果与UI无关的操作如上传/下载，数据库，可以使用此种写法。

new Thread(new Runnable() {@Overridepublic void run() {textviewCurrentStatus.invalidate();}
}).start();

优点：避免了创建新线程带来的线程切换开销。
缺点：Handler发送的消息会保存在消息队列中，如果一直发送大量的消息，将可能导致消息队列过长，影响应用的响应能力。LiveData和RxJava等现在比较流行的框架，能够替代Handler实现更优异的异步编程和UI更新。

1、创建Handler

一般在主线程中创建Handler如下：

private Handler mHandler = new Handler(Looper.getMainLooper()) {public void handleMessage(Message msg) {switch (msg.what) {case 1:// todo 在主线程更新UIdoSomethingsAboutUI();break;}super.handleMessage(msg);}
};

在子线程中创建Handler，最好使用HandlerThread。如果不使用HandlerThread，必须要手动启动Looper，具体如下：

private Handler mHandler;@Override
protected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);new Thread(new Runnable() {@Overridepublic void run() {// todo 在子线程进行耗时操作doSomethings();Looper.prepare();  // 准备LoopermHandler= new Handler(new Handler.Callback() {@Overridepublic boolean handleMessage(@NonNull Message msg) {// todo 实际还是在主线程更新UIdoSomethingsAboutUI();return false;}});Looper.loop();    // 启动Looper}}).start();
}

2、Handler通信

使用Handler通信，有两种方法将消息加入消息队列中：post()方法和sendMessage()方法。
– sendMessage()方法是异步方式。即加入消息到消息队列中后，不会立即执行此消息，而是等待消息阻塞的处理程序返回。 — 存疑
– post()方法是同步方式。即加入消息到消息队列中后，会直接处理此消息，不必等待消息阻塞的处理程序返回。— 存疑

2.1 sendMessage 方式

首先，需要定义好handler需要处理的业务。

private Handler myHandler = new Handler(Looper.getMainLooper()) {public void handleMessage(Message msg) {switch (msg.what) {case 1:// todo 在主线程更新UIdoSomethingsAboutUI();break;}super.handleMessage(msg);}
};

在需要的时机，发送消息触发handler调用业务。

new Thread(new Runnable() {@Overridepublic void run() {// todo 在子线程中进行耗时操作doSomethings();Message message = new Message(); //或者Message msg = mHandler.obtainMessage();message.what = 1;msg.arg1 = 100;msg.obj = "message content";myHandler.sendMessage(message);}
}).start();

另外一种常见写法，本质都是一样的：

private Handler mHandler = new Handler(new Handler.Callback() {@Overridepublic boolean handleMessage(@NonNull Message msg) {switch (msg.what){case 1:// todo 在主线程更新UIdoSomethingsAboutUI();break;}return false;}
});
....
new Thread(new Runnable() {@Overridepublic void run() {// todo 在子线程中进行耗时操作doSomethings();Message message = mHandler.obtainMessage(1);mHandler.sendMessage(message);}
}).start();

2.2 post 方式

通过调用 Handler 的 post() 方法，将 Runnable 对象通过 MessageQueue 发送到消息队列中，即可让主线程处理相应的操作。这种方式可以用于解决在子线程中不能进行 UI 操作的问题，例如我们可以在子线程中通过 post 方式将更新 UI 的任务传递到主线程来完成，这样就不会因为在非 UI 线程中更新 UI 而导致 ANR（Application Not Responding）了。

private Handler mHandler =new Handler();
...
mHandler.post(new Runnable() {@Overridepublic void run() {// todo UI更新代码doSomethingsAboutUI();}
});

注意：post方法虽然发送的是一个实现了Runnable接口的类对象，但是它并非创建了一个新线程，而是执行了该对象中的run方法。也就是说，整个run中的操作和主线程处于同一个线程。这样对于那些简单的操作，似乎并不会影响。但是对于耗时较长的操作，就会出现“假死”。为了解决这个问题，就需要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。

在主线程中使用Handler，可以直接使用getMainLooper()获取主线程Looper对象，并创建Handler实例。例如，在Activity中实现在子线程中更新UI：

private Handler mHandler = new Handler(Looper.getMainLooper());
...
new Thread(new Runnable() {@Overridepublic void run() {// todo 在子线程中进行耗时操作doSomething();mHandler.post(new Runnable() {@Overridepublic void run() {// todo 在主线程更新UIdoSomethingsAboutUI();}});}
}).start();

Handler常用方法

1、延时执行

3秒后执行UI更新的代码。

mHandler.postDelayed(new Runnable() {@Overridepublic void run() {// todo UI更新代码doSomethingsAboutUI();}
},3000);

2、周期执行

有时候需要按时反复周期性的执行一些任务
2.1 使用Timer和TimerTask 实现

private Timer mTimer = new Timer();
private TimerTask mTimerTask = new TimerTask() {@Overridepublic void run() {Message message = new Message();message.what = 1;mHandler.sendMessage(message);}
};private Handler mHandler = new Handler() {public void handleMessage(Message msg) {switch (msg.what) {case 1:// todo 处理定时或周期性的业务doSomethings();break;}super.handleMessage(msg);}
};

在需要触发的时机，调用即可

mTimer.schedule(mTimerTask, 10000);

2.2 使用postDelayed和sendMessage实现

private int index = 0;private Handler mHandler = new Handler(Looper.getMainLooper()) {public void handleMessage(Message msg) {switch (msg.what) {case 1:updateOnTick();break;}super.handleMessage(msg);}
};private void updateOnTick(){mHandler.postDelayed(new Runnable() {@Overridepublic void run() {// todo 周期性执行doSomethings();Log.d(TAG, "run: " + (index++));mHandler.sendMessage(Message.obtain(mHandler,1));}}, 2000);  // 2秒执行一次
}

HandlerThread用法

HandlerThread常用于需要在后台执行耗时任务，并与UI线程进行交互的场景。比如，每隔6秒需要切换一下TextView的显示数据，虽然可以在UI线程中执行，但是这样的操作长时间占用UI线程，很容易让UI线程卡顿甚至崩溃，所以最好在子线程HandlerThread中调用这种业务。
HandlerThread能新建一个拥有Looper的线程。这个Looper能够用来新建其他的Handler。但需要注意的是，新建的HandlerThread需要及时回收，否则容易内存泄露。

非UI线程的业务也可以使用HandlerThread消息机制，因为不会干扰或阻塞UI线程，而且通过消息可以多次重复使用当前线程，也可以多个Handler也可以共享一个Looper，节省开支。

一个线程只能创建一个Looper，一个Looper个创建多个Handler。

使用HandlerThread可以实现以下功能和优势：

  1. 后台线程执行任务：HandlerThread在后台创建一个工作线程，可以在该线程中执行耗时任务，而不会阻塞UI线程，保证了应用的响应性和流畅性。
  2. 消息处理和线程间通信：HandlerThread内部封装了Looper和Handler，可以轻松地实现消息的发送和处理，以及线程间的通信。通过HandlerThread，可以将耗时任务的结果发送到UI线程进行更新，或者接收UI线程发送的消息进行处理。
  3. 简化线程管理：HandlerThread将线程的创建和管理进行了封装，开发人员只需要关注业务逻辑的实现，而无需手动创建和管理线程，减少了线程管理的复杂性。

主线程-创建Handler

private Handler mHandler;
private HandlerThread mHandlerThread;@Override
protected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);mHandlerThread = new HandlerThread("子线程HandlerThread");mHandlerThread.start();mHandler= new Handler(mHandlerThread.getLooper()) {@Overridepublic void handleMessage(@NonNull Message msg) {super.handleMessage(msg);switch (msg.what){case 1:Log.d(TAG, "handleMessage: " + mHandlerThread.getName());// todo 在主线程更新UIdoSomethingsAboutUI();break;}}};
}
...
private void sendMessages(){new Thread(new Runnable() {@Overridepublic void run() {// todo 在子线程中进行耗时操作doSomethings();Message message = mHandler.obtainMessage(1);mHandler.sendMessage(message);}}).start();
}@Override
protected void onPause() {super.onPause();// 防止退出界面后Handler还在执行mHandler.removeMessages(1);
}@Override
protected void onDestroy() {super.onDestroy();// 防止退出界面后Handler还在执行mHandler.removeMessages(1);// 释放资源mHandlerThread.quit();
}

子线程-创建Handler

private Handler mHandler;
private HandlerThread mHandlerThread;@Override
protected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);new Thread(new Runnable() {@Overridepublic void run() {mHandlerThread = new HandlerThread("子线程HandlerThread");mHandlerThread.start();mHandler= new Handler(mHandlerThread.getLooper()) {@Overridepublic void handleMessage(@NonNull Message msg) {super.handleMessage(msg);switch (msg.what){case 1:Log.d(TAG, "handleMessage: " + mHandlerThread.getName());// todo 在主线程更新UIdoSomethingsAboutUI();break;}}};}}).start();
}
...
private void sendMessages(){new Thread(new Runnable() {@Overridepublic void run() {// todo 在子线程中进行耗时操作doSomethings();Log.d(TAG, "sendMessages: 耗时操作");Message message = mHandler.obtainMessage(1);mHandler.sendMessage(message);}}).start();
}@Override
protected void onPause() {super.onPause();// 防止退出界面后Handler还在执行mHandler.removeMessages(1);  // 删除所有消息 mHandler.removeCallbacksAndMessages(null);
}@Override
protected void onDestroy() {super.onDestroy();// 防止退出界面后Handler还在执行mHandler.removeMessages(1);   // 删除所有消息 mHandler.removeCallbacksAndMessages(null);// 释放资源mHandlerThread.quit();
}

注意：1、子线程中创建了Looper，当没有消息的时候子线程将会被block，无法被回收，所以我们需要手动调用quit 方法将消息删除并且唤醒looper，然后next方法返回null退出loop。
2、在主线程和子线程中，使用HandlerThread创建Handler，基本没有区别。但如果没有使用HandlerThread，在子线程中需要先创建Looper，再创建Handler。具体如下：

private Handler mHandler ;
...
new Thread(new Runnable() {@Overridepublic void run() {Looper.prepare(); // 创建Looper的子线程，然后创建MessageQueue，最后进行绑定。mHandler = new Handler(new Handler.Callback() {@Overridepublic boolean handleMessage(@NonNull Message msg) {return false;}});Looper.loop();  // 启动Looper}
}).start();

FAQ

Message是如何创建

首先考虑一个问题，屏幕刷新率 60Hz（即每秒刷新60次），每次刷新要用到 3 个 Message，也就是每秒钟至少要创建180个Message。这样不断的创建回收，就会出现内存抖动的问题，从而导致 GC、屏幕卡顿等问题。
为了解决上面的问题，采用 Message 了享元的设计模式，使用 obtain() 方法创建。在Handler 中创建两个线程池队列，一个是我们比较熟悉的 MessageQueue，另一个就是回收池 sPool（最大长度是 50 复用池）。MessageQueue 中 Message 回收时，我们将清空数据的 Message 放回到 sPool 队列中。创建 Manager，我们直接从 sPool 池中取出来就可以了。
应用场景：地图、股票、RecyclerView复用等对数据的处理都使用了享元模式。

主线程中Looper的轮询死循环为何没有阻塞主线程

Looper 轮询是死循环，但是当没有消息的时候他会 block（阻塞， 阻塞代码没有执行计时操作），ANR 是当我们处理点击事件的时候 5s 内没有响应，我们在处理点击事件的时候也是用的 Handler，所以一定会有消息执行，并且 ANR 也会发送 Handler 消息，所以不会阻塞主线程。Looper 是通过 Linux 系统的 epoll 实现的阻塞式等待消息执行（有消息执行无消息阻塞），而 ANR 是消息处理耗时太长导致无法执行剩下需要被执行的消息触发了 ANR。Handler底层为什么用epoll，为什么不用select和poll？ Socket 非阻塞 IO 中 select 需要全部轮询不适合，poll 也是需要遍历和 copy，效率太低了。epoll 非阻塞式 IO，使用句柄获取 APP 对象，epoll 无遍历，无拷贝。还使用了红黑树（解决查询慢的问题）。

Handler内存泄漏问题及解决方案

内部类持有外部类的引用导致了内存泄漏，如果 Activity 退出的时候，MessageQueue中还有一个 Message 没有执行，这个 Message 持有了 Handler 的引用，而 Handler 持有了 Activity 的引用，导致 Activity 无法被回收，导致内存泄漏。这种问题可以使用 static 关键字修饰，在 onDestory 的时候将消息清除。
简单理解：当 Handler 为非静态内部类时，其持有外部类 Activity 对象，所以导致 static Looper -> mMainLooper -> MessageQueue -> Message -> Handler -> MainActivity，这个引用链中 Message 如果还在 MessageQueue 中等待执行，则会导致 Activity 一直无法被释放和回收。
根本原因：因为Looper需要循环处理消息，但一个线程只有一个Looper，而一个线程中可以有多个Handler，MessageQueue中消息Message 执行时不知道要通知哪个Handler执行任务，所以在Message创建时target引用了Handler对象，用于回调执行的消息。
如果Handler是Activity这种短生命周期对象的非静态内部类时，则创建出来的Handler对象会持有该外部类Activity的引用，当页面销毁时，还在队列的Message持有着Handler对象，而Handler正持有着外部类Activity，就会导致 Activity无法被gc回收，从而导致内存泄漏。
解决办法：
1、Handler不能是Activity这种短生命周期的对象类的内部类；
2、在 Activity销毁时，将创建的 Handler中的消息队列清空并结束所有任务。
3、将handler设置成static，static变量是全局变量，不能够自动引用外部类变量，这时Handler 就不再持有 Activity，Activity就可以正常释放。

Handler为什么会持有Activity的引用？

创建Handler时，采用的是匿名内部类或者成员内部类的方式，而内部类会默认持有外部类的引用，也就是Handler对象会默认持有Activity的引用。

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

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

相关文章

今天发现个有意思的问题：java基础篇章网络编程的报错问题，顺便看一下各个GPT的实力

今天发现个有意思的问题：java基础篇章网络编程的报错问题，顺便看一下各个GPT的实力

问题： 一个java socket网络编程的引发的异常，具体代码Client.java、Server.java，如下 Client.java package Test2;import java.io.*; import java.net.Socket;public class Client {public static void main(String[] args) throws IOExce…
阅读更多...
JMeter 请求头信息配置详解

JMeter 请求头信息配置详解

在进行 Web 测试和 API 测试时，正确配置 HTTP 请求头是关键步骤之一，尤其当使用诸如 JMeter 这样的强大工具时。在本文中，我将详细介绍如何在 JMeter 中有效地配置和管理HTTP请求头。 在 JMeter 中添加和配置 HTTP 请求头 步骤 1: 打开 HTT…
阅读更多...
中间件研发之Springboot自定义starter

中间件研发之Springboot自定义starter

Spring Boot Starter是一种简化Spring Boot应用开发的机制，它可以通过引入一些预定义的依赖和配置，让我们快速地集成某些功能模块，而无需繁琐地编写代码和配置文件。Spring Boot官方提供了很多常用的Starter，例如spring-boot-star…
阅读更多...
张大哥笔记：卖盗版网课，获利 100 万被抓

张大哥笔记：卖盗版网课，获利 100 万被抓

这几天刷视频，看到一个新闻，某大学生卖盗版网课，把别人2000多正版网课，以做活动名义售卖20元，获利100多万被抓。 下方图片来自：极目新闻 卖这种盗版网课，门槛低，成本低，…
阅读更多...
揭秘！如何利用自动化工具提升抖音推广效果

揭秘！如何利用自动化工具提升抖音推广效果

亲爱的读者朋友们，你是否在为抖音的推广效果而苦恼？看着别人家的视频轻松获得大量曝光，你是否也心生羡慕？今天，我们就来分享一个秘密武器，让你轻松提升抖音推广效果！ 首先，让我们来了…
阅读更多...
为何美国多IP服务器是全自动内容采集站的最佳选择?

为何美国多IP服务器是全自动内容采集站的最佳选择?

为何美国多IP服务器是全自动内容采集站的最佳选择? 在建设全自动内容采集站时，选择合适的服务器至关重要。而在众多选项中，美国多IP服务器被认为是最佳选择，究竟为何呢?本文将从多个方面进行深入探讨。 为何美国多IP服务器是全自动内容采集…
阅读更多...
项目|保障房房产管理系统，政务房产解决方案

项目|保障房房产管理系统，政务房产解决方案

一、系统概况 保障房管理系统是是为了落实中央关于住房保障的相关政策，实现对低收入家庭住房状况的调查管理、保障计划及落实管理、保障申请及审核管理、保障户和保障房源档案管理等。 针对政府保障房产管理的一站式解决方案，专注于为解决复杂、繁琐的…
阅读更多...
【精品毕设推荐】搜索引擎的设计与实现

【精品毕设推荐】搜索引擎的设计与实现

点击免费下载原文及代码 摘要 我们处在一个大数据的时代，伴随着网络信息资源的庞大，人们越来越多地注重怎样才能快速有效地从海量的网络信息中，检索出自己需要的、潜在的、有价值的信息，从而可以有效地在日常工作和生活中发挥作…
阅读更多...
【C++】stack、queue和priority_queue的模拟实现

【C++】stack、queue和priority_queue的模拟实现

在本篇博客中，作者将会讲解STL中的stack、queue和priority_queue的模拟实现，同时还会带大家了解一下deque这个容器。 一.什么是适配器 STL中一共有6大组件：容器，适配器，空间配置器，仿函数，迭代器…
阅读更多...
机器学习——3.梯度计算与梯度下降

机器学习——3.梯度计算与梯度下降

基本概念 梯度的本意是一个向量（矢量），表示某一函数在该点处的方向导数沿着该方向取得最大值，即函数在该点处沿着该方向（此梯度的方向）变化最快，变化率最大（为该梯度的模&#xff0…
阅读更多...
validation的简单使用

validation的简单使用

首先是依赖 我这里使用的是 web 工程&#xff0c;所以多一个web依赖 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-validation</artifactId></dependency><dependency><groupId>…
阅读更多...
10 华三vlan技术介绍

10 华三vlan技术介绍

AI 解析 -Kimi-ai Kimi.ai - 帮你看更大的世界 (moonshot.cn) 虚拟局域网&#xff08;VLAN&#xff09;技术是一种在物理网络基础上创建多个逻辑网络的技术。它允许网络管理员将一个物理网络分割成多个虚拟的局域网&#xff0c;这些局域网在逻辑上是隔离的&#xff0c;但实际…
阅读更多...
leetCode68. 文本左右对齐

leetCode68. 文本左右对齐

基本思路&#xff1a; leetCode68. 文本左右对齐 代码 class Solution { public:vector<string> fullJustify(vector<string>& words, int maxWidth) {vector<string> res;for(int i 0; i < words.size(); i){ // 枚举有多少个单词int j i 1; //…
阅读更多...
年轻人刮疯了，刮刮乐断货了

年轻人刮疯了，刮刮乐断货了

年轻人刮疯了 刮刮乐缺货了。 00后彩票店老板陆诗等得有点着急。她的福彩店开在深圳&#xff0c;今年4月才开门营业&#xff0c;但从开业到今天&#xff0c;刮刮乐总共就来了一回货——开业时发的20本。 那之后&#xff0c;刮刮乐就彻底断供了。原本&#xff0c;陆诗想把刮刮…
阅读更多...
《MySQL数据类型》

《MySQL数据类型》

文章目录 一、理解数据本身就是一种约束1.tinyint类型和 tinyint unsigned类型2.其他的int类型 二、bit类型三、float类型1.signed版本注意2.unsigned版本 四、decimal类型float 和 decimal 总结五、char类型&#xff08;固定长度&#xff09;六、varchar类型&#xff08;可变长…
阅读更多...
【跟马少平老师学AI】-【神经网络是怎么实现的】（四）卷积神经网络

【跟马少平老师学AI】-【神经网络是怎么实现的】（四）卷积神经网络

一句话归纳&#xff1a; 1&#xff09;用1个小粒度的模式&#xff0c;逐个与图像的局部区域进行运算&#xff0c;运算结果反映模式与区域的匹配程度。 2&#xff09;卷积神经网络与全连接神经网络的区别&#xff1a; 卷积神经网络的输出只与局部输入有连接。参数较少&#xff0…
阅读更多...
N9048B PXE EMI 测试接收机，1 Hz 至 44 GHz

N9048B PXE EMI 测试接收机，1 Hz 至 44 GHz

​ _EMI_ N9048B EMI 测试接收机 1 Hz 至 44 GHz Keysight N9048B PXE 是一款符合标准的 EMI 测试接收机&#xff0c;配有射频预选器和 LNA 设计。其实时扫描&#xff08;RTS&#xff09;功能有助于您缩短总体测试时间&#xff0c;轻松执行无间隙的信号捕获和分析。 特点 …
阅读更多...
宏电全栈式IoT赋能供排水智能监测，护航城市生命线

宏电全栈式IoT赋能供排水智能监测，护航城市生命线

城市供水、排水系统是维系城市正常运行、满足群众生产生活需要的重要基础设施&#xff0c;是城市的“生命线”。随着城市化进程加快&#xff0c;城市规模不断扩大&#xff0c;地下管线增长迅速&#xff0c;城市“生命线安全”的监管日益面临挑战。 宏电作为物联网行业的领航者…
阅读更多...
Docker本地部署overleaf后，挖掘用户加密逻辑

Docker本地部署overleaf后，挖掘用户加密逻辑

overleaf的用户信息&#xff0c;保存在mongo数据库的users集合中。 用户密码则存在hashedPassword字段中 从开源的代码services\web\app\src\Features\Authentication\AuthenticationManager.js第303行可以找到密码加密逻辑。 本地可以通过下面的代码生成overleaf用户密码信息…
阅读更多...
408数据结构-树与森林 自学知识点整理

408数据结构-树与森林 自学知识点整理

前置知识&#xff1a;树的基本概念与性质 树的存储结构 树既可以采用顺序存储结构&#xff0c;又可采用链式存储结构。但无论采取哪种方式&#xff0c;都要求能够唯一地反映树中各结点之间的逻辑关系。 1. 双亲表示法 这种存储结构采用一组连续空间来存储每个结点&#xff0…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023