安卓应用内通信的核心-Handler

Handler

Handler是安卓应用内通信的核心。

Handler相关的类简介

Handler机制整体可以看作一个传送带。

  • Looper
    传送带的轮子。
  • Handler
    传送带上货物的入口和出口。
  • Message
    传送带上的货物。
  • MessageQueue
    传送带的皮带。

基础知识

一个Thread只有一个Looper，一个Handler只有一个Looper，一个Looper只有一个MessageQueue。
Message分为三种：

  • 普通消息
    表现为Asynchronous为false
  • 异步消息
    表现为Asynchronous为true
  • 屏障消息
    表现为target为null

开始分析

Looper

public static void TestLooper() {// 在当前线程创建LooperLooper.prepare();// 获取当前线程的LooperLooper looper = Looper.myLooper();// 使传送带开始运动Looper.loop();// 终止运动looper.quit();
}

我们从prepare开始入手

prepare
    /** Initialize the current thread as a looper.* This gives you a chance to create handlers that then reference* this looper, before actually starting the loop. Be sure to call* {@link #loop()} after calling this method, and end it by calling* {@link #quit()}.*/public static void prepare() {prepare(true);}private static void prepare(boolean quitAllowed) {if (sThreadLocal.get() != null) {throw new RuntimeException("Only one Looper may be created per thread");}sThreadLocal.set(new Looper(quitAllowed));}private Looper(boolean quitAllowed) {mQueue = new MessageQueue(quitAllowed);mThread = Thread.currentThread();}

prepare函数实际上创建了一个Looper对象，并设置到ThreadLocal中，同时在初始化时创建了一个可以退出的MessageQueue。

myLooper & quit
    /*** Return the Looper object associated with the current thread.  Returns* null if the calling thread is not associated with a Looper.*/public static @Nullable Looper myLooper() {return sThreadLocal.get();}/*** Quits the looper.* <p>* Causes the {@link #loop} method to terminate without processing any* more messages in the message queue.* </p><p>* Any attempt to post messages to the queue after the looper is asked to quit will fail.* For example, the {@link Handler#sendMessage(Message)} method will return false.* </p><p class="note">* Using this method may be unsafe because some messages may not be delivered* before the looper terminates.  Consider using {@link #quitSafely} instead to ensure* that all pending work is completed in an orderly manner.* </p>** @see #quitSafely*/public void quit() {mQueue.quit(false);}

myLooper函数和quit方法则就是简易的封装。
接下来我们看重量级的loop函数

loop
    /*** Run the message queue in this thread. Be sure to call* {@link #quit()} to end the loop.*/@SuppressWarnings({"UnusedTokenOfOriginalCallingIdentity","ClearIdentityCallNotFollowedByTryFinally","ResultOfClearIdentityCallNotStoredInVariable"})public static void loop() {final Looper me = myLooper();if (me == null) {throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");}if (me.mInLoop) {Slog.w(TAG, "Loop again would have the queued messages be executed"+ " before this one completed.");}me.mInLoop = true;// Make sure the identity of this thread is that of the local process,// and keep track of what that identity token actually is.Binder.clearCallingIdentity();final long ident = Binder.clearCallingIdentity();// Allow overriding a threshold with a system prop. e.g.// adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'final int thresholdOverride =SystemProperties.getInt("log.looper."+ Process.myUid() + "."+ Thread.currentThread().getName()+ ".slow", -1);me.mSlowDeliveryDetected = false;for (;;) {if (!loopOnce(me, ident, thresholdOverride)) {return;}}}

首先是拿到当前线程的Looper实例。这里很明显mInLoop是一个标志，用于判断该Looper是否已经调用了loop。
接下来是一个死循环for，不断调用loopOnce

loopOnce
    /*** Poll and deliver single message, return true if the outer loop should continue.*/@SuppressWarnings({"UnusedTokenOfOriginalCallingIdentity","ClearIdentityCallNotFollowedByTryFinally"})private static boolean loopOnce(final Looper me,final long ident, final int thresholdOverride) {Message msg = me.mQueue.next(); // might blockif (msg == null) {// No message indicates that the message queue is quitting.return false;}// This must be in a local variable, in case a UI event sets the loggerfinal Printer logging = me.mLogging;if (logging != null) {logging.println(">>>>> Dispatching to " + msg.target + " "+ msg.callback + ": " + msg.what);}// Make sure the observer won't change while processing a transaction.final Observer observer = sObserver;final long traceTag = me.mTraceTag;long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;final boolean hasOverride = thresholdOverride >= 0;if (hasOverride) {slowDispatchThresholdMs = thresholdOverride;slowDeliveryThresholdMs = thresholdOverride;}final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0 || hasOverride)&& (msg.when > 0);final boolean logSlowDispatch = (slowDispatchThresholdMs > 0 || hasOverride);final boolean needStartTime = logSlowDelivery || logSlowDispatch;final boolean needEndTime = logSlowDispatch;if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {Trace.traceBegin(traceTag, msg.target.getTraceName(msg));}final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;final long dispatchEnd;Object token = null;if (observer != null) {token = observer.messageDispatchStarting();}long origWorkSource = ThreadLocalWorkSource.setUid(msg.workSourceUid);try {msg.target.dispatchMessage(msg);if (observer != null) {observer.messageDispatched(token, msg);}dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;} catch (Exception exception) {if (observer != null) {observer.dispatchingThrewException(token, msg, exception);}throw exception;} finally {ThreadLocalWorkSource.restore(origWorkSource);if (traceTag != 0) {Trace.traceEnd(traceTag);}}if (logSlowDelivery) {if (me.mSlowDeliveryDetected) {if ((dispatchStart - msg.when) <= 10) {Slog.w(TAG, "Drained");me.mSlowDeliveryDetected = false;}} else {if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",msg)) {// Once we write a slow delivery log, suppress until the queue drains.me.mSlowDeliveryDetected = true;}}}if (logSlowDispatch) {showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", msg);}if (logging != null) {logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);}// Make sure that during the course of dispatching the// identity of the thread wasn't corrupted.final long newIdent = Binder.clearCallingIdentity();if (ident != newIdent) {Log.wtf(TAG, "Thread identity changed from 0x"+ Long.toHexString(ident) + " to 0x"+ Long.toHexString(newIdent) + " while dispatching to "+ msg.target.getClass().getName() + " "+ msg.callback + " what=" + msg.what);}msg.recycleUnchecked();return true;}

取出Looper中MessageQueue的Message。
如果Message是null，则说明Looper该退出了。
msg.target是Looper所绑定的Handler。
通过msg.target.dispatchMessage(msg);，使得Handler处理当前的Message。

总结

Looper源码很简单，但设计很巧妙。使用了ThreadLocal避免对Looper的new。

MessageQueue

该类在上面的Looper中多次出现。
首先Looper构造函数中创建了该类实例，然后loopOnce中还调用该类的next方法得到一个Message实例。

构造函数 & 析构函数
    MessageQueue(boolean quitAllowed) {mQuitAllowed = quitAllowed;mPtr = nativeInit();}@Overrideprotected void finalize() throws Throwable {try {dispose();} finally {super.finalize();}}// Disposes of the underlying message queue.// Must only be called on the looper thread or the finalizer.private void dispose() {if (mPtr != 0) {nativeDestroy(mPtr);mPtr = 0;}}

看起来有点平平无奇，但请读者注意一下这里的nativeInit。
MessageQueue的工作完全可以纯java实现，无非就是notify和wait，但是这里却使用了native。

quit
    void quit(boolean safe) {if (!mQuitAllowed) {throw new IllegalStateException("Main thread not allowed to quit.");}synchronized (this) {if (mQuitting) {return;}mQuitting = true;if (safe) {removeAllFutureMessagesLocked();} else {removeAllMessagesLocked();}// We can assume mPtr != 0 because mQuitting was previously false.nativeWake(mPtr);}}

对于removeAllFutureMessagesLocked和removeAllMessagesLocked我们暂且不做探讨

next
Message next() {// Return here if the message loop has already quit and been disposed.// This can happen if the application tries to restart a looper after quit// which is not supported.final long ptr = mPtr;if (ptr == 0) {return null;}int pendingIdleHandlerCount = -1; // -1 only during first iterationint nextPollTimeoutMillis = 0;for (;;) {if (nextPollTimeoutMillis != 0) {Binder.flushPendingCommands();}nativePollOnce(ptr, nextPollTimeoutMillis);synchronized (this) {// Try to retrieve the next message.  Return if found.final long now = SystemClock.uptimeMillis();Message prevMsg = null;Message msg = mMessages;if (msg != null && msg.target == null) {// Stalled by a barrier.  Find the next asynchronous message in the queue.do {prevMsg = msg;msg = msg.next;} while (msg != null && !msg.isAsynchronous());}if (msg != null) {if (now < msg.when) {// Next message is not ready.  Set a timeout to wake up when it is ready.nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);} else {// Got a message.mBlocked = false;if (prevMsg != null) {prevMsg.next = msg.next;} else {mMessages = msg.next;}msg.next = null;if (DEBUG) Log.v(TAG, "Returning message: " + msg);msg.markInUse();return msg;}} else {// No more messages.nextPollTimeoutMillis = -1;}// Process the quit message now that all pending messages have been handled.if (mQuitting) {dispose();return null;}// If first time idle, then get the number of idlers to run.// Idle handles only run if the queue is empty or if the first message// in the queue (possibly a barrier) is due to be handled in the future.if (pendingIdleHandlerCount < 0&& (mMessages == null || now < mMessages.when)) {pendingIdleHandlerCount = mIdleHandlers.size();}if (pendingIdleHandlerCount <= 0) {// No idle handlers to run.  Loop and wait some more.mBlocked = true;continue;}if (mPendingIdleHandlers == null) {mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];}mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);}// Run the idle handlers.// We only ever reach this code block during the first iteration.for (int i = 0; i < pendingIdleHandlerCount; i++) {final IdleHandler idler = mPendingIdleHandlers[i];mPendingIdleHandlers[i] = null; // release the reference to the handlerboolean keep = false;try {keep = idler.queueIdle();} catch (Throwable t) {Log.wtf(TAG, "IdleHandler threw exception", t);}if (!keep) {synchronized (this) {mIdleHandlers.remove(idler);}}}// Reset the idle handler count to 0 so we do not run them again.pendingIdleHandlerCount = 0;// While calling an idle handler, a new message could have been delivered// so go back and look again for a pending message without waiting.nextPollTimeoutMillis = 0;}}

首先看局部变量nextPollTimeoutMillis，他是控制下一次poll的间隔。初始值为0，代表调用next时立即poll。
next函数的每次循环，都会调用poll，等待nextPollTimeoutMillis。
mMessages是一个属性变量Message。他代表Message单链表的首部。

poll后遍历取消息。
如果消息头的target为null，则说明该消息是一个同步屏障。
如果是同步屏障，则遍历取到第一个异步消息，并赋值给msg。

接下来对msg分几种情况：

  1. 如果遍历后msg为null，说明没有消息，则设置nextPollTimeoutMillis为-1。
  2. 如果有消息，但未到他的发布时间，则重新设置nextPollTimeoutMillis。
  3. 如果有消息，且到达他发布的时间，则将他从链表中拿出，设置为使用状态，然后return出去。

对于情况1，2还有一些本次循环的收尾工作：
如果调用了quit，则本次循环将调用dispose，并返回null告知Looper该停下了。
如果没设置IdleHandler，则直接进行下一次循环。
如果设置了IdleHandler，则调用他们，并清除nextPollTimeoutMillis

小结next

上面出现了一个新的词同步屏障，他的表现为target为null。
当设置了同步屏障之后，next函数将会忽略所有的同步消息，返回异步消息。换句话说就是，设置了同步屏障之后，Handler只会处理异步消息。再换句话说，同步屏障为Handler消息机制增加了一种简单的优先级机制，异步消息的优先级要高于同步消息。

Handler

构造函数
    public Handler(boolean async) {this(null, async);}public Handler(@Nullable Callback callback, boolean async) {if (FIND_POTENTIAL_LEAKS) {final Class<? extends Handler> klass = getClass();if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&(klass.getModifiers() & Modifier.STATIC) == 0) {Log.w(TAG, "The following Handler class should be static or leaks might occur: " +klass.getCanonicalName());}}mLooper = Looper.myLooper();if (mLooper == null) {throw new RuntimeException("Can't create handler inside thread " + Thread.currentThread()+ " that has not called Looper.prepare()");}mQueue = mLooper.mQueue;mCallback = callback;mAsynchronous = async;mIsShared = false;}public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async) {this(looper, callback, async, /* shared= */ false);}public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async,boolean shared) {mLooper = looper;mQueue = looper.mQueue;mCallback = callback;mAsynchronous = async;mIsShared = shared;}

不论是哪个构造函数，都是为了赋值mLooper、mQueue、mCallback、mAsynchronous、mIsShared

sendMessage & post & sendMessageDelayed
    public final boolean sendMessage(@NonNull Message msg) {return sendMessageDelayed(msg, 0);}public final boolean post(@NonNull Runnable r) {return  sendMessageDelayed(getPostMessage(r), 0);}public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {if (delayMillis < 0) {delayMillis = 0;}return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);}

这三个函数都是常规使用时的函数，最终都是调用sendMessageAtTime

sendMessageAtTime
    public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {MessageQueue queue = mQueue;if (queue == null) {RuntimeException e = new RuntimeException(this + " sendMessageAtTime() called with no mQueue");Log.w("Looper", e.getMessage(), e);return false;}return enqueueMessage(queue, msg, uptimeMillis);}private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,long uptimeMillis) {msg.target = this;msg.workSourceUid = ThreadLocalWorkSource.getUid();if (mAsynchronous) {msg.setAsynchronous(true);}return queue.enqueueMessage(msg, uptimeMillis);}

兜兜转转又回到了MessageQueue中，不过我们暂且不分析他。

要知道，Looper是传送带的轮子，loopOnce中取到一个Message就会调用msg.target.dispatchMessage(msg)

dispatchMessage
    public void dispatchMessage(@NonNull Message msg) {if (msg.callback != null) {handleCallback(msg);} else {if (mCallback != null) {if (mCallback.handleMessage(msg)) {return;}}handleMessage(msg);}}private static void handleCallback(Message message) {message.callback.run();}

没啥说的，就是正常的分发。

小总结

现在我们已经知道Handler体系工作的大致流程，接下来我们再次确认一下具体的线程切换是如何完成的

    class MainThread extends Thread {public Handler mHandler;public void run() {Looper.prepare();mHandler = new Handler(Looper.myLooper()) {public void handleMessage(Message msg) {// process incoming messages here}};Looper.loop();}}

主线程可以抽象成上述的简易模型，而我们的子线程，通过调用主线程mHandler的post方法等向主线程队列中插入一条消息。
主线程在Looper.loop()时取到消息，然后交给Handler处理。
如果消息是一个Runnable，则直接run。这相当于在主线程中执行。
如果消息不是Runnable，则交给handleMessage处理。

再探MessageQueue

上述对MessageQueue的分析只是大体一览，这个类在Frameworks中大有作用。例如removeAllFutureMessagesLocked、removeAllMessagesLocked和enqueueMessage这些方法，我们还没探索。mMessages、mNextBarrierToken还有Message的Asynchronous，我们一点点揭开。

enqueueMessage

上面有说Handler插入信息是用了queue.enqueueMessage。
那我们来看看他的具体实现

 boolean enqueueMessage(Message msg, long when) {if (msg.target == null) {throw new IllegalArgumentException("Message must have a target.");}synchronized (this) {if (msg.isInUse()) {throw new IllegalStateException(msg + " This message is already in use.");}if (mQuitting) {IllegalStateException e = new IllegalStateException(msg.target + " sending message to a Handler on a dead thread");Log.w(TAG, e.getMessage(), e);msg.recycle();return false;}msg.markInUse();msg.when = when;Message p = mMessages;boolean needWake;if (p == null || when == 0 || when < p.when) {// New head, wake up the event queue if blocked.msg.next = p;mMessages = msg;needWake = mBlocked;} else {// Inserted within the middle of the queue.  Usually we don't have to wake// up the event queue unless there is a barrier at the head of the queue// and the message is the earliest asynchronous message in the queue.needWake = mBlocked && p.target == null && msg.isAsynchronous();Message prev;for (;;) {prev = p;p = p.next;if (p == null || when < p.when) {break;}if (needWake && p.isAsynchronous()) {needWake = false;}}msg.next = p; // invariant: p == prev.nextprev.next = msg;}// We can assume mPtr != 0 because mQuitting is false.if (needWake) {nativeWake(mPtr);}}return true;}

该函数有有一句注释如下

// New head, wake up the event queue if blocked.
再结合上下文，这句话表明了mMessages是一个单链表的头部。

当首部为null，或when为0，或者待插入的Message的发生时间在首部之前。
则将当前信息变成新的首部。

这里要注意，上文中next函数如果取到了一个消息，则mBlocked = false;
同时没去出消息或者消息未到执行执行，且没有IdleHandler就会mBlocked = true;

如果存在首部，且待插入的信息发生时间在首部之后。
则将待插入的信息插入到正确的位置（按时间排序）。

接下来我们看看高级用法。使用同步屏障.

postSyncBarrier
    public int postSyncBarrier() {return postSyncBarrier(SystemClock.uptimeMillis());}private int postSyncBarrier(long when) {// Enqueue a new sync barrier token.// We don't need to wake the queue because the purpose of a barrier is to stall it.synchronized (this) {final int token = mNextBarrierToken++;final Message msg = Message.obtain();msg.markInUse();msg.when = when;msg.arg1 = token;Message prev = null;Message p = mMessages;if (when != 0) {while (p != null && p.when <= when) {prev = p;p = p.next;}}if (prev != null) { // invariant: p == prev.nextmsg.next = p;prev.next = msg;} else {msg.next = p;mMessages = msg;}return token;}}

就是简简单单的插入一个message。但请注意，这里的message并没有设置target，也就是target为null。这是一条屏障消息

removeSyncBarrier
public void removeSyncBarrier(int token) {// Remove a sync barrier token from the queue.// If the queue is no longer stalled by a barrier then wake it.synchronized (this) {Message prev = null;Message p = mMessages;while (p != null && (p.target != null || p.arg1 != token)) {prev = p;p = p.next;}if (p == null) {throw new IllegalStateException("The specified message queue synchronization "+ " barrier token has not been posted or has already been removed.");}final boolean needWake;if (prev != null) {prev.next = p.next;needWake = false;} else {mMessages = p.next;needWake = mMessages == null || mMessages.target != null;}p.recycleUnchecked();// If the loop is quitting then it is already awake.// We can assume mPtr != 0 when mQuitting is false.if (needWake && !mQuitting) {nativeWake(mPtr);}}}

更简单了，就是直接删掉。

同步屏障在Frameworks中的应用

实际上只有ViewRootImpl中有使用，目的是优先处理UI事件。
对应代码如下

void scheduleTraversals() {if (!mTraversalScheduled) {mTraversalScheduled = true;//设置同步障碍，确保mTraversalRunnable优先被执行mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();//内部通过Handler发送了一个异步消息mChoreographer.postCallback(Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);if (!mUnbufferedInputDispatch) {scheduleConsumeBatchedInput();}notifyRendererOfFramePending();pokeDrawLockIfNeeded();}
}

进阶知识

Handler中有很多关于Uid的处理，因为Messenger依赖Handler提供了IPC接口。
对于Messenger，他过于简单本文不再赘述。

MessageQueue的native部分使用了poll，因此他可以监听fd的一些事件，而MessageQueue确实也提供了诸如addOnFileDescriptorEventListener等一系列增删查FileDescriptorEventListener的功能。
该功能在Zygote中也有应用。在过后的博文中我可能会进行介绍。

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

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

相关文章

滑动窗口2

滑动窗口2

1. 水果成篮&#xff08;904&#xff09; 题目描述&#xff1a; 算法原理&#xff1a; 根据题目意思&#xff0c;friuts表示第i棵树上的水果种类&#xff0c;然后我们有两个篮子去在这些树上去采水果&#xff0c;但是有限制就是一个篮子里就只能装一种水果&#xff0c;也就是…
阅读更多...
矩阵运算在数据分析中的应用

矩阵运算在数据分析中的应用

矩阵运算在数据分析中的应用 大家好&#xff0c;我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编&#xff0c;也是冬天不穿秋裤&#xff0c;天冷也要风度的程序猿&#xff01; 矩阵运算作为数学和计算机科学中的重要概念&#xff0c;在数据分析和科学计算中发…
阅读更多...
elasticsearch源码分析-03选举集群状态

elasticsearch源码分析-03选举集群状态

选举集群状态 es中存储的数据有一下几种&#xff0c;state元数据、lucene索引文件、translog事务日志 元数据信息可以分为&#xff1a; 集群层面的元信息-对应着metaData数据结构&#xff0c;主要是clusterUUid、settings、templates等索引层面的元信息-对应着indexMetaData数…
阅读更多...
RK35x8通过TFTP下载内核到开发板

RK35x8通过TFTP下载内核到开发板

对于有网线接口的RK35X8开发板&#xff0c;调试时候&#xff0c;可以通过网线下载内核镜像和设备树到开发板&#xff0c;不用每次修改驱动都要重新打开下载工具&#xff0c;进入下载模式。通过TFTP可以大大提高调试效率。 在ubuntu安装TFTP服务 安装tftp服务器 sudo apt-get…
阅读更多...
【面试系列】前端开发工程师高频面试题及详细解答

【面试系列】前端开发工程师高频面试题及详细解答

欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;欢迎订阅相关专栏&#xff1a; ⭐️ 全网最全IT互联网公司面试宝典&#xff1a;收集整理全网各大IT互联网公司技术、项目、HR面试真题. ⭐️ AIGC时代的创新与未来&#xff1a;详细讲解AIGC的概念、核心技术、…
阅读更多...
Python商务数据分析知识专栏（二）——Python数据分析基础

Python商务数据分析知识专栏（二）——Python数据分析基础

Python商务数据分析知识专栏&#xff08;二&#xff09;——Python数据分析基础 一、Python数据分析概述二、Numpy数值计算基础专栏二&#xff08;Python数据分析基础&#xff09;的总结 与 专栏三&#xff08;Python数据分析的应用&#xff09;开端 一、Python数据分析概述 二…
阅读更多...
【笔记】Spring Cloud Gateway 实现 gRPC 代理

【笔记】Spring Cloud Gateway 实现 gRPC 代理

Spring Cloud Gateway 在 3.1.x 版本中增加了针对 gRPC 的网关代理功能支持,本片文章描述一下如何实现相关支持.本文主要基于 Spring Cloud Gateway 的 官方文档 进行一个实践练习。有兴趣的可以翻看官方文档。 由于 Grpc 是基于 HTTP2 协议进行传输的&#xff0c;因此 Srping …
阅读更多...
深度学习之Transformer模型的Vision Transformer（ViT）和Swin Transformer

深度学习之Transformer模型的Vision Transformer（ViT）和Swin Transformer

Transformer 模型最初由 Vaswani 等人在 2017 年提出，是一种基于自注意力机制的深度学习模型。它在自然语言处理（NLP）领域取得了巨大成功，并且也逐渐被应用到计算机视觉任务中。以下是两种在计算机视觉领域中非常重要的 Transformer 模型：Vision Transformer（ViT）和 Swi…
阅读更多...
git 个人常见错误备注

git 个人常见错误备注

问题1&#xff1a;all conflict fixed but you are still merging。。。。。 如果你已经解决了所有冲突&#xff0c;但 Git 仍然提示你正在进行合并&#xff0c;可能是因为你还没有完成合并过程。以下是详细步骤&#xff0c;确保你正确完成合并并提交更改&#xff1a; 确认所…
阅读更多...
Tongsuo(铜锁)项目介绍 - 实现国密SSL协议

Tongsuo(铜锁)项目介绍 - 实现国密SSL协议

文章介绍 铜锁（Tongsuo）是一个提供现代密码学算法和安全通信协议的开源基础密码库，为存储、网络、密钥管理、隐私计算、区块链等诸多业务场景提供底层的密码学基础能力，实现数据在传输、使用、存储等过程中的私密性、完整性和可认证性，为数据生命周期中的隐私和安全提供保…
阅读更多...
鸿蒙 如何 url decode

鸿蒙 如何 url decode

在 TypeScript 和 JavaScript 中进行 URL 编码的最简单方式是使用内置的 global 函数 encodeURIComponent()。以下是一个示例&#xff1a; let url "https://example.com/?name测试&job开发者"; let encodedURL encodeURIComponent(url); console.log(encode…
阅读更多...
【RAG】FoRAG：面向网络增强型长形式问答的事实性优化RAG

【RAG】FoRAG：面向网络增强型长形式问答的事实性优化RAG

一、解决问题 在基于网络的长形式问答&#xff08;Web-enhanced Long-form Question Answering, LFQA&#xff09;任务中&#xff0c;现有RAG在生成答案时存在的问题&#xff1a; 事实性不足&#xff1a;研究表明&#xff0c;现有系统生成的答案中只有大约一半的陈述能够完全得…
阅读更多...
Qt开发笔记：Qt3D三维开发笔记（一）：Qt3D三维开发基础概念介绍

Qt开发笔记：Qt3D三维开发笔记（一）：Qt3D三维开发基础概念介绍

若该文为原创文章&#xff0c;转载请注明原文出处 本文章博客地址&#xff1a;https://blog.csdn.net/qq21497936/article/details/140059315 长沙红胖子Qt&#xff08;长沙创微智科&#xff09;博文大全&#xff1a;开发技术集合&#xff08;包含Qt实用技术、树莓派、三维、O…
阅读更多...
汇编语言基础教程

汇编语言基础教程

汇编语言基础教程 大家好&#xff0c;我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编&#xff0c;也是冬天不穿秋裤&#xff0c;天冷也要风度的程序猿&#xff01;今天我们将深入探讨汇编语言的基础知识和应用&#xff0c;帮助大家理解汇编语言在计算机编程中…
阅读更多...
来自Claude官方的提示词库，支持中文！建议收藏！

来自Claude官方的提示词库，支持中文！建议收藏！

大家好，我是木易，一个持续关注AI领域的互联网技术产品经理，国内Top2本科，美国Top10 CS研究生，MBA。我坚信AI是普通人变强的“外挂”，所以创建了“AI信息Gap”这个公众号，专注于分享AI全维度知识，包括但不限于AI科普，AI工具测评，AI效率提升，AI行业洞察。关注我，AI之…
阅读更多...
多元时间序列分析——VAR（向量自回归模型）

多元时间序列分析——VAR（向量自回归模型）

VAR模型主要是考察多个变量之间的动态互动关系&#xff0c;从而解释各种经济冲击对经济变量形成的动态影响。这种动态关系可通过格兰杰因果关系、脉冲响应以及方差分解来进一步明确和可视化。VAR模型主要研究内生变量之间的关系&#xff0c;内生变量就是参与模型并由模型体系内…
阅读更多...
通天星CMSV6车载监控平台CompanyList信息泄露漏洞

通天星CMSV6车载监控平台CompanyList信息泄露漏洞

1 漏洞描述 通天星CMSV6车载视频监控平台是东莞市通天星软件科技有限公司研发的监控平台，通天星CMSV6产品覆盖车载录像机、单兵录像机、网络监控摄像机、行驶记录仪等产品的视频综合平台。通天星科技应用于公交车车载、校车车载、大巴车车载、物流车载、油品运输车载、警车车…
阅读更多...
推荐一款程序员的搞钱神器

推荐一款程序员的搞钱神器

你是不是经常为开发环境的搭建而头疼&#xff1f;有没有遇到过因为接口开发而焦头烂额的情况&#xff1f;作为一名程序员&#xff0c;特别是独立开发者&#xff0c;这些问题是不是常常让你觉得心力交瘁&#xff1f;别担心&#xff0c;现在有一个神器&#xff0c;能让你摆脱这些…
阅读更多...
五、golang基础之slice和map

五、golang基础之slice和map

文章目录 一、slice&#xff08;一&#xff09;含义&#xff08;二&#xff09;定义切片&#xff08;三&#xff09;切片初始化&#xff08;四&#xff09;len() 和 cap() 函数&#xff08;五&#xff09;空(nil)切片&#xff08;六&#xff09;切片截取&#xff08;七&#xf…
阅读更多...
2024HVV最新POC/EXP，目前有8000+个POC/EXP

2024HVV最新POC/EXP，目前有8000+个POC/EXP

点击"仙网攻城狮”关注我们哦~ 不当想研发的渗透人不是好运维 让我们每天进步一点点 简介 都是网上收集的POC和EXP&#xff0c;最新收集时间是2024年五月&#xff0c;需要的自取。 表里没有的可以翻翻之前的文章&#xff0c;资源比较零散没有整合起来。 文件链接&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023