其实，第一章节，只是让你了解下Flow的基本情况。我们开发中，基本很少使用这种模式。所以来讲，我们甚至可以直接使用StateFlow和SharedFlow才是正途。这是很多教程没有说明的点。所以第一章随便浏览下即可。日后再补充理解都是可以的。

1. 基本接触Flow

//第一步：定义flow{}
class FlowStudyViewModel : ViewModel() {val timeFlow = flow {logt { "flow start..." }var time = 0while (true) {logt { "flow begin..." }emit("" + time++)Thread.sleep(3*1000) //模拟耗时操作logt { "flow end..." }}}
}//第二步：订阅收集数据和显示。collect是挂起函数。
lifecycleScope.launch {viewModel.timeFlow.collect{ time->logt { "flow get data " }showInfoTv.text = time}
}

学习kotlin的协程，flow等知识点，我一直很关心它的运行线程在哪里，这样能更深入的理解它的设计理念和我们UI更新的方式。

上述代码，是最简单的使用，但是是存在问题的。界面会卡死。因为flow没有指定运行线程。它是跑在主线程里面。因此，我们加上：

flow{//...
}.flowOn(Dispatchers.IO) //指定运行线程

紧接着，我们尝试修改：

//第二步：订阅收集数据和显示。collect是挂起函数。
lifecycleScope.launch {viewModel.timeFlow.collect{ time->delay(2000) //add：接收的处理效率调整logt { "flow get data " }showInfoTv.text = time}
}

我们增加一句，影响收集处的执行间隔。最后就会得到如下日志：

SubThread[84]: flow begin...18
MainThread: flow get data 12
SubThread[84]: flow end...
SubThread[84]: flow begin...19
MainThread: flow get data 13
SubThread[84]: flow end...
SubThread[84]: flow begin...20
SubThread[84]: flow end...
MainThread: flow get data 14
MainThread: flow get data 15
MainThread: flow get data 16

就是数据会快，已经执行完毕，而收集处的处理慢慢继续执行。

如果我们不想要中间的执行结果，就使用collectLatest:

viewModel.timeFlow.collectLatest{ time->  //替代collect

collect 对上游数据流流发出的每个值都收集并完整执行 lambda 函数的操作，而 collectLatest 如果在前一个值收集并执行 lambda 完成之前发出新值，则取消任何正在进行的收集和 lambda 函数。

稍微再讲讲这句话的意思：

比如：

lifecycleScope.launch {viewModel.timeFlow.collectLatest{ time->logt { "flow get data $time" }showInfoTv.text = timedelay(5000) //在操作前与后}
}flow {while (totalCount++ <= 20) {logt { "flow begin...$time" }emit("" + time++)delay(1000)logt { "flow end..." }}
}

由于收集处速度执行不够快，新的数据又来了，如果是collect函数，则会慢慢完整执行整个collect的函数。而collectLatest则会取消后续的操作。两种不同的设计，注意区别。

本章知识点小结：

  • collect是挂起函数，需要scope launch执行；
  • flow{}定义的是冷流，必须主动collect才会执行；emit发射数据；
  • flow{}的运行线程通过flowOn修改。查看flowOn的注释，有介绍其他操作符分割后的执行区别和连续调用的第一个优先级。
  • collect vs collectLatest ： 数据流的执行时间和收集函数体的执行取消与否。

取消

就是kotlin的挂起函数，去掉collect的Job即可。或者有生命周期的Scope限定自行取消。

2. 常用操作符

rxjava，或者，java Collection stream用过的，对于map，filter等操作符肯定不陌生。

flowOn

前面已经接触过了，用来切换线程选择。

map/filter/onEach

val timeFlow = flow {var time = 0var totalCount = 0while (totalCount++ <= 20) {logt { "flow begin...$time" }emit( time++)delay(1000)}
}.map { time->logt { "map begin: $time" }"time: $time"
}.flowOn(Dispatchers.IO)

map: 将第一段执行的emit int型，转成了String型。

.filter { time->time % 3 == 0
}

filter: lamda返回boolean值来进行数据流过滤。

onEach: 遍历。略。

catch

catch 操作符可以捕获来自上游的异常。

flow {emit(1)throw RuntimeException()
}
.onCompletion { cause ->if (cause != null)println("Flow completed exceptionally")elseprintln("Done")
}
.catch{ println("catch exception") }
.collect{ println(it) }//结果：
1
Flow completed exceptionally
catch exception//onCompletion、catch 交换一下位置：
flow {emit(1)throw RuntimeException()
}
.catch{ println("catch exception") }
.onCompletion { cause ->if (cause != null)println("Flow completed exceptionally")elseprintln("Done")
}
.collect { println(it) }//执行结果
1
catch exception
Done

debounce

防抖，目前还是实验性质。

主要使用场景，就是输入框，监听文本变化，然后抉择是不是应该马上使用呢？

以前类似这种代码都见过吧：

handler.remove(mRunnable)
handler.postDelay(mRunnable, 1000)

在Flow的流式编程方式下，使用dobounce，来帮你过滤。

在给定的timeout间隔过滤最新的值。最新的值始终会被发送：
Example:
flow {emit(1)delay(90)emit(2)delay(90)emit(3)delay(1010)emit(4)delay(1010)emit(5)
}.debounce(1000)
得到结果：
3, 4, 5
注意：如果原流发射数据快于timeout才能被发射。

比如3这里，发射以后，时间超过了timeout才能被发送出去，如果下一次emit来的太快就被过滤掉了。

sample

.sample(1000)

采样，传入timeout值即可。隔这么久得到一次数据。

take

仅收集流中前 N 个元素，后续元素会被忽略。

flowOf(1, 2, 3, 4, 5).take(3) // 仅收集前 3 个元素（1, 2, 3）.collect { println(it) }// 输出：1 → 2 → 3

终止符

collect/collectLatest

略。最常用的。

reduce

与collect类似，都是挂起函数。这些操作符是用来终结flow流程的。

  • 求和、求积、字符串拼接等累积操作。
  • 需要将流数据转换为单一聚合值。
val sum = flowOf(1, 2, 3, 4, 5).reduce { acc, value -> acc + value }println(sum) // 输出：15（1+2+3+4+5）val result = flow {for (i in ('A'..'Z')) {emit(i.toString())}
}.fold("test: ") { acc, value -> acc + value}
println(result) //输出：test: ABCDEFG...Z
fold

比reduce多了一个默认入参。reduce和fold，在实际使用较少，有类似场景回头学习。

多流操作符

我们前面介绍的操作符，都是单独一个Flow，这一小节介绍，多个Flow操作。用法和难度都比较复杂。本章节对于刚学Flow的童鞋，建议跳过，简略浏览本章节，了解一下它们的作用，以后再学习。

flatMapConcat
sendGetTokenRequest().flatMapConcat { token ->sendGetUserInfoRequest(token)}.flowOn(Dispatchers.IO).collect { userInfo ->println(userInfo)}flow1.flatMapConcat { flow2 }.flatMapConcat { flow3 }.flatMapConcat { flow4 }.collect { userInfo ->println(userInfo)}

如上述代码，遇到嵌套请求的问题，比如我们去拿用户信息的时候，需要先请求Token数据，再拿Token去请求用户信息，这里使用flatMapConcat比较合适。保证emit结果顺序。

flatMapMerge

与flatMapConcat不同点是不保证顺序。

flatMapLatest

与flatMapMerge/flatMapContact，和collectLatest类似，如果来不及处理就将会丢弃。

flow {emit(1)delay(150)emit(2)delay(50)emit(3)
}.flatMapLatest {flow {delay(100)emit("$it")}
}.collect {println(it)}
打印：  
1
3
zip

flatMap是串行的。zip是并行的。

n sendRealtimeWeatherRequest(): Flow<String> = flow {// send request to realtime weatheremit(realtimeWeather)
}fun sendSevenDaysWeatherRequest(): Flow<String> = flow {// send request to get 7 days weatheremit(sevenDaysWeather)
}fun sendWeatherBackgroundImageRequest(): Flow<String> = flow {// send request to get weather background imageemit(weatherBackgroundImage)
}fun main() {runBlocking {sendRealtimeWeatherRequest().zip(sendSevenDaysWeatherRequest()) { realtimeWeather, sevenDaysWeather ->weather.realtimeWeather = realtimeWeatherweather.sevenDaysWeather = sevenDaysWeatherweather}.zip(sendWeatherBackgroundImageRequest()) { weather, weatherBackgroundImage ->weather.weatherBackgroundImage = weatherBackgroundImageweather}.collect { weather ->}}
}
combine

Flow 操作符 zip 和 combine 都是 Flow 的扩展函数，是用来实现合并流的操作符（组合操作符），都可以将两个流合并为一个流

zip 用于将两个流中的元素合并在一起，当两个流中都有元素就会将这些元素组成一个新元素发出，如果任何一个流没有元素，就不会发出任何元素，如果其中一个流发送的元素比另一个慢，就会等待另一个流发送元素，意味着合并元素操作是同步的

combine 用于将两个流中的最新元素组合在一起，至少有一个流有新的元素的话，组合操作就会继续进行下去，如果其中一个流发送的元素比另一个慢，就会使用最新的元素。

  • zip 操作符：同时进行两个网络 Api 接口的调用，并在两个接口都调用完成后一起给出结果（实现在一个回调中返回两个网络请求的结果）进行下一步处理。zip 可以将两个流中的元素成对进行合并处理，适用于两个流长度相等或者只关心较短长度的流的元素的场景，先发射的元素会等待对应顺序的后发射的元素到来后才进行合并操作。
  • combine 操作符：同时监听多个输入字段的状态（比如用户名、密码），只有当所有的输入都满足条件时才启用登录提交的按钮。combine 可以将两个流中的最新的元素组合在一起，适用于需要基于多个流的最新状态进行处理的场景，只要任意一个流发出新元素就会触发组合操作。
buffer

buffer函数其实就是一种背压的处理策略，它提供了一份缓存区，当Flow数据流速不均匀的时候，使用这份缓存区来保证程序运行效率。

flow函数只管发送自己的数据，它不需要关心数据有没有被处理，反正都缓存在buffer当中。

而collect函数只需要一直从buffer中获取数据来进行处理就可以了。

但是，如果流速不均匀问题持续放大，缓存区的内容越来越多时又该怎么办呢？

这个时候，我们又需要引入一种新的策略了，来适当地丢弃一些数据。

那么进入到本篇文章的最后一个操作符函数：conflate。

conflate

buffer函数最大的问题在于，不管怎样调整它缓冲区的大小（buffer函数可以通过传入参数来指定缓冲区大小），都无法完全地保障程度的运行效果。究其原因，主要还是因为buffer函数不会丢弃数据。

而在某些场景下，我们可能并不需要保留所有的数据。

比如拿股票软件举例，服务器端会将股票价格的实时数据源源不断地发送到客户端这边，而客户端这边只需要永远显示最新的股票价格即可，将过时的数据展示给用户是没有意义的。

因此，这种场景下使用buffer函数来提升运行效率就完全不合理，它会缓存太多完全没有必要保留的数据。

那么针对这种场景，其中一个可选的方案就是借助我们在上篇文章中学习的collectLatest函数。

而collectLatest会当有新数据到来时而前一个数据还没有处理完，则会将前一个数据剩余的处理逻辑全部取消，可能不是我们预期的结果。

而使用conflate有些数据则被完全丢弃掉了。因为当上一条数据处理完时，又有更新的数据发送过来了，那么这些过期的数据就会被直接舍弃。

3. 生命周期

3.1 自行把控生命周期

val timeFlow = flow {var time = 0while (true) {logd{"emit $time"}emit(time)delay(1000)time++}}//显然有问题：home退到后台，仍然在跑，持续打印日志emit和collect
lifecycleScope.launch {viewModel.timeFlow.collect { d->logd { "flow collect $d" }showInfoTv.text = "flow collect: $d"}
}//存在泄露风险：虽然退到后台不工作了，暂时达到了效果。但是正如该函数被deprecated一样，是存在泄露风险的。仅仅是暂停了该块的执行。
lifecycleScope.launchWhenStarted {viewModel.timeFlow.collect { d->logd { "flow collect $d" }showInfoTv.text = "flow collect: $d"}
}//good：这样达到的效果是每次home后，彻底取消了。回来重新执行。得到的结果也是从0开始。
lifecycleScope.launch {repeatOnLifecycle(Lifecycle.State.STARTED) {viewModel.timeFlow.collect { d->showInfoTv.text = "flow collect: $d"}}
}

如果你需要数据被暂存，应该把time，放到viewModel里面，变成全局变量。

我的理解：flow的执行是没有生命周期感知的。需要你自行把握collect挂起函数的执行生命周期。 推荐采用如下方式来保证执行的安全性：

lifecycleScope.launch {repeatOnLifecycle(Lifecycle.State.STARTED) {viewModel.timeFlow.collect {//...}}
}

3.2 错误使用

collect是阻塞的。有多个执行需要launch分开。

//error：多个Flow不能放到一个lifecycleScope.launch里去collect{}，因为进入collect{}相当于一个死循环，下一行代码永远不会执行
lifecycleScope.launch {flow1.flowWithLifecycle(lifecycle, Lifecycle.State.STARTED).collect {}flow2.flowWithLifecycle(lifecycle, Lifecycle.State.STARTED).collect {}
}//success: 正确写法。如果就想写到一个lifecycleScope.launch{}里去，可以在内部再开启launch{}子协程去执行。
lifecycleScope.launch {launch {flow1.flowWithLifecycle(lifecycle, Lifecycle.State.STARTED).collect {}}launch {flow2.flowWithLifecycle(lifecycle, Lifecycle.State.STARTED).collect {}}
}

4. StateFlow&SharedFlow

之前学习都是冷流。现在来了解热流。

随着响应式编程在 Android 开发中的普及，开发者们开始寻求更有效的方式来处理状态变化和事件通信。这正是 StateFlow 和 SharedFlow 应运而生的背景。

StateFlow 是一个热流（hot flow），它始终持有一个值并在值发生变化时发出更新。这使得 StateFlow 非常适合于表示可以随时间变化的状态，如 UI 控件的可见性或网络状态的变化。

与之相对，SharedFlow 是设计用来传递事件的。它可以发出独立的、不连续的数据或事件，使其成为处理用户交互、网络响应或其他一次性事件的理想选择。

4.1 StateFlow

StateFlow 是一个状态容器，旨在以响应式的方式共享一个可变的数据状态。它是一个热流，意味着即使没有调用（collect函数）也会保持其状态。这种特性使得 StateFlow 适合于应用中需要观察和响应状态变化的场景。

重点就是替代LiveData。

下面的代码将作为最佳实践模板代码来编写。带状态的数据Bean，通知和监听处理。

sealed class DataState<out T> { //注意out重点object Loading : DataState<Nothing>()data class Success<out T>(val data: T) : DataState<T>()data class Error(val message: String?) : DataState<Nothing>()
}class FlowStudyViewModel : ViewModel() {private val _dataState = MutableStateFlow<DataState<String>>(DataState.Loading)val dataState: StateFlow<DataState<String>> = _dataState.asStateFlow()fun startLoad() {viewModelScope.launch {
//            _dataState.updateAndGet { //可以比较旧值一致就不通知出去
//                try {
//                    val data = api.request()
//                    DataState.Success(data)
//                } catch (e: Exception) {
//                    DataState.Error(e.message)
//                }
//            }_dataState.value = try {val data = api.request()DataState.Success(data)} catch (e: Exception) {DataState.Error(e.message)}}}
}//activity
lifecycleScope.launch {repeatOnLifecycle(Lifecycle.State.STARTED) {viewModel.dataState.collect { d->val data:Stringwhen (d) {is DataState.Success -> {data = d.data.toString()}is DataState.Error -> {data = "error"ToastUtil.toastOnTop("${d.message}")}is DataState.Loading -> {data = "loading"}}showInfoTv.text = data}}
}

从写法和实际的结果都与LiveData一样。并且理解StateFlow仅仅当做一个状态容器，旨在以响应式的方式共享一个可变的数据状态。白话来讲，相当于持有数据bean的一个可被监听的数据，与LiveData的作用完全一致。

4.2 SharedFlow

SharedFlow 是另一种类型的 Kotlin Flow，专门用于事件的传递。与 StateFlow 不同，SharedFlow 不保持状态，而是用于发送一次性或离散的事件。这使得 SharedFlow 成为管理事件通信的理想选择，尤其是在需要处理多个观察者的场景中。适用于：

  • 用户交互事件，如按钮点击或滚动事件。
  • 系统通知，如网络状态变更或数据库更新。
对于 SharedFlow 的使用，以下是一些高级技巧和最佳实践：
事件去重：通过 distinctUntilChanged 或自定义逻辑确保事件不被重复处理。
事件缓冲：适当配置 SharedFlow 的缓冲区大小和回放策略，以处理高频事件或防止事件丢失。
生命周期感知：在 Android 应用中，确保事件流的收集与组件的生命周期保持一致，避免内存泄漏。

代码示例：

private val _eventFlow = MutableSharedFlow<MyEvent>()
val eventFlow: SharedFlow<MyEvent> = _eventFlow.asSharedFlow()fun sendEvent(event: MyEvent) {viewModelScope.launch {_eventFlow.emit(event)}
}

可以看到，它没有初始化数据。

额外参数可选。

    public fun <T> MutableSharedFlow(// 每个新的订阅者订阅时收到的回放的数目，默认0replay: Int = 0,// 除了replay数目之外，缓存的容量，默认0extraBufferCapacity: Int = 0,// 缓存区溢出时的策略，默认为挂起。只有当至少有一个订阅者时，onBufferOverflow才会生效。当无订阅者时，只有最近replay数目的值会保存，并且onBufferOverflow无效。onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND)

StateFlow vs LiveData

引用前面说的，写法和实际的结果都与LiveData一样。并且理解StateFlow仅仅当做一个状态容器，旨在以响应式的方式共享一个可变的数据状态。白话来讲，相当于持有数据bean的一个可被监听的数据，与LiveData的作用完全一致。

区别点：

  • StateFlow 需要将初始状态传递给构造函数，而 LiveData 不需要。

  • 当 View 进入 STOPPED 状态时，LiveData.observe() 会自动取消注册使用方，而从 StateFlow 或任何其他数据流收集数据的操作并不会自动停止。如需实现相同的行为，您需要从 Lifecycle.repeatOnLifecycle 块收集数据流。

4.3 StateFlow vs SharedFlow

理解 StateFlow 和 SharedFlow 之间的关键差异有助于你在合适的场景中做出正确的选择。

  • 关键差异

状态保持 vs 事件传递：StateFlow 用于表示随时间变化的状态，而 SharedFlow 更适合于处理一次性或离散的事件。

单一订阅者 vs 多订阅者：StateFlow 通常用于单一订阅者模式，而 SharedFlow 能够同时向多个收集器广播事件。

初始化值：StateFlow 要求有初始值，而 SharedFlow 没有初始化值。即，StateFlow是粘性的，一注册就会回调，类似LiveData。

何时选择使用哪一个

  • 当需要表示并观察某个随时间变化的状态时，选择 StateFlow。
  • 当需要处理用户交互或系统事件，并且这些事件可能有多个观察者时，选择 SharedFlow。

结合使用的策略

在一些复杂的场景中，StateFlow 和 SharedFlow 可以组合使用。例如，你可以使用 StateFlow 来维护应用的状态，同时使用 SharedFlow 来处理和响应用户事件或系统通知。

示例1：

考虑一个简单的聊天应用，其中包含消息的发送和接收功能。可以使用 StateFlow 来表示当前的消息列表，而使用 SharedFlow 来处理新消息的接收。

示例2：

社交媒体应用，需要处理用户的点赞和评论事件。使用 SharedFlow，可以有效地广播这些事件到应用的不同部分，如更新 UI 或发送网络请求。

其他

MVI和MVVM

  • ‌MVI‌：
    严格遵循‌单向数据流‌（View → Intent → ViewModel → State → View）‌13。用户交互被封装为Intent事件，触发状态更新后驱动UI渲染，确保状态变化可预测。

  • ‌MVVM‌：
    通过数据绑定实现‌双向数据流‌（View ↔ ViewModel ↔ Model）‌12。View与ViewModel直接交互，灵活性高但可能增加数据不一致的风险。

callbackFlow

把基于回调的 API 转换为数据流。

callbackFlow 是冷流，没有接收者，不会产生数据。

callbackFlow：底层使用channel来进行中转，首先通过produce创建一个ReceiveChannel。然后在调用collect的时候，在将channel的值取出来emit出去。

在产生数据的时候，有两个方法可用：send 、offer

  • send ： 必须在协程体内使用
  • trySend(offer的替代者) ： 可以在非协程体内使用

举例：

/*** 模拟网络请求*/
fun requestApi(callback: (Int) -> Unit) {thread {Thread.sleep(3000)callback(3)}
}

改成callbackFlow：

注意里面的4要素。

val callbackFlow = callbackFlow { //1. 定义//模拟网络请求回调try {requestCallbackFlowApi { result ->//发送数据trySend(result).isSuccess //2. 使用trySend在非协程调用发送}} catch (e: Exception) {close(e) //4. 自行关闭flow的方式，否则，flow不会主动关闭的。}awaitClose { //3. 必须有awaitClose的设定，否则程序报错。//do something.}
}val job = GlobalScope.launch {flow.collect {//接收结果}
}

channelFlow

https://www.imooc.com/article/300248 有介绍channelFlow。我认为作为了解即可。它还不如callbackFlow常用。

flow 是 Cold Stream。在没有切换线程的情况下，生产者和消费者是同步非阻塞的。
channel 是 Hot Stream。而 channelFlow 实现了生产者和消费者异步非阻塞模型。

Channel

https://blog.csdn.net/vitaviva/article/details/149141984

  • Channel特性

它是协程间进行点对点通信的 “管道”，常用来解决经典的生产/消费问题。Channel 具备以下特效

点对点通信：设计用于协程间直接数据传递，数据 “一对一” 消费，发送后仅能被一个接收方获取 。
生产者-消费者模式：典型的 “管道” 模型，生产者协程发数据，消费者协程收数据，适合任务拆分与协作（如多步骤数据处理，各步骤用协程 + Channel 衔接 ）。
即时性：数据发送后立即等待消费，强调 “实时” 通信，像事件驱动场景（按钮点击事件通过 Channel 传递给处理协程 ）。
背压(Backpressure)： Channel 内部通过同步机制处理生产消费速度差。发送快时，若缓冲区满，发送端挂起；接收慢时，若缓冲区空，接收端挂起，自动平衡数据流转。

  • Flow 的特性

数据流抽象：将异步数据视为 “流”，支持冷流（无订阅不产生数据，如从数据库查询数据的 Flow ，订阅时才执行查询 ）和热流（如 SharedFlow，多订阅者共享数据，数据产生与订阅解耦 ）。
操作符丰富：提供 map（数据映射 ）、filter（数据过滤 ）、flatMapConcat（流拼接 ）等操作，可灵活转换、组合数据流，适合复杂数据处理场景（如网络请求 + 本地缓存数据的流式整合 ）。
多订阅者支持： SharedFlow 可广播数据给多个订阅者，数据 “一对多” 消费，如应用全局状态变化（用户登录状态），多个页面协程订阅 Flow 监听更新 。

对比维度ChannelFlow
通信模式点对点，数据 “一对一” 消费支持 “一对多”（SharedFlow），数据可广播
核心场景协程间任务协作、实时事件传递异步数据流处理、复杂数据转换与多订阅
背压处理依赖 Channel 缓冲区与挂起机制通过操作符（如 buffer ）或 Flow 自身设计处理
启动特性无 “懒启动”，发送数据逻辑主动执行。推。冷流默认懒启动，订阅时才触发数据生产。拉。

用法略。自行学习。

引用：
https://juejin.cn/post/7390936500115095561

https://baijiahao.baidu.com/s?id=1784258499249583415&wfr=spider&for=pc

https://developer.android.google.cn/kotlin/flow?hl=zh-cn

https://www.imooc.com/article/300248

https://blog.csdn.net/qq36246172/article/details/141271993

https://juejin.cn/post/7383086531043590185?from=search-suggest

https://mp.weixin.qq.com/s?__biz=MzA5MzI3NjE2MA==&mid=2650270522&idx=1&sn=b05ff0909b3454cfb5e17bbfd4a37f60&chksm=88631a55bf149343b7bcfefa54b563df66a3b5fb7848c296dc50b964a3e06770241c6aa42a15&scene=21#wechat_redirect

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

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

相关文章

【人工智能99问】什么是教师强制？(16/99)

【人工智能99问】什么是教师强制？(16/99)

文章目录什么是教师强制&#xff1f;教师强制&#xff08;Teacher Forcing&#xff09;的定义原比例&#xff08;Original Proportion&#xff09;教师强制的举例说明&#xff08;一&#xff09;教师强制的举例说明&#xff08;二&#xff09;优点和缺点解决曝光偏差的方法什么…
阅读更多...
【WPF】WPF 自定义控件之依赖属性

【WPF】WPF 自定义控件之依赖属性

&#x1f4e6; WPF 自定义控件之依赖属性 在开发 WPF 应用时&#xff0c;自定义控件能帮助我们复用逻辑和样式&#xff0c;但我很快会遇到一个问题&#xff1a;在控件内部如何支持数据绑定和属性变更通知&#xff1f;特别是我们继承自 Control 的时候&#xff0c;已经不能再继承…
阅读更多...
DOM型XSS破坏

DOM型XSS破坏

目录 首先 然后 第一种 第二种&#xff08;DOM&#xff09; HTMLCollection HTML Relationships Custom 解 首先 <script>//urlencode解码 //location接口的hash属性是一个字符串&#xff0c;包含一个“#”后跟位置URL的片段标识符。如果URL没有片段标识符&#…
阅读更多...
Linux C 多线程基本操作

Linux C 多线程基本操作

我们已经了解进程的基本概念&#xff1a;进程是正在执行的程序&#xff0c;并且是系统资源分配的基本单位。当用户需要在一台计算机上去完成多个独立的工作任务时&#xff0c;可以使用多进程的方式&#xff0c;为每个独立的工作任务分配一个进程。多进程的管理则由操作系统负责…
阅读更多...
C语言基础：二维数组练习题

C语言基础：二维数组练习题

1. 一个二维数组赋了初值&#xff0c;用户输入一个数&#xff0c;在该二维数组中查找。找到则返回行列位置&#xff0c;没找到则提示。#include <stdio.h>int main() {int arr[3][3] {{1, 2, 3},{4, 5, 6},{7, 8, 9}};int t;printf("要查找的数&#xff1a;")…
阅读更多...
Java面试题034：一文深入了解MySQL（6）

Java面试题034：一文深入了解MySQL（6）

Java面试题029&#xff1a;一文深入了解MySQL&#xff08;1&#xff09; Java面试题030&#xff1a;一文深入了解MySQL&#xff08;2&#xff09; Java面试题031&#xff1a;一文深入了解MySQL&#xff08;3&#xff09; Java面试题032&#xff1a;一文深入了解MySQL&#x…
阅读更多...
Java基础教程（011）：面向对象中的构造方法

Java基础教程（011）：面向对象中的构造方法

10-面向对象-构造方法 构造方法也叫做构造器、构造函数。 作用&#xff1a;在创建对象的时候给成员变量进行初始化的。 ✅ 一、构造方法的特点特点说明与类同名构造方法的名称必须与类名相同没有返回类型构造方法没有返回值&#xff0c;甚至不能写 void自动调用使用 new 创建对…
阅读更多...
Adobe Photoshop：数字图像处理的终极工具指南

Adobe Photoshop：数字图像处理的终极工具指南

Hi&#xff0c;我是布兰妮甜 &#xff01;Adobe Photoshop自1990年问世以来&#xff0c;已经成为数字图像处理领域的标杆和代名词。这款强大的软件不仅彻底改变了摄影、设计和艺术创作的方式&#xff0c;还深刻影响了我们消费和感知视觉内容的文化方式。从专业摄影师到社交媒体…
阅读更多...
本期来讲讲什么是LVS集群？

本期来讲讲什么是LVS集群？

集群和分布式 集群&#xff08;Cluster&#xff09;&#xff0c;解决某个问题将多台计算机组合形成的系统群。 常见的集群类型&#xff1a; 负载均衡(LoadBalancing&#xff0c;简称LB)&#xff1a;由多个相同配置的主机组成&#xff0c;每个主机经过调度承担部分访问&#…
阅读更多...
JVM 类加载过程笔记

JVM 类加载过程笔记

一、概述 JVM&#xff08;Java Virtual Machine&#xff09;在运行 Java 程序时&#xff0c;需要将 .class 字节码文件加载到内存中&#xff0c;并转换成可以被 JVM 执行的数据结构&#xff0c;这一过程就是 类加载过程&#xff08;Class Loading Process&#xff09;。 JVM 的…
阅读更多...
基于爬虫技术的电影数据可视化系统 Python+Django+Vue.js

基于爬虫技术的电影数据可视化系统 Python+Django+Vue.js

本文项目编号 25002 &#xff0c;文末自助获取源码 \color{red}{25002&#xff0c;文末自助获取源码} 25002&#xff0c;文末自助获取源码 目录 一、系统介绍二、系统录屏三、启动教程四、功能截图五、文案资料5.1 选题背景5.2 国内外研究现状 六、核心代码6.1 查询数据6.2 新…
阅读更多...
如何用 LUKS 和 cryptsetup 为 Linux 配置加密

如何用 LUKS 和 cryptsetup 为 Linux 配置加密

在信息安全愈发重要的今天&#xff0c;为 Linux 系统盘配置全盘加密已经成为很多企业和个人的选择。LUKS&#xff08;Linux Unified Key Setup&#xff09;配合工具 cryptsetup 可以在不牺牲性能的前提下实现高强度加密。本文将通过一个故事化的场景&#xff0c;介绍整个配置过…
阅读更多...
VIVADO技巧_BUFGMUX时序优化

VIVADO技巧_BUFGMUX时序优化

1.版本说明日期作者版本说明2025xxxx风释雪初始版本 2.概述 基于VIVADO时序约束&#xff0c;BUFGMUX多路时钟选择原语的设计3.原语介绍 7系列FPGA/UltraSCale/UltraSCaleBUFGMUX_CTRL BUFGMUX_CTRL_inst (.O(O), // 1-bit output: Clock output.I0(I0), // 1-bit input: Cloc…
阅读更多...
信息与通信领域Nature Communication发文量

信息与通信领域Nature Communication发文量

TelecommunicationCommunication
阅读更多...
服务器系统时间不准确怎么办？

服务器系统时间不准确怎么办？

服务器系统时间不准确可能会导致日志错乱、任务调度失败、SSL证书校验错误等问题。以下是解决办法&#xff1a;&#x1f310; 一、同步系统时间的方法1. 使用 timedatectl 命令&#xff08;适用于 systemd 系统&#xff09;timedatectl set-ntp true # 开启自动同步 timedatect…
阅读更多...
零信任产品联合宁盾泛终端网络准入，打造随需而变、精准贴合业务的网络安全访问体系

零信任产品联合宁盾泛终端网络准入，打造随需而变、精准贴合业务的网络安全访问体系

零信任网络访问控制&#xff08;Zero Trust Network Access&#xff0c;ZTNA&#xff0c;文中零信任皆指 ZTNA&#xff09;基于“永不信任&#xff0c;持续验证”的理念&#xff0c;打破了企业基于传统网络边界进行防护的固有模式。在当前日趋复杂的网络环境下&#xff0c;内部…
阅读更多...
【未限制消息消费导致数据库CPU告警问题排查及解决方案】

【未限制消息消费导致数据库CPU告警问题排查及解决方案】

一、背景 某天下午&#xff0c;上游系统同一时间突然下了三个大合同数据&#xff0c;平均每个合同数据实例在6万以上的量级&#xff0c;短短几分钟内瞬间有20万左右的流量涌入系统。 而在正常情况下&#xff0c;系统1天处理的流量也不过2千量级&#xff0c;当时数据库指标监控告…
阅读更多...
iOS开发 Swift 速记2：三种集合类型 Array Set Dictionary

iOS开发 Swift 速记2：三种集合类型 Array Set Dictionary

初级代码游戏的专栏介绍与文章目录-CSDN博客 我的github&#xff1a;codetoys&#xff0c;所有代码都将会位于ctfc库中。已经放入库中我会指出在库中的位置。 这些代码大部分以Linux为目标但部分代码是纯C的&#xff0c;可以在任何平台上使用。 源码指引&#xff1a;github源…
阅读更多...
Apache基础配置

Apache基础配置

一、Apache安装# 安装apache [rootwebserver ~]# yum install httpd -y# 在防火墙中放行web服务 [rootwebserver ~]# firewall-cmd --permanent --add-servicehttp success [rootwebserver ~]# firewall-cmd --permanent --add-servicehttps success# 开启服务 [rootwebserver …
阅读更多...
Python100个库分享第37个—BeautifulSoup(爬虫篇)

Python100个库分享第37个—BeautifulSoup(爬虫篇)

目录专栏导读&#x1f4da; 库简介&#x1f3af; 主要特点&#x1f6e0;️ 安装方法&#x1f680; 快速入门基本使用流程解析器选择&#x1f50d; 核心功能详解1. 基本查找方法find() 和 find_all()CSS选择器2. 属性操作3. 文本提取&#x1f577;️ 实战爬虫案例案例1&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023