bootstrap模板网站/seo实战培训教程

bootstrap模板网站,seo实战培训教程,网站标签的作用,新营销方式有哪些RxJava和RxAndroid是什么？ RxJava是基于JVM的响应式扩展，用于编写异步代码 RxAndroid是关于Android的RxJava绑定 RxJava和RxAndroid使用 依赖 implementation io.reactivex.rxjava3:rxjava:3.1.0 implementation io.reactivex.rxjava3:rxandroid:3.…

RxJava和RxAndroid是什么？

RxJava是基于JVM的响应式扩展，用于编写异步代码

RxAndroid是关于Android的RxJava绑定

RxJava和RxAndroid使用

依赖

implementation 'io.reactivex.rxjava3:rxjava:3.1.0'
implementation 'io.reactivex.rxjava3:rxandroid:3.0.2'

使用过程

如下模拟在子线程中进行耗时操作，并将结果返回到主线程中处理

  • Flowable：将要进行的操作
  • subscribeOn()：操作要运行的线程
  • observeOn() ：处理结果要运行的线程
  • subscribe()：处理结果
public class MainActivity extends AppCompatActivity {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);Flowable.fromCallable(() -> {Thread.sleep(3000);return "Done";}).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(System.out::println, Throwable::printStackTrace);}
}

内存泄漏问题

若Activity退出后，线程仍未执行完，会导致内存泄漏，需要在onDestroy()将任务取消

public class MainActivity extends AppCompatActivity {CompositeDisposable mCompositeDisposable  = new CompositeDisposable();@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);Disposable disposable = Flowable.fromCallable(() -> {Thread.sleep(3000);return "Done";}).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(System.out::println, Throwable::printStackTrace);mCompositeDisposable.add(disposable);}@Overrideprotected void onDestroy() {super.onDestroy();mCompositeDisposable.dispose();}
}

RxJava源码解析

Publisher

Publisher用于发布数据，Subscriber通过subscribe()订阅数据

public interface Publisher<T> {public void subscribe(Subscriber<? super T> s);
}

Subscriber

Subscriber接收Publisher发布的数据

  • onSubscribe()：subscribe()回调函数，回调前会创建Subscription用于控制数据发布和停止
  • onNext()：当Subscription调用request()时会调用onNext()发布数据
  • onError()：处理接收到的错误
  • onComplete()：处理完成的情况
public interface Subscriber<T> {public void onSubscribe(Subscription s);public void onNext(T t);public void onError(Throwable t);public void onComplete();
}

Subscription

Subscription表示Publisher和Subscriber的对应关系

  • request()：向Publisher请求数据
  • cancel()：让Publisher停止发布数据
public interface Subscription {public void request(long n);public void cancel();
}

Scheduler

createWorker()用于创建Worker ，具体的调度工作由Worker的schedule()完成

public abstract class Scheduler {public abstract Worker createWorker();public abstract static class Worker implements Disposable {@NonNullpublic Disposable schedule(@NonNull Runnable run) {return schedule(run, 0L, TimeUnit.NANOSECONDS);}public abstract Disposable schedule(@NonNull Runnable run, long delay, @NonNull TimeUnit unit);}
}

source传递过程

fromCallable()创建FlowableFromCallable，传递callable

public abstract class Flowable<@NonNull T> implements Publisher<T> {public static <@NonNull T> Flowable<T> fromCallable(@NonNull Callable<? extends T> callable) {return RxJavaPlugins.onAssembly(new FlowableFromCallable<>(callable));}
}

subscribeOn()创建FlowableSubscribeOn，传递this（即FlowableFromCallable）作为source

public abstract class Flowable<@NonNull T> implements Publisher<T> {public final Flowable<T> subscribeOn(@NonNull Scheduler scheduler) {Objects.requireNonNull(scheduler, "scheduler is null");return subscribeOn(scheduler, !(this instanceof FlowableCreate));}public final Flowable<T> subscribeOn(@NonNull Scheduler scheduler, boolean requestOn) {Objects.requireNonNull(scheduler, "scheduler is null");return RxJavaPlugins.onAssembly(new FlowableSubscribeOn<>(this, scheduler, requestOn));}
}

observeOn()创建FlowableObserveOn，传递this（即FlowableSubscribeOn）作为source

public abstract class Flowable<@NonNull T> implements Publisher<T> {public final Flowable<T> observeOn(@NonNull Scheduler scheduler) {return observeOn(scheduler, false, bufferSize());}public final Flowable<T> observeOn(@NonNull Scheduler scheduler, boolean delayError, int bufferSize) {Objects.requireNonNull(scheduler, "scheduler is null");ObjectHelper.verifyPositive(bufferSize, "bufferSize");return RxJavaPlugins.onAssembly(new FlowableObserveOn<>(this, scheduler, delayError, bufferSize));}
}

即依次将自身当作Flowable，作为参数source传递给下一个Flowable

subscribe()流程

subscribe()最终调用具体Flowable的subscribeActual()

public abstract class Flowable<@NonNull T> implements Publisher<T> {......public final Disposable subscribe(@NonNull Consumer<? super T> onNext, @NonNull Consumer<? super Throwable> onError) {return subscribe(onNext, onError, Functions.EMPTY_ACTION);}public final Disposable subscribe(@NonNull Consumer<? super T> onNext, @NonNull Consumer<? super Throwable> onError,@NonNull Action onComplete) {.....LambdaSubscriber<T> ls = new LambdaSubscriber<>(onNext, onError, onComplete, FlowableInternalHelper.RequestMax.INSTANCE);subscribe(ls);return ls;}public final void subscribe(@NonNull FlowableSubscriber<? super T> subscriber) {try {Subscriber<? super T> flowableSubscriber = RxJavaPlugins.onSubscribe(this, subscriber);......subscribeActual(flowableSubscriber);}......}protected abstract void subscribeActual(@NonNull Subscriber<? super T> subscriber);
}

调用过程和传递过程是相反的，先调用FlowableObserveOn的subscribeActual()

public final class FlowableObserveOn<T> extends AbstractFlowableWithUpstream<T, T> {......@Overridepublic void subscribeActual(Subscriber<? super T> s) {Worker worker = scheduler.createWorker();if (s instanceof ConditionalSubscriber) {.....} else {source.subscribe(new ObserveOnSubscriber<>(s, worker, delayError, prefetch));}}}

上面的source就是上一层传递下来的FlowableSubscribeOn，即调用到FlowableSubscribeOn的subscribeActual()

public final class FlowableSubscribeOn<T> extends AbstractFlowableWithUpstream<T , T> {......@Overridepublic void subscribeActual(final Subscriber<? super T> s) {Scheduler.Worker w = scheduler.createWorker();final SubscribeOnSubscriber<T> sos = new SubscribeOnSubscriber<>(s, w, source, nonScheduledRequests);.....w.schedule(sos);}static final class SubscribeOnSubscriber<T> extends AtomicReference<Thread>implements FlowableSubscriber<T>, Subscription, Runnable {......@Overridepublic void run() {lazySet(Thread.currentThread());Publisher<T> src = source;source = null;src.subscribe(this);}

schedule()最终会调用run()方法，lazySet()切换线程，上面的source就是上一层传递下来的FlowableFromCallable，即将到FlowableFromCallable的subscribeActual()放到指定线程中运行

public final class FlowableFromCallable<T> extends Flowable<T> implements Supplier<T> {final Callable<? extends T> callable;......@Overridepublic void subscribeActual(Subscriber<? super T> s) {DeferredScalarSubscription<T> deferred = new DeferredScalarSubscription<>(s);s.onSubscribe(deferred);T t;try {t = Objects.requireNonNull(callable.call(), "The callable returned a null value");} catch (Throwable ex) {Exceptions.throwIfFatal(ex);if (deferred.isCancelled()) {RxJavaPlugins.onError(ex);} else {s.onError(ex);}return;}deferred.complete(t);}......
}

上面若出错回调onError()，否则调用downstream的onNext()传递结果

public class DeferredScalarSubscription<@NonNull T> extends BasicIntQueueSubscription<T> {public final void complete(T v) {int state = get();for (;;) {......if (state == HAS_REQUEST_NO_VALUE) {lazySet(HAS_REQUEST_HAS_VALUE);Subscriber<? super T> a = downstream;a.onNext(v);if (get() != CANCELLED) {a.onComplete();}return;}value = v;......}}
}

onNext()过程

调用FlowableSubscribeOn.SubscribeOnSubscriber的onNext()，调用downstream的onNext()传递结果

public final class FlowableSubscribeOn<T> extends AbstractFlowableWithUpstream<T , T> {static final class SubscribeOnSubscriber<T> extends AtomicReference<Thread>implements FlowableSubscriber<T>, Subscription, Runnable {@Overridepublic void onNext(T t) {downstream.onNext(t);}}
}

调用FlowableObserveOn.BaseObserveOnSubscriber的onNext()、trySchedule()，schedule()最终会调用run()方法，根据sourceMode判断是同步还是异步

  • FlowableObserveOn.ObserveOnSubscriber的runSync()和runAsync()都调用downstream的onNext()传递结果
public final class FlowableObserveOn<T> extends AbstractFlowableWithUpstream<T, T> {.....abstract static class BaseObserveOnSubscriber<T>extends BasicIntQueueSubscription<T>implements FlowableSubscriber<T>, Runnable {@Overridepublic final void onNext(T t) {......trySchedule();}'final void trySchedule() {......worker.schedule(this);}@Overridepublic final void run() {if (outputFused) {runBackfused();} else if (sourceMode == SYNC) {runSync();} else {runAsync();}}}static final class ObserveOnSubscriber<T> extends BaseObserveOnSubscriber<T>implements FlowableSubscriber<T> {void runSync() {......final Subscriber<? super T> a = downstream;......for (;;) {......while (e != r) {......a.onNext(v);......}......}}.....@Overridevoid runAsync() {final Subscriber<? super T> a = downstream;for (;;) {......while (e != r) {.....a.onNext(v);.....}.....}}}
}

调用LambdaSubscriber的onNext()，通过传入的Consumer消费掉最终的结果，即通过System.out::println打印出来

public final class LambdaSubscriber<T> extends AtomicReference<Subscription>implements FlowableSubscriber<T>, Subscription, Disposable, LambdaConsumerIntrospection {.....@Overridepublic void onNext(T t) {if (!isDisposed()) {try {onNext.accept(t);} catch (Throwable e) {Exceptions.throwIfFatal(e);get().cancel();onError(e);}}}
}

onSubscribe()和request()流程

FlowableFromCallable回调下一层的onSubscribe()，其将Subscription存到upstream

public final class FlowableFromCallable<T> extends Flowable<T> implements Supplier<T> {final Callable<? extends T> callable;@Overridepublic void subscribeActual(Subscriber<? super T> s) {DeferredScalarSubscription<T> deferred = new DeferredScalarSubscription<>(s);s.onSubscribe(deferred);......}
}public final class FlowableSubscribeOn<T> extends AbstractFlowableWithUpstream<T , T> {static final class SubscribeOnSubscriber<T> extends AtomicReference<Thread>implements FlowableSubscriber<T>, Subscription, Runnable {@Overridepublic void onSubscribe(Subscription s) {if (SubscriptionHelper.setOnce(this.upstream, s)) {......}}}
}

FlowableSubscribeOn回调下一层的onSubscribe()，其回调下一层的onSubscribe()和上一层的request()请求数据

public final class FlowableSubscribeOn<T> extends AbstractFlowableWithUpstream<T , T> {......@Overridepublic void subscribeActual(final Subscriber<? super T> s) {Scheduler.Worker w = scheduler.createWorker();final SubscribeOnSubscriber<T> sos = new SubscribeOnSubscriber<>(s, w, source, nonScheduledRequests);s.onSubscribe(sos);}   
}public final class FlowableObserveOn<T> extends AbstractFlowableWithUpstream<T, T> {static final class ObserveOnSubscriber<T> extends BaseObserveOnSubscriber<T>implements FlowableSubscriber<T> {......@Overridepublic void onSubscribe(Subscription s) {if (SubscriptionHelper.validate(this.upstream, s)) {this.upstream = s;......queue = new SpscArrayQueue<>(prefetch);downstream.onSubscribe(this);s.request(prefetch);}}}
}

LambdaSubscriber利用FlowableInternalHelper.RequestMax的accept()调用上一层的request()，从schedule()获取数据

public final class LambdaSubscriber<T> extends AtomicReference<Subscription>implements FlowableSubscriber<T>, Subscription, Disposable, LambdaConsumerIntrospection {@Overridepublic void onSubscribe(Subscription s) {if (SubscriptionHelper.setOnce(this, s)) {try {onSubscribe.accept(this);} catch (Throwable ex) {......}}}}public final class FlowableInternalHelper {public enum RequestMax implements Consumer<Subscription> {INSTANCE;@Overridepublic void accept(Subscription t) {t.request(Long.MAX_VALUE);}}
}public final class FlowableObserveOn<T> extends AbstractFlowableWithUpstream<T, T> {abstract static class BaseObserveOnSubscriber<T>extends BasicIntQueueSubscription<T>implements FlowableSubscriber<T>, Runnable {@Overridepublic final void request(long n) {if (SubscriptionHelper.validate(n)) {BackpressureHelper.add(requested, n);trySchedule();}}final void trySchedule() {......worker.schedule(this);}}
}

FlowableSubscribeOn.SubscribeOnSubscriber的request()、requestUpstream()判断当前线程，若未切换线程调用schedule()切换线程调用上一层的request()

public final class FlowableSubscribeOn<T> extends AbstractFlowableWithUpstream<T , T> {static final class SubscribeOnSubscriber<T> extends AtomicReference<Thread>implements FlowableSubscriber<T>, Subscription, Runnable {@Overridepublic void request(final long n) {if (SubscriptionHelper.validate(n)) {Subscription s = this.upstream.get();if (s != null) {requestUpstream(n, s);} else {......}}}}void requestUpstream(final long n, final Subscription s) {if (nonScheduledRequests || Thread.currentThread() == get()) {s.request(n);} else {worker.schedule(new Request(s, n));}}static final class Request implements Runnable {......@Overridepublic void run() {upstream.request(n);}}}
}

DeferredScalarSubscription接收到请求后，将值传给downstream的onNext()

public class DeferredScalarSubscription<@NonNull T> extends BasicIntQueueSubscription<T> {@Overridepublic final void request(long n) {if (SubscriptionHelper.validate(n)) {for (;;) {int state = get();......if (state == NO_REQUEST_HAS_VALUE) {if (compareAndSet(NO_REQUEST_HAS_VALUE, HAS_REQUEST_HAS_VALUE)) {T v = value;if (v != null) {value = null;Subscriber<? super T> a = downstream;a.onNext(v);if (get() != CANCELLED) {a.onComplete();}}}return;}......}}}
}

Schedulers.io()调度过程

Schedulers.io() = Schedulers.IO = IOTask() = IoHolder.DEFAULT = IoScheduler()

public final class Schedulers {static final Scheduler IO;static final class IoHolder {static final Scheduler DEFAULT = new IoScheduler();}static {IO = RxJavaPlugins.initIoScheduler(new IOTask());}public static Scheduler io() {return RxJavaPlugins.onIoScheduler(IO);}static final class IOTask implements Supplier<Scheduler> {@Overridepublic Scheduler get() {return IoHolder.DEFAULT;}}
}

FlowableSubscribeOn的subscribeActual()通过IoScheduler创建Worker并调用schedule()

public final class FlowableSubscribeOn<T> extends AbstractFlowableWithUpstream<T , T> {......@Overridepublic void subscribeActual(final Subscriber<? super T> s) {Scheduler.Worker w = scheduler.createWorker();final SubscribeOnSubscriber<T> sos = new SubscribeOnSubscriber<>(s, w, source, nonScheduledRequests);.....w.schedule(sos);}
}

调用IoScheduler的createWorker()会返回EventLoopWorker

public final class IoScheduler extends Scheduler {@NonNull@Overridepublic Worker createWorker() {return new EventLoopWorker(pool.get());}
}

调用IoScheduler.EventLoopWorker的schedule()最终调用ThreadWorker的父类NewThreadWorker的scheduleActual()

public final class IoScheduler extends Scheduler {static final class EventLoopWorker extends Scheduler.Worker implements Runnable {@NonNull@Overridepublic Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {......return threadWorker.scheduleActual(action, delayTime, unit, tasks);}}static final class ThreadWorker extends NewThreadWorker {......}
}

调用scheduleActual()将Runnable封装成ScheduledRunnable，通过ScheduledThreadPoolExecutor的submit()或schedule()提交

public class NewThreadWorker extends Scheduler.Worker implements Disposable {private final ScheduledExecutorService executor;volatile boolean disposed;public NewThreadWorker(ThreadFactory threadFactory) {executor = SchedulerPoolFactory.create(threadFactory);}@NonNullpublic ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {Runnable decoratedRun = RxJavaPlugins.onSchedule(run);ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);......Future<?> f;try {if (delayTime <= 0) {f = executor.submit((Callable<Object>)sr);} else {f = executor.schedule((Callable<Object>)sr, delayTime, unit);}sr.setFuture(f);} catch (RejectedExecutionException ex) {......}return sr;}
}public final class SchedulerPoolFactory {public static ScheduledExecutorService create(ThreadFactory factory) {final ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1, factory);exec.setRemoveOnCancelPolicy(PURGE_ENABLED);return exec;}
}

线程池会调用FlowableSubscribeOn.SubscribeOnSubscriber的run()方法，SubscribeOnSubscriber继承了AtomicReference<Thread>，lazySet()切换线程调用上一层source的subscribe()

public final class FlowableSubscribeOn<T> extends AbstractFlowableWithUpstream<T , T> {static final class SubscribeOnSubscriber<T> extends AtomicReference<Thread>implements FlowableSubscriber<T>, Subscription, Runnable {@Overridepublic void run() {lazySet(Thread.currentThread());Publisher<T> src = source;source = null;src.subscribe(this);}}}

AndroidSchedulers.mainThread()调度过程

AndroidSchedulers.mainThread() = AndroidSchedulers.MAIN_THREAD = MainHolder.DEFAULT = HandlerScheduler()，通过主线程Looper创建handler

public final class AndroidSchedulers {private static final class MainHolder {static final Scheduler DEFAULT = internalFrom(Looper.getMainLooper(), true);}private static final Scheduler MAIN_THREAD =RxAndroidPlugins.initMainThreadScheduler(() -> MainHolder.DEFAULT);}public static Scheduler mainThread() {return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);}private static Scheduler internalFrom(Looper looper, boolean async) {......return new HandlerScheduler(new Handler(looper), async);}
}

FlowableObserveOn的subscribeActual()通过IoScheduler创建Worker，在onNext()的trySchedule()调用schedule()

public final class FlowableObserveOn<T> extends AbstractFlowableWithUpstream<T, T> {@Overridepublic void subscribeActual(Subscriber<? super T> s) {Worker worker = scheduler.createWorker();if (s instanceof ConditionalSubscriber) {......} else {source.subscribe(new ObserveOnSubscriber<>(s, worker, delayError, prefetch));}}abstract static class BaseObserveOnSubscriber<T>extends BasicIntQueueSubscription<T>implements FlowableSubscriber<T>, Runnable {@Overridepublic final void onNext(T t) {......trySchedule();}final void trySchedule() {......worker.schedule(this);}}
}

调用HandlerScheduler的createWorker()返回HandlerWorker()

final class HandlerScheduler extends Scheduler {@Overridepublic Worker createWorker() {return new HandlerWorker(handler, async);}
}

调用HandlerScheduler.HandlerWorker的schedule()，将Runnable封装成ScheduledRunnable，调用主线程handler的sendMessageDelayed()

final class HandlerScheduler extends Scheduler {private static final class HandlerWorker extends Worker {@Overridepublic Disposable schedule(Runnable run, long delay, TimeUnit unit) {......run = RxJavaPlugins.onSchedule(run);ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);Message message = Message.obtain(handler, scheduled);message.obj = this; if (async) {message.setAsynchronous(true);}handler.sendMessageDelayed(message, unit.toMillis(delay));......return scheduled;}}
}

最终主线程会调用FlowableObserveOn.BaseObserveOnSubscriber的run()，根据sourceMode判断是同步还是异步

  • FlowableObserveOn.ObserveOnSubscriber的runSync()和runAsync()都调用downstream的onNext()传递结果
public final class FlowableObserveOn<T> extends AbstractFlowableWithUpstream<T, T> {.....abstract static class BaseObserveOnSubscriber<T>extends BasicIntQueueSubscription<T>implements FlowableSubscriber<T>, Runnable {......@Overridepublic final void run() {if (outputFused) {runBackfused();} else if (sourceMode == SYNC) {runSync();} else {runAsync();}}}static final class ObserveOnSubscriber<T> extends BaseObserveOnSubscriber<T>implements FlowableSubscriber<T> {void runSync() {......final Subscriber<? super T> a = downstream;......for (;;) {......while (e != r) {......a.onNext(v);......}......}}.....@Overridevoid runAsync() {final Subscriber<? super T> a = downstream;for (;;) {......while (e != r) {.....a.onNext(v);.....}.....}}}
}

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

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

相关文章

并发基础—三大问题：可见性、原子性、有序性

并发基础—三大问题：可见性、原子性、有序性

文章目录 可见性原子性有序性&#xff08;指令重排&#xff09;经典的指令重排案例&#xff1a;单例模式的双重检查锁volatile和synchronize都可以保证有序性并发压测工具Jcstress证明指令重排会在多线程下出现问题&#xff08;了解&#xff09;CPU缓存分为三个级别&#xff1a…
阅读更多...
PyTorch 入门学习

PyTorch 入门学习

目录 PyTorch 定义 核心作用 应用场景 Pytorch 基本语法 1. 张量的创建 2. 张量的类型转换 3. 张量数值计算 4. 张量运算函数 5. 张量索引操作 6. 张量形状操作 7. 张量拼接操作 8. 自动微分模块 9. 案例-线性回归案例 PyTorch 定义 PyTorch 是一个基于 Python 深…
阅读更多...
Spring Cloud 中的服务注册与发现: Eureka详解

Spring Cloud 中的服务注册与发现: Eureka详解

1. 背景 1.1 问题描述 我们如果通过 RestTamplate 进行远程调用时&#xff0c;URL 是写死的&#xff0c;例如&#xff1a; String url "http://127.0.0.1:9090/product/" orderInfo.getProductId(); 当机器更换或者新增机器时&#xff0c;这个 URL 就需要相应地变…
阅读更多...
网页制作15-Javascipt时间特效の记录网页停留时间

网页制作15-Javascipt时间特效の记录网页停留时间

01效果图&#xff1a; 02运用&#xff1a; window.setTimeout&#xff08;&#xff09;刷新function&#xff08;&#xff09;函数document.forms&#xff08;&#xff09;&#xff1a;表单if条件语句window.alert&#xff08;&#xff09;窗口警示 03、操作代码&#xff1a;…
阅读更多...
C++ std::list超详细指南：基础实践（手搓list）

C++ std::list超详细指南：基础实践（手搓list）

目录 一.核心特性 1.双向循环链表结构 2.头文件&#xff1a;#include 3.时间复杂度 4.内存特性 二.构造函数 三.list iterator的使用 1.学习list iterator之前我们要知道iterator的区分 ​编辑 2.begin()end() 3.rbegin()rend() 四.list关键接口 1.empty() 2. size…
阅读更多...
996引擎 - 红点系统

996引擎 - 红点系统

996引擎 - 红点系统 总结NPC 红点（TXT红点）Lua 红点1. Red_Point.lua2. UI_Ex.lua参考资料以下内容是在三端 lua 环境下测试的 总结 红点系统分几个部分组成。 M2中设置变量推送。 配置红点表。 Envir\Data\cfg_redpoint.xls 2.1. UI元素中找到ID填写 ids 列。 主界面挂载…
阅读更多...
PySide(PyQt)，使用types.MethodType动态定义事件

PySide(PyQt)，使用types.MethodType动态定义事件

以PySide(PyQt)的图片项为例&#xff0c;比如一个视窗的场景底图是一个QGraphicsPixmapItem&#xff0c;需要修改它的鼠标滚轮事件&#xff0c;以实现鼠标滚轮缩放显示的功能。为了达到这个目的&#xff0c;可以重新定义一个QGraphicsPixmapItem类&#xff0c;并重写它的wheelE…
阅读更多...
【eNSP实战】三层交换机使用ACL实现网络安全

【eNSP实战】三层交换机使用ACL实现网络安全

拓图 要求&#xff1a; vlan1可以访问Internetvlan2和vlan3不能访问Internet和vlan1vlan2和vlan3之间可以互相访问PC配置如图所示&#xff0c;这里不展示 LSW1接口vlan配置 vlan batch 10 20 30 # interface Vlanif1ip address 192.168.40.2 255.255.255.0 # interface Vla…
阅读更多...
Unity中WolrdSpace下的UI展示在上层

Unity中WolrdSpace下的UI展示在上层

一、问题描述 Unity 中 Canvas使用World Space布局的UI&#xff0c;想让它不被3d物体遮挡&#xff0c;始终显示在上层。 二、解决方案 使用shader解决 在 UI 的材质中禁用深度测试&#xff08;ZTest&#xff09;&#xff0c;强制 UI 始终渲染在最上层。 Shader "Custo…
阅读更多...
五子棋小游戏-简单开发版

五子棋小游戏-简单开发版

一、需求分析 开发一个基于 Pygame 库的五子棋小游戏&#xff0c;允许两名玩家在棋盘上轮流落子&#xff0c;当有一方达成五子连珠时游戏结束&#xff0c;显示获胜信息&#xff0c;并提供退出游戏和重新开始游戏的操作选项。 1.棋盘显示 &#xff1a; 显示一个 15x15 的五子棋…
阅读更多...
小秋的矩阵

小秋的矩阵

0小秋的矩阵 - 蓝桥云课 问题描述 给你一个 n 行 m 列只包含 0 和 1 的矩阵&#xff0c;求它的所有子矩阵中&#xff0c;是方阵而且恰好包含 k 个 0 的数量。 方阵是行数和列数相等的矩阵。 子矩阵是从一个矩阵当中选取某些行和某些列交叉位置所组成的新矩阵&#xff08;保…
阅读更多...
晶晨S905L3芯片_原机安卓4升级安卓9.0_通刷线刷固件包

晶晨S905L3芯片_原机安卓4升级安卓9.0_通刷线刷固件包

晶晨S905L3芯片_原机安卓4升级安卓9.0_通刷线刷固件包 线刷方法&#xff1a;&#xff08;新手参考借鉴一下&#xff09; 1、准备好一根双公头USB线刷刷机线&#xff0c;长度30-50CM长度最佳&#xff0c;同时准备一台电脑&#xff1b; 2、电脑上安装好刷机工具Amlogic USB Bu…
阅读更多...
谷歌Chrome或微软Edge浏览器修改网页任意内容

谷歌Chrome或微软Edge浏览器修改网页任意内容

在谷歌或微软浏览器按F12&#xff0c;打开开发者工具&#xff0c;切换到console选项卡&#xff1a; 在下面的输入行输入下面的命令回车&#xff1a; document.body.contentEditable"true"效果如下&#xff1a;
阅读更多...
【生日蛋糕——DFS剪枝优化】

【生日蛋糕——DFS剪枝优化】

题目 分析 代码 #include <bits/stdc.h> using namespace std;const int N 24; const int inf 0x3f3f3f3f;int mins[N], minv[N]; int R[N], H[N]; int n, m, ans inf;void dfs(int u, int v, int s) {if(v minv[u] > n) return;if(s mins[u] > ans) return;…
阅读更多...
短视频下载去水印，用什么工具好？

短视频下载去水印，用什么工具好？

去除视频和图片水印是许多用户的需求&#xff0c;尤其是在分享或保存内容时。以下是6款超好用的工具&#xff0c;帮助你轻松去除水印&#xff0c;享受纯净的视觉体验&#xff1a; 1. 易下载去水印小程序 特点&#xff1a; 操作简单&#xff0c;支持抖音、快手、小红书、哔哩哔哩…
阅读更多...
设计模式(行为型)-备忘录模式

设计模式(行为型)-备忘录模式

目录 定义 类图 角色 角色详解 &#xff08;一&#xff09;发起人角色&#xff08;Originator&#xff09;​ &#xff08;二&#xff09;备忘录角色&#xff08;Memento&#xff09;​ &#xff08;三&#xff09;备忘录管理员角色&#xff08;Caretaker&#xff09;​…
阅读更多...
【技术报告】谷歌开源多模态大模型 Gemma-3

【技术报告】谷歌开源多模态大模型 Gemma-3

【技术报告】谷歌开源多模态大模型 Gemma-3 1. Gemma-3 简介1.1 Gemma-3 的新功能1.2 与现有工作流的集成1.3 开始使用 Gemma-3 Gemma-3 技术报告&#xff1a;摘要Gemma-3 技术报告&#xff1a;1. 引言Gemma-3 技术报告&#xff1a;2. 模型架构2.1 视觉模态2.2 预训练2.3 量化感…
阅读更多...
[ISP] 人眼中的颜色

[ISP] 人眼中的颜色

相机是如何记录颜色的&#xff0c;又是如何被显示器还原的&#xff1f; 相机通过记录RGB数值然后显示器显示RGB数值来实现颜色的记录和呈现。道理是这么个道理&#xff0c;但实际上各厂家生产的相机对光的响应各不相同&#xff0c;并且不同厂家显示器对三原色的显示也天差地别&…
阅读更多...
InfiniBand可靠连接（RC）模式：设计原理、核心机制与应用实践

InfiniBand可靠连接（RC）模式：设计原理、核心机制与应用实践

引言 InfiniBand作为一种高性能网络互连技术&#xff0c;广泛应用于超算集群、分布式存储和金融交易系统等领域。其可靠连接&#xff08;Reliable Connection, RC&#xff09;模式以硬件级的有序性、可靠性和低延迟特性成为关键场景的首选。本文结合技术原理、机制对比和实际应…
阅读更多...
【网络】Caddy 服务器如何提供 TLS（Transport Layer Security）（传输层安全协议）

【网络】Caddy 服务器如何提供 TLS（Transport Layer Security）（传输层安全协议）

这张图片介绍了 Caddy 服务器如何提供 TLS&#xff08;传输层安全协议&#xff09; 支持&#xff0c;确保通信的安全性。以下是对图片内容的详细分析 1. Caddy 是什么&#xff1f; Caddy 是一个现代化的 Web 服务器&#xff0c;以其简单易用和自动化的 HTTPS 支持而闻名。它内…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023