【Flink精讲】Flink数据延迟处理

news2024/11/18 21:25:36

面试题：Flink数据延迟怎么处理？

  1. 将迟到数据直接丢弃【默认方案】
  2. 将迟到数据收集起来另外处理（旁路输出）
  3. 重新激活已经关闭的窗口并重新计算以修正结果（Lateness）

Flink数据延迟处理方案

用一个案例说明三种处理方式

举个例子：左流跟右流按照5秒的时间窗口进行coGroup操作（按单词进行关联），超过5秒进行丢弃。

结果说明：在Socket数据源输入 "1005000 java" 后，会统计1005000时间戳之前的数据，而在1005000时间戳之后输入的hello就没有被统计输出。当输入 "1010000 xixi" 后，触发了第2个窗口，只输出了java，还是没有后输入的hello统计结果，这也更明确了1005000时间戳之后输入的hello被丢弃了。

object MyCoGroupJoin {
  def main(args: Array[String]): Unit = {
    //创建环境变量
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    //指定事件时间
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

    //创建Socket源数据流，内容格式 "时间戳 单词"
    val s1 = env.socketTextStream("127.0.0.1", 9000)
      // 设置事件时间戳字段
      .assignAscendingTimestamps(_.split(" ")(0).toLong)
      .map(line => {
        val strs = line.split(" ")
        (strs(0).toLong, strs(1))
      })

    //创建Socket源数据流，内容格式 "时间戳 单词"
    val s2 = env.socketTextStream("127.0.0.1", 8888)
      // 设置事件时间戳字段
      .assignAscendingTimestamps(_.split(" ")(0).toLong)
      .map(line => {
        val strs = line.split(" ")
        (strs(0).toLong, strs(1))
      })

    //将两个数据流进行合并统计，这里是将两数据流利用窗口进行单词拼串处理
    s1.coGroup(s2)
      .where(_._2)
      .equalTo(_._2)
      .window(TumblingEventTimeWindows.of(Time.seconds(5))) //滚动窗口，窗口大小5秒
      .apply(new CoGroupFunction[(Long, String), (Long, String), String] {

        override def coGroup(first: lang.Iterable[(Long, String)], second: lang.Iterable[(Long, String)], out: Collector[String]): Unit = {
          //对两数据流中的数据进行循环遍历，并拼串下发
          first.forEach(r1 => {
            second.forEach(r2 => {
              println(s"${r1}::${r2}")
              val str = r1._2 + r2._2
              out.collect(str)
            })
          })
        }
      })
      .print()

    env.execute("cogroupjoin")
  }
}

 运行效果

========左流========
nc -l 9999

1001000 hello
1005000 java
1003000 hello [这条被丢弃了]
1010000 xixi

========右流========
nc -l 8888

1002000 hello
1005000 java
1001000 hello [这条被丢弃了]
1010000 xixi

========程序控制台输出结果========
(1001000,hello)::(1002000,hello)
4> hellohello
(1005000,java)::(1005000,java)
2> javajava

设置Watermark

时间语义：

  • Event Time（事件时间）：每条数据或事件自带的时间属性。由于时间属性依附于数据本身，在高并发的情况下可能存在Event Time的到达为乱序的，即一个较早发生的数据延迟到达
  • Process Time（处理时间）：对于某个算子来说，Processing Time指算子使用当前机器的系统时钟时间
  • Ingestion Time（接入时间）：事件到达Flink Source的时间

Flink的三种时间语义中，Processing Time和Ingestion Time都是基于Flink本身所产生的时间，可以不用设置时间字段和Watermark。如果要使用Event Time，以下两项配置缺一不可：第一，使用一个时间戳为数据流中每个事件的Event Time赋值；第二，生成Watermark。

Event Time是每个事件的元数据，如果不设置，Flink并不知道每个事件的发生时间，我们必须要为每个事件的Event Time赋值一个时间戳。关于时间戳，包括Flink在内的绝大多数系统都使用Unix时间戳系统（Unix time或Unix epoch）。Unix时间戳系统以1970-01-01 00:00:00.000 为起始点，其他时间记为距离该起始时间的整数差值，一般是毫秒（millisecond）精度。

有了Event Time时间戳，我们还必须生成Watermark。Watermark是Flink插入到数据流中的一种特殊的数据结构，它包含一个时间戳，并假设后续不会有小于该时间戳的数据，如果后续数据存在小于该时间戳的数据则视为延迟数据，需另外处理。下图展示了一个乱序数据流，其中方框是单个事件，方框中的数字是其对应的Event Time时间戳，圆圈为Watermark，圆圈中的数字为Watermark对应的时间戳。

 将之前的例子进行处理说明

object MyCoGroupJoin {

  def main(args: Array[String]): Unit = {

    // 创建环境变量
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    // 指定事件时间
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    // 创建Socket源数据流，内容格式 "时间戳 单词"
    val s1 = env.socketTextStream("127.0.0.1", 9999)
      // 设置事件时间戳字段
      // .assignAscendingTimestamps(_.split(" ")(0).toLong)
      // 这里可以指定周期性产生WaterMark 或 间歇性产生WaterMark，分别使用AssignerWithPeriodicWatermarks和AssignerWithPunctuatedWatermarks来实现
      // 这里使用周期性产生WaterMark,延长2秒
      .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[String](Time.seconds(2)) {
        
        override def extractTimestamp(element: String): Long = {
          val strs = element.split(" ")
          strs(0).toLong
        }
      })
      .map(line => {
        val strs = line.split(" ")
        (strs(0).toLong, strs(1))
      })

    // 创建Socket源数据流，内容格式 "时间戳 单词"
    val s2 = env.socketTextStream("127.0.0.1", 8888)
      // 设置事件时间戳字段
      // .assignAscendingTimestamps(_.split(" ")(0).toLong)
      // 这里可以指定周期性产生WaterMark 或 间歇性产生WaterMark，分别使用AssignerWithPeriodicWatermarks和AssignerWithPunctuatedWatermarks来实现
      // 这里使用周期性产生WaterMark,延长2秒
      .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[String](Time.seconds(2)) {
        override def extractTimestamp(element: String): Long = {
          val strs = element.split(" ")
          strs(0).toLong
        }
      })
      .map(line => {
        val strs = line.split(" ")
        (strs(0).toLong, strs(1))
      })
    //将两个数据流进行合并统计，这里是将两数据流利用窗口进行单词拼串处理
    s1.coGroup(s2)
      .where(_._2)
      .equalTo(_._2)
      .window(TumblingEventTimeWindows.of(Time.seconds(5))) //滚动窗口，窗口大小5秒
      .apply(new CoGroupFunction[(Long, String), (Long, String), String] {
        
        override def coGroup(first: lang.Iterable[(Long, String)], second: lang.Iterable[(Long, String)], out: Collector[String]): Unit = {
          // 对两数据流中的数据进行循环遍历，并拼串下发
          first.forEach(r1 => {
            second.forEach(r2 => {
              println(s"${r1}::${r2}")
              val str = r1._2 + r2._2
              out.collect(str)
            })
          })
        }
      })
      .print()
    
    env.execute("cogroupjoin")
  }
}

执行效果

=========左流=========
nc -l 9999
1001000 hello
1005000 java
1003000 hello
1007000 java

=========右流=========
nc -l 8888
1002000 hello
1005000 java
1001000 hello
1007000 java

=========程序控制台输出=========
(1001000,hello)::(1002000,hello)
4> hellohello
(1001000,hello)::(1001000,hello)
4> hellohello
(1003000,hello)::(1002000,hello)
4> hellohello
(1003000,hello)::(1001000,hello)
4> hellohello

当我们使用Watermark后，我们可以发现在两个Socket终端输入"1005000 java"时，控制台并没有立刻统计输出信息。而是在两个Socket终端输入 "1007000 java"后，控制台才将统计结果输出出来，且在时间戳"1005000"之后输入的hello也同时给统计出来了，上面的问题可以解决了，但是 "1007000 java" 之后我们再输入 hello ，你会发现还是存在问题，没有输出又给丢弃了。继续测试如下。


======左流======
nc -l 9999
1001000 hello
1005000 java
1003000 hello
1007000 java
1003000 hello
1012000 spark

======右流======
nc -l 8888
1002000 hello
1005000 java
1001000 hello
1007000 java
1004000 hello
1012000 spark

=======程序执行控制台输出结果=======
(1001000,hello)::(1002000,hello)
4> hellohello
(1001000,hello)::(1001000,hello)
4> hellohello
(1003000,hello)::(1002000,hello)
4> hellohello
(1003000,hello)::(1001000,hello)
4> hellohello
(1005000,java)::(1005000,java)
2> javajava
(1005000,java)::(1007000,java)
2> javajava
(1007000,java)::(1005000,java)
2> javajava
(1007000,java)::(1007000,java)
2> javajava

所以waterMark只能在一定程度上解决这种问题。我们再来看看allowedLateness机制。

设置Lateness

object MyCoGroupJoin {
  def main(args: Array[String]): Unit = {
    // 创建环境变量
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    // 指定事件时间
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    // 创建Socket源数据流，内容格式 "时间戳 单词"
    val s1 = env.socketTextStream("127.0.0.1", 9999)
      // 设置事件时间戳字段
      // .assignAscendingTimestamps(_.split(" ")(0).toLong)
      // 这里可以指定周期性产生WaterMark 或 间歇性产生WaterMark，分别使用AssignerWithPeriodicWatermarks和AssignerWithPunctuatedWatermarks来实现
      // 这里使用周期性产生WaterMark,延长2秒
      .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[String](Time.seconds(2)) {
        override def extractTimestamp(element: String): Long = {
          val strs = element.split(" ")
          strs(0).toLong
        }
      })
      .map(line => {
        val strs = line.split(" ")
        (strs(0).toLong, strs(1))
      })
    // 创建Socket源数据流，内容格式 "时间戳 单词"
    val s2 = env.socketTextStream("127.0.0.1", 8888)
      // 设置事件时间戳字段
      // .assignAscendingTimestamps(_.split(" ")(0).toLong)
      // 这里可以指定周期性产生WaterMark 或 间歇性产生WaterMark，分别使用AssignerWithPeriodicWatermarks和AssignerWithPunctuatedWatermarks来实现
      // 这里使用周期性产生WaterMark,延长2秒
      .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[String](Time.seconds(2)) {
        override def extractTimestamp(element: String): Long = {
          val strs = element.split(" ")
          strs(0).toLong
        }
      })
      .map(line => {
        val strs = line.split(" ")
        (strs(0).toLong, strs(1))
      })
    //将两个数据流进行合并统计，这里是将两数据流利用窗口进行单词拼串处理
    s1.coGroup(s2)
      .where(_._2)
      .equalTo(_._2)
      .window(TumblingEventTimeWindows.of(Time.seconds(5))) //滚动窗口，窗口大小5秒
      // 允许数据迟到2秒，窗口触发后2秒内过来的数据还可以重新被计算
      .allowedLateness(Time.seconds(2))
      .apply(new CoGroupFunction[(Long, String), (Long, String), String] {
        override def coGroup(first: lang.Iterable[(Long, String)], second: lang.Iterable[(Long, String)], out: Collector[String]): Unit = {
          // 对两数据流中的数据进行循环遍历，并拼串下发
          first.forEach(r1 => {
            second.forEach(r2 => {
              println(s"${r1}::${r2}")
              val str = r1._2 + r2._2
              out.collect(str)
            })
          })
        }
      })
      .print()
    env.execute("cogroupjoin")
  }
}

执行效果

======左流======
nc -l 9999
1001000 hello
1007000 java

======右流======
nc -l 8888
1002000 hello
1007000 java
1003000 hello

=======程序执行控制台输出结果=======
(1001000,hello)::(1002000,hello)
4> hellohello
(1001000,hello)::(1002000,hello)
4> hellohello
(1001000,hello)::(1003000,hello)
4> hellohello

到这里估计有朋友又有疑问了，allowedLateness机制解决数据延迟设置的时间段，那之后再来的延迟数据呢，还是被丢弃了并没有彻底解决问题。别慌，针对allowedLateness机制之后来的延迟数据Flink还提供了另一种方案就是sideOutput机制。 

旁路输出

Side Output简单来说就是在程序执行过程中,将主流stream流中的不同的业务类型或者不同条件的数据分别输出到不同的地方。如果我们想对没能及时在Flink窗口计算的延迟数据专门处理，也就是窗口已经计算了，但后面才来的数据专门处理，我们可以使用旁路输出到侧流中去处理。

object MyCoGroupJoin {

  def main(args: Array[String]): Unit = {
    // 创建环境变量
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    // 指定事件时间
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    // 创建Socket源数据流，内容格式 "时间戳 单词"
    val s1 = env.socketTextStream("127.0.0.1", 9999)
      // 这里可以指定周期性产生WaterMark 或 间歇性产生WaterMark，分别使用AssignerWithPeriodicWatermarks和AssignerWithPunctuatedWatermarks来实现
      // 这里使用周期性产生WaterMark,延长2秒
      .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[String](Time.seconds(2)) {
        override def extractTimestamp(element: String): Long = {
          val strs = element.split(" ")
          strs(0).toLong
        }
      })
      .map(line => {
        val strs = line.split(" ")
        (strs(0).toLong, strs(1))
      })
    // 定义一个侧输出流
    val lateData: OutputTag[(Long, String)] = new OutputTag[(Long, String)]("late")
    val s2 = s1.timeWindowAll(Time.seconds(5))
      //允许迟到2秒数据
      .allowedLateness(Time.seconds(2))
      //迟到长于2秒的数据将被保存到lateData侧数据流中
      .sideOutputLateData(lateData)
      .process(new ProcessAllWindowFunction[(Long, String), (Long, String), TimeWindow] {
        override def process(context: Context, elements: Iterable[(Long, String)], out: Collector[(Long, String)]): Unit = {
          elements.foreach(ele => {
            out.collect(ele)
          })
        }
      })
    s2.print("主流")
    s2.getSideOutput(lateData).print("侧流")
    env.execute("cogroupjoin")
  }
}
=======数据流======
nc -l 9999
1001000 hello
1005000 java
1007000 python
1002000 hello
1009000 java
1001000 xixi
1002000 haha

=======程序执行控制台输出结果=====
主流:10> (1001000,hello)
主流:11> (1001000,hello)
主流:12> (1002000,hello)
侧流:1> (1001000,xixi)
侧流:2> (1002000,haha)

通过上面测试可以发现晚于allowedLateness机制的延迟数据，Flink没有丢弃而是输出到了侧输出流中等待处理了，这样延迟数据就完美解决了。

双流Join中的数据延迟处理

  1. 数据质量问题：流式数据到达计算引擎的时间不一定：比如 A 流的数据先到了，A 流不知道 B 流对应同 key 的数据什么时候到，没法关联；
  2. 数据时效问题：流式数据不知何时、下发怎样的数据：A 流的数据到达后，如果 B 流的数据永远不到，那么 A 流的数据在什么时候以及是否要填充一个 null 值下发下去。

Window Join

Flink Window Join。就是将两条流的数据从无界数据变为有界数据，即划分出时间窗口，然后将同一时间窗口内的两条流的数据做 Join（这里的时间窗口支持 Tumbling、Sliding、Session）。

解法说明：

  1. 流式数据到达计算引擎的时间不一定：数据已经被划分为窗口，无界数据变为有界数据，就和离线批处理的方式一样了，两个窗口的数据简单的进行关联即可
  2. 流式数据不知何时、下发怎样的数据：窗口结束就把数据下发下去，关联到的数据就下发 [A, B]，没有关联到的数据取决于是否是 outer join 然后进行数据下发

Tumbling

 Sliding

Session

Flink SQL（Flink 1.14 版本 Window TVF 中支持）：

SELECT 
    L.num as L_Num
    , L.id as L_Id
    , R.num as R_Num
    , R.id as R_Id
    , L.window_start
    , L.window_end
FROM (
    SELECT * 
    FROM TABLE(TUMBLE(TABLE LeftTable, DESCRIPTOR(row_time), INTERVAL '5' MINUTES))
) L
FULL JOIN (
    SELECT * 
    FROM TABLE(TUMBLE(TABLE RightTable, DESCRIPTOR(row_time), INTERVAL '5' MINUTES))
) R
ON L.num = R.num 
AND L.window_start = R.window_start 
AND L.window_end = R.window_end;
方案特点

⭐ 产出数据质量：低
⭐ 产出数据时效性：中
当我们的窗口大小划分的越细时，在窗口边缘关联不上的数据就会越多，数据质量就越差。窗口大小划分的越宽时，窗口内关联上的数据就会越多，数据质量越好，但是产出时效性就会越差。所以要注意取舍。

举个例子：以曝光关联点击来说，如果我们划分的时间窗口为 1 分钟，那么一旦出现曝光在 0:59，点击在 1:01 的情况，就会关联不上，当我们的划分的时间窗口 1 小时时，只有在每个小时的边界处的数据才会出现关联不上的情况。

适用场景

该种解决方案适用于可以评估出窗口内的关联率高的场景，如果窗口内关联率不高则不建议使用。注意：这种方案由于上面说到的数据质量和时效性问题在实际生产环境中很少使用。

Interval Join

Interval Join。其也是将两条流的数据从无界数据变为有界数据，但是这里的有界和Window Join 的有界的概念是不一样的，这里的有界是指两条流之间的有界。

以 A 流 join B 流举例，interval join 可以让 A 流可以关联 B 流一段时间区间内的数据，比如 A 流关联 B 流前后 5 分钟的数据。

解法说明：

  1. 流式数据到达计算引擎的时间不一定：数据已经被划分为窗口，无界数据变为有界数据，就和离线批处理的方式一样了，两个窗口的数据简单的进行关联即可
  2. 流式数据不知何时、下发怎样的数据：窗口结束（这里的窗口结束是指 interval 区间结束，区间的结束是利用 watermark 来判断的）就把数据下发下去，关联到的数据就下发 [A, B]，没有关联到的数据取决于是否是 outer join 然后进行数据下发
CREATE TABLE show_log_table (
     log_id BIGINT,
     show_params STRING,
     row_time AS cast(CURRENT_TIMESTAMP as timestamp(3)),
     WATERMARK FOR row_time AS row_time
 ) WITH (
   'connector' = 'datagen',
   'rows-per-second' = '1',
   'fields.show_params.length' = '1',
   'fields.log_id.min' = '1',
   'fields.log_id.max' = '10'
 );
 
 CREATE TABLE click_log_table (
     log_id BIGINT,
     click_params STRING,
     row_time AS cast(CURRENT_TIMESTAMP as timestamp(3)),
     WATERMARK FOR row_time AS row_time
 )
 WITH (
   'connector' = 'datagen',
   'rows-per-second' = '1',
   'fields.click_params.length' = '1',
   'fields.log_id.min' = '1',
   'fields.log_id.max' = '10'
 );
 
 CREATE TABLE sink_table (
     s_id BIGINT,
     s_params STRING,
     c_id BIGINT,
     c_params STRING
 ) WITH (
   'connector' = 'print'
 );
 
 INSERT INTO sink_table
 SELECT
     show_log_table.log_id as s_id,
     show_log_table.show_params as s_params,
     click_log_table.log_id as c_id,
     click_log_table.click_params as c_params
 FROM show_log_table FULL JOIN click_log_table ON show_log_table.log_id = click_log_table.log_id
 AND show_log_table.row_time BETWEEN click_log_table.row_time - INTERVAL '5' SECOND AND click_log_table.row_time
方案特点

⭐ 产出数据质量：中
⭐ 产出数据时效性：中
interval join 的方案比 window join 方案在数据质量上好很多，但是其也是存在 join 不到的情况的。并且如果为 outer join 的话，outer 一测的流数据需要要等到区间结束才能下发。

适用场景

该种解决方案适用于两条流之间可以明确评估出相互延迟的时间是多久的，这里我们可以使用离线数据进行评估，使用离线数据的两条流的时间戳做差得到一个分布区间。

比如在 A 流和 B 流时间戳相差在 1min 之内的有 95%，在 1-4 min 之内的有 4.5%，则我们就可以认为两条流数据时间相差在 4 min 之内的有 99.5%，这时我们将上下界设置为 4min 就是一个能保障 0.5% 误差的合理区间。

注意：这种方案在生产环境中还是比较常用的。

Regular Join

Regular Join。上面两节说的两种 Join 都是基于划分窗口，将无界数据变为有界数据进行关联机制，但是本节说的 regular join 则还是基于无界数据进行关联。

以 A 流 left join B 流举例，A 流数据到来之后，直接去尝试关联 B 流数据。
1. 如果关联到了则直接下发关联到的数据
2. 如果没有关联到则也直接下发没有关联到的数据，后续 B 流中的数据到来之后，会把之前下发下去的没有关联到数据撤回，然后把关联到的数据数据进行下发。由此可以看出这是基于 Flink SQL 的 retract 机制，则也就说明了其目前只支持 Flink SQL。

解法说明：

  1.  流式数据到达计算引擎的时间不一定：两条流的数据会尝试关联，能关联到直接下发，关联不到先下发一个目前的结果数据
  2.  流式数据不知何时、下发怎样的数据：两条流的数据会尝试关联，能关联到直接下发，关联不到先下发一个目前的结果数据
CREATE TABLE show_log_table (
    log_id BIGINT,
    show_params STRING
) WITH (
  'connector' = 'datagen',
  'rows-per-second' = '1',
  'fields.show_params.length' = '3',
  'fields.log_id.min' = '1',
  'fields.log_id.max' = '10'
);
 
CREATE TABLE click_log_table (
  log_id BIGINT,
  click_params     STRING
)
WITH (
  'connector' = 'datagen',
  'rows-per-second' = '1',
  'fields.click_params.length' = '3',
  'fields.log_id.min' = '1',
  'fields.log_id.max' = '10'
);
 
CREATE TABLE sink_table (
    s_id BIGINT,
    s_params STRING,
    c_id BIGINT,
    c_params STRING
) WITH (
  'connector' = 'print'
);
 
INSERT INTO sink_table
SELECT
    show_log_table.log_id as s_id,
    show_log_table.show_params as s_params,
    click_log_table.log_id as c_id,
    click_log_table.click_params as c_params
FROM show_log_table
LEFT JOIN click_log_table ON show_log_table.log_id = click_log_table.log_id;
方案特点

产出数据质量：高
产出数据时效性：高
数据质量和时效性高的原因都是因为 regular join 会保障目前 Flink 任务已经接收到的数据中能关联的一定是关联上的，即使关联不上，数据也会下发，完完全全保障了当前数据的客观性和时效性。

适用场景

该种解决方案虽然是目前在产出质量、时效性上最好的一种解决方案，但是在实际场景中使用时，也存在一些问题：

基于 retract 机制，所有的数据都会存储在 state 中以判断能否关联到，所以我们要设置合理的 state ttl 来避免大 state 问题导致的任务不稳定
基于 retract 机制，所以在数据发生更新时，会下发回撤数据、最新数据 2 条消息，当我们的关联层级越多，则下发消息量的也会放大
 sink 组件要支持 retract，我们不要忘了最终数据是要提供数据服务给需求方进行使用的，所以我们最终写入的数据组件也需要支持 retract，比如 MySQL。如果写入的是 Kafka，则下游消费这个 Kafka 的引擎也需要支持回撤\更新机制。

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

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

相关文章

鸿蒙开发已解决-Failed to connect to gitee.com port 443: Time out 连接超时提示

鸿蒙开发已解决-Failed to connect to gitee.com port 443: Time out 连接超时提示

文章目录 项目场景：问题描述原因分析：解决方案：解决方案1解决方案2：解决方案3：此Bug解决方案总结解决方案总结**心得体会：解决连接超时问题的三种方案**项目场景： 导入Sample时遇到导入失败的情况，并提示“Failed to connect to gitee.com port 443: Time out”连接超…
阅读更多...
外汇天眼：MT5到底比MT4强在哪里？

外汇天眼：MT5到底比MT4强在哪里？

这段时间，我们收到许多用户询问关于MT5比MT4优秀的地方，为解答多数投资人的疑惑，决定简短分享两者的差距。 其实MT4功能已经非常强大，但MT5的功能提升绝对不只一个量级，这也是工程师积极向MT5转型的主要原因&#xff0…
阅读更多...
Apache ECharts | 一个数据可视化图表库

Apache ECharts | 一个数据可视化图表库

文章目录 1、简介1.1、主要特点1.2、使用场景 2、安装方式一：从下载的源代码或编译产物安装方法二：从 npm 安装方法三：⭐定制安装echarts.js 3、使用 官网： 英语：https://echarts.apache.org/en/index.html 中文&a…
阅读更多...
使用Moonbuilders Academy平台，学习DApp开发

使用Moonbuilders Academy平台，学习DApp开发

Moonbeam团队于2022年宣布开放Moonbuilders Academy。这是一套以开发为中心的异步学习课程，用于学习如何在Moonbeam上构建跨链DApp。 如何从官网进入平台？ 点击http://moonbeam.network 鼠标移动至 “Builders”，在Resources下方选择“Moo…
阅读更多...
激活函数整理

激活函数整理

sigmoid函数 import torch from d2l import torch as d2l %matplotlib inline ​ xtorch.arange(-10,10,0.1,requires_gradTrue) sigmoidtorch.nn.Sigmoid() ysigmoid(x) ​ d2l.plot(x.detach(),y.detach(),x,sigmoid(x),figsize(5,2.5)) sigmoid函数连续、光滑、单调递增&am…
阅读更多...
Queue接口分析

Queue接口分析

一、Queue是什么 该接口是Java集合框架成员 Queue： 通常（但不一定）队列就是一个先入先出（FIFO）的数据结构，和堆一样（但可以进行转换，比如优先级列队排序，又或者改为栈形…
阅读更多...
增广路算法 DFS求解 最大网络流问题

增广路算法 DFS求解 最大网络流问题

最大网络流问题 最大网络流问题是这样的，有一个有向图，假定有一个源点，有一个汇点，源点有流量出来，汇点有流量进入，有向图上的边的权重为该条边可通过的最大流量(方向为边的方向)，问从源点到汇…
阅读更多...
网络安全新形势下的动态防御体系研究（下）

网络安全新形势下的动态防御体系研究（下）

文章目录 一、动态防御体系构成（一）建立对抗式威胁评估能力（二）建立安全防御效能验证能力（三）建立安全防御基准检测能力（四）建立欺骗式防御能力（五）建立安全态…
阅读更多...
Windows下面基于pgsql15的备份和恢复

Windows下面基于pgsql15的备份和恢复

一、基础备份 1.创建一个文件用来存储备份数据 2.备份指令 $CurrentDate Get-Date -Format "yyyy-MM-dd" $OutputDirectory "D:\PgsqData\pg_base\$CurrentDate" $Command "./pg_basebackup -h 127.0.0.1 -U postgres -Ft -Pv -Xf -z -Z5 -D $O…
阅读更多...
前端面试题集合四（html）

前端面试题集合四（html）

HTML 面试知识点总结 本部分主要是笔者在复习 HTML 相关知识和一些相关面试题时所做的笔记，如果出现错误，希望大家指出！ 目录 1. DOCTYPE 的作用是什么？2. 标准模式与兼容模式各有什么区别？3. HTML5 为什么只需要写…
阅读更多...
Cesium笔记 初始化 原生Cesium

Cesium笔记 初始化 原生Cesium

1、创建vue项目 vue create my_demo 2、下载Cesium 可以从官网下载&#xff0c;也可以使用node下载 npm install cesium 3、把node_modules文件夹中下载得Cesium&#xff0c;移出到public文件夹下 4、将Cesium.js 以及样式文件widgets.css在index.html中引用 <!DOCT…
阅读更多...
鸿鹄云商B2B2C：JAVA实现的商家间直播带货商城系统概览

鸿鹄云商B2B2C：JAVA实现的商家间直播带货商城系统概览

【saas云平台】打造全行业全渠道全场景的saas产品&#xff0c;为经营场景提供一体化解决方案&#xff1b;门店经营区域化、网店经营一体化&#xff0c;本地化、全方位、一站式服务&#xff0c;为多门店提供统一运营解决方案&#xff1b;提供丰富多样的营销玩法覆盖所有经营场景…
阅读更多...
理清类图，辨识UML

理清类图，辨识UML

类图 public 用 表示 protected 用 # 表示 private 用 - 表示 class Person { public:void setName(std::string name) {this->name name;}std::string getName() {return this->name;} public:int nationality;//国籍 protected:int idCard;//身份证号 private:std…
阅读更多...
_Incapsula_Resource与Rc4混淆分析

_Incapsula_Resource与Rc4混淆分析

一、获得混淆js 这么一个地址 https://www.interasia.cc/_Incapsula_Resource?SWJIYLWA5074a744e2e3d891814e9a2dace20bd4,719d34d31c8e3a6e6fffd425f7e032f3 浏览器打开这个地址 复制这个js&#xff0c;到浏览器调试 先格式化查看&#xff0c;也就是一个eval函数执行b函数 …
阅读更多...
【解刊】Elsevier旗下，1区CCF-B，超快审稿：2个月22天录用！

【解刊】Elsevier旗下，1区CCF-B，超快审稿：2个月22天录用！

计算机类 • 升区期刊 本次带来Elsevier旗下高分快刊&#xff0c;入选CCF-B类推荐&#xff0c;如有相关领域作者意向投稿&#xff0c;可重点关注&#xff01;更多领域期刊&#xff0c;可移步公众号【Unionpub学术】了解详情~ 01 期刊简介 Computer Networks ✅出版社&#x…
阅读更多...
vue中使用component中的is渲染组件如何使用，:is 等价 v-if渲染组件。

vue中使用component中的is渲染组件如何使用，:is 等价 v-if渲染组件。

动态组件顾名思义动态加载不同的组件&#xff0c;is属性用于加载不同组件&#xff0c;传参使用属性传递 1、使用v-for遍历component&#xff0c;组件都会执行 <componentv-for"(item, index) in TAB_PANE":key"index":is"item.componentName"…
阅读更多...
idea右上角浏览器图标没有idea内部浏览器怎么显示

idea右上角浏览器图标没有idea内部浏览器怎么显示

idea右上角浏览器图标没有idea内部浏览器怎么显示 file -> settings -> tools -> web brosers 选择需要的浏览器&#xff0c;勾选上展示到编辑器中 打开上图的Built-in Preview&#xff0c;就会显示idea标志的内部显示了&#xff01;&#xff01;&#xff01;
阅读更多...
AttentionFreeTransformer 核心结构图（GraphViz 重绘）

AttentionFreeTransformer 核心结构图（GraphViz 重绘）

AFTFull digraph AFTFull {rankdirBTnode [stylefilled, colorBlackfontcolorWhite, fillcolor"#30638e", fontname"SimHei",fontsize32,width5, height2,]inp [label"输入\n[BatchSize,\n SeqLen,\n HidSize]", shape"Mrecord"]llq […
阅读更多...
测试平台开发vue组件化重构前端代码

测试平台开发vue组件化重构前端代码

基于 springbootvue 的测试平台开发 继续更新&#xff08;人在魔都 T_T&#xff09;。 这期其实并不是一个详细的开发过程记录&#xff0c;主要还是针对本次前端重构来聊聊几个关注点。 目前重构的总进度在80%&#xff0c;重构完的页面没什么变化&#xff0c;再回顾一下。 一…
阅读更多...
2024美赛数学建模思路 - 复盘：人力资源安排的最优化模型

2024美赛数学建模思路 - 复盘：人力资源安排的最优化模型

文章目录 0 赛题思路1 描述2 问题概括3 建模过程3.1 边界说明3.2 符号约定3.3 分析3.4 模型建立3.5 模型求解 4 模型评价与推广5 实现代码 建模资料 0 赛题思路 &#xff08;赛题出来以后第一时间在CSDN分享&#xff09; https://blog.csdn.net/dc_sinor?typeblog 1 描述 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023