slivelight
slivelight

详解Flink作业提交流程

一、提交流程

Flink 作业在开发完毕之后，需要提交到 Flink 集群执行。ClientFronted 是入口，触发用户开发的 Flink 应用 Jar 文件中的 main 方法，然后交给 PipelineExecutor（流水线执行器，在 FlinkClient 升成 JobGraph 之后，将作业提交给集群的重要环节。）#execue 方法，最终会选择一个触发一个具体的 PiplineExecutor 执行。

提交模式又可分为：

  • Detached：Flink Client 创建完集群之后，可以退出命令行窗口，集群独立运行。

  • Attached：不能关闭命令行窗口，需要与集群之间维持连接。

1.1 Yarn Session 提交流程

启动集群：

  • 使用 bin/yarn-session.sh 提交会话模式的作业。如果提交到已经存在的集群，则获取 Yarn 集群信息、应用 ID，并准备提交作业。如果启动新的 Yarn Session 集群，则进入步骤（2）

  • Yarn 启动新 Flink 集群

    1）如果没有集群，则创建一个新的 Session 模式的集群。首先将应用配置（flink-conf.yaml、logback.xml、log4j.properties）和相关文件（Flink Jar、配置类文件、用户 Jar 文件、JobGraph 对象等）上传至分布式存储(如 HDFS)的应用暂存目录。

    2）通过 Yarn Client 向 Yarn 提交 Flink 创建集群的申请，Yarn 分配资源，在申请的 Yarn Container 中初始化并启动 FlinkJobManager 进程，在 JobManager 进程中运行 YarnSessionClusterEntrypoint 作为集群启动入口（不同的集群部署模式有不同的 ClusterEntrypoint 实现），初始化 Dispatcher、ResourceManager，启动相关的 RPC 服务，等待 Client 通过 Rest 接口提交作业。

作业提交：

Yarn 集群准备好后，开始作业提交。

1）Flink Client 通过 Rest 向 Dispatcher 提交 JobGraph。

2）Dispatcher 是 Rest 接口，不负责实际的调度、执行方面的工作，当收到 JobGraph 后，为作业创建一个 JobMaster，将工作交给 JobManager（负责作业调度、管理作业和 Task 的生命周期），构建 ExecutionGraph（JobGraph 的并行化版本，调度层最核心的数据结构）。

这两个步骤结束后，作业进入调度执行阶段。

作业调度执行：

1）JobMaster 向 YarnResourceManager 申请资源，开始调度 ExecutionGraph 执行，向 YarnResourceManager 申请资源；初次提交作业集群中尚没有 TaskManager，此时资源不足，开始申请资源。

2）YarnResourceManager 收到 JobManager 的资源请求，如果当前有空闲 Slot 则将 Slot 分配给 JobMaster.，否则 YarnResourceManager 将向 YarnMaster 请求创建 TaskManager。

3）YarnResourceManager 将资源请求加入到等待请求队列，并通过心跳向 Yarn RM 申请新的 Container 资源来启动 TaskManager 进程，Yarn 分配新的 Container 给 TaskManager。

4）YarnResourceManager 启动，然后从 HDFS 加载 Jar 文件等所需要的的相关资源，在容器中启动 TaskManager。

5）TaskManager 启动之后，向 ResourceManager 注册，并把自己的 Slot 资源情况汇报给 ResouceManager。

6）ResourceManager 从等待队列中取出 Slot 请求，向 TaskManager 确认资源可用情况，并告知 TaskManager 将 Slot 分配给哪个 JobMaster。

7）TaskManager 向 JobMaster 提供 Slot，JobMaster 调度 Task 到 TaskManager 的此 Slot 上执行。

1.2 Yarn Per-Job 提交流程

启动集群：

  • 使用./flink run -m yarn-cluster 提交 Per-Job 模式的作业。

  • Yarn 启动 Flink 集群。该模式下 Flink 集群的启动入口是 YarnJobClusterEntryPoint，其他与 YarnSession 模式下集群的启动类似。

作业提交：

该步骤与 Seesion 模式下的不同，Client 并不会通过 Rest 向 Dispatcher 提交 JobGraph,由 Dispatcher 从本地文件系统获取 JObGraph，其后的不好走与 Session 模式的一样

作业调度执行：

与 Yarn Session 模式下一致。

1.3 K8s Session 提交流程

详解Flink作业提交流程_第1张图片

启动集群：

  • Flink 客户端首先连接 Kubernetes API Server，提交 Flink 集群的资源描述文件，包括 flink-configuration-configmap.yaml、jobmanager-service.yaml、jobmanager-deployment.yaml 和 taskmanager-deployment.yaml 等。

  • Kubernets Master 会根据这些资源描述文件去创建对应的 Kubernetes 实体。以 JobManager 部署为例，Kubernetes 集群中的某个节点收到请求后，Kubelet 进程会从中央仓库下载 Flink 镜像，准备和挂载卷，然后执行启动命令。Pod 启动后 Flink Master(JobManager)进程随之启动，初始化 Dispacher 和 KubernetesResourceManager。并通过 K8s 服务对外暴露 FlinkMaster 的端口，K8s 服务类似于路由服务。

两个步骤完成之后，Session 模式的集群就创建成功，集群可以接收作业提交请求，但是此时还没有 JobManager、TaskManager，当作业需要执行时，才会按需创建。

作业提交：

  • Client 用户可以通过 Flink 命令行（即 Flink Client）向这个会话模式的集群提交任务。此时 JobGraph 会在 FlinkClient 端生成，然后和用户 Jar 包一起通过 RestClient 上传。

  • 作业提交成功，Dispatcher 会为每个作业启动一个 JobMaster，将 JobGraph 交给 JobMaster 调度执行。

两个步骤完成之后，作业进入调度执行阶段。

作业调度执行：

K8s Session 模式集群下，ResourceManager 向 k8sMaster 申请和释放 TaskManager，除此之外，作业的调度与执行和 Yarn 模式是一样的。

1）JobMaster 向 KubernetesResourceManager 请求 Slot。

2）KubernetesResourceManager 从 kubernetes 集群分配 TaskManager。每个 TaskManager 都是具有唯一标识的 Pod。KubernetesResourceManager 会为 TaskManager 生成一份新的配置文件，里面有 Flink Master 的 service name 作为地址。这样在 FLInkMaster failover 之后，TaskManager 仍然可以重新连上。

3）Kubernetes 集群分配一个新的 Pod 后，在上面启动 TaskManager。

4）TaskManager 启动后注册到 SlotManager。

5）SlotManager 向 TaskManager 请求 Slot.

6）TaskManager 提供 Slot 给 JobMaster，然后任务就会被分配到这个 Slot 上运行。

二、Graph 总览

详解Flink作业提交流程_第2张图片

  • 流计算应用的 Graph 转换：StreamGraph-->JobGraph-->ExecutionGraph-->物理执行图(启动计算任务)

  • 批处理应用的 Graph 转换：OptimizedPlan-->JobGraph

  • Table & SQL API 的 Graph 转换：Blink Table Planner Flink Table Planner。

2.1 流图

使用 DataStreamAPI 开发的应用程序，首先被转换为 Transformation,然后被映射为 StreamGraph。

2.1.1 SteramGraph 核心对象

  • StreamNode

    StreamNode 是 StremGraph 中的节点 ，从 Transformation 转换而来，可以简单理解为一个 StreamNode 表示一个算子，从逻辑上来说，SteramNode 在 StreamGraph 中存在实体和虚拟的 StreamNode。StremNode 可以有多个输入，也可以有多个输出。

    实体的 StreamNode 会最终变成物理算子。虚拟的 StreamNode 会附着在 StreamEdge 上。

  • StreamEdge

    StreamEdge 是 StreamGraph 中的边，用来连接两个 StreamNode,一个 StreamNode 可以有多个出边、入边，StreamEdge 中包含了旁路输出、分区器、字段筛选输出等信息。

2.1.2 StreamGraph 生成过程

StreamGraph 在 FlinkClient 中生成，由 FlinkClient 在提交的时候触发 Flink 应用的 main 方法，用户编写的业务逻辑组装成 Transformation 流水线，在最后调用 StreamExecutionEnvironment.execute() 的时候开始触发 StreamGraph 构建。

详解Flink作业提交流程_第3张图片

StreamGraph 实际上是在 StreamGraphGenerator 中生成的，从 SinkTransformation（输出） 向前追溯到 SourceTransformation。在遍历过程中一边遍历一边构建 StreamGraph。

详解Flink作业提交流程_第4张图片

在遍历 Transformation 的过程中，会对不同类型的 Transformation 分别进行转换。对于物理 Transformation 则转换为 StreamNode 实体，对于虚拟 Transformation 则作为虚拟 StreamNode。

详解Flink作业提交流程_第5张图片

针对于某一种类型的 Transformation，会调用其相应的 transformxxx()函数进行转换。transfromxxx（）首先转换上游 Transformation 进行递归转换，确保上游的都已经完成了转换。然后通过 addOperator()方法构造出 StreamNode，通过 addEdge()方法与上游的 transform 进行连接，构造出 StreamEdge。

在添加 StreamEdge 的过程中，如果 ShuffleMode 为 null，则使用 ShuffleMode PIPELINED 模式，在流计算中，只有 PIPLINED 模式才会在批处理中设计其他模式。构建 StreamEdge 的时候，在转换 Transformation 过程中生成的 虚拟 StreamNode 会将虚拟 StreamNode 的信息附着在 StreamEdge 上

2.1.3 虚拟 Transformation 的转换

虚拟的 Transformation 生成的时候不会转换为 SteramNode，而是添加为虚拟节点。

详解Flink作业提交流程_第6张图片

 private void addEdgeInternal(Integer upStreamVertexID,
   Integer downStreamVertexID,
   int typeNumber,
   StreamPartitioner partitioner,
   List outputNames,
   OutputTag outputTag,
   ShuffleMode shuffleMode) {
  //当上游是sideoutput时，递归调用，并传入sideoutput信息
  if (virtualSideOutputNodes.containsKey(upStreamVertexID)) {
   int virtualId = upStreamVertexID;
   upStreamVertexID = virtualSideOutputNodes.get(virtualId).f0;
   if (outputTag == null) {
    outputTag = virtualSideOutputNodes.get(virtualId).f1;
   }
   addEdgeInternal(upStreamVertexID, downStreamVertexID, typeNumber, partitioner, null, outputTag, shuffleMode);

  }
  //当上游是select时，递归调用，并传入select信息
  else if (virtualSelectNodes.containsKey(upStreamVertexID)) {
   int virtualId = upStreamVertexID;
   upStreamVertexID = virtualSelectNodes.get(virtualId).f0;
   if (outputNames.isEmpty()) {
    // selections that happen downstream override earlier selections
    outputNames = virtualSelectNodes.get(virtualId).f1;
   }
   addEdgeInternal(upStreamVertexID, downStreamVertexID, typeNumber, partitioner, outputNames, outputTag, shuffleMode);
  }
  //当上游是Partition时，递归调用，并传入Partition信息
  else if (virtualPartitionNodes.containsKey(upStreamVertexID)) {
   int virtualId = upStreamVertexID;
   upStreamVertexID = virtualPartitionNodes.get(virtualId).f0;
   if (partitioner == null) {
    partitioner = virtualPartitionNodes.get(virtualId).f1;
   }
   shuffleMode = virtualPartitionNodes.get(virtualId).f2;
   addEdgeInternal(upStreamVertexID, downStreamVertexID, typeNumber, partitioner, outputNames, outputTag, shuffleMode);
  }
  //不是以上逻辑转换的情况，真正构建StreamEdge
  else {
   StreamNode upstreamNode = getStreamNode(upStreamVertexID);
   StreamNode downstreamNode = getStreamNode(downStreamVertexID);

   // If no partitioner was specified and the parallelism of upstream and downstream
   // operator matches use forward partitioning, use rebalance otherwise.
   //没有指定partitioner时，会为其选择forward或者rebalance
   if (partitioner == null && upstreamNode.getParallelism() == downstreamNode.getParallelism()) {
    partitioner = new ForwardPartitioner();
   } else if (partitioner == null) {
    partitioner = new RebalancePartitioner();
   }

   if (partitioner instanceof ForwardPartitioner) {
    if (upstreamNode.getParallelism() != downstreamNode.getParallelism()) {
     throw new UnsupportedOperationException("Forward partitioning does not allow " +
       "change of parallelism. Upstream operation: " + upstreamNode + " parallelism: " + upstreamNode.getParallelism() +
       ", downstream operation: " + downstreamNode + " parallelism: " + downstreamNode.getParallelism() +
       " You must use another partitioning strategy, such as broadcast, rebalance, shuffle or global.");
    }
   }

   if (shuffleMode == null) {
    shuffleMode = ShuffleMode.UNDEFINED;
   }
   //创建StreamEdge,并将该SteramEdge添加到上游的输出，下游的输入。
   StreamEdge edge = new StreamEdge(upstreamNode, downstreamNode, typeNumber, outputNames, partitioner, outputTag, shuffleMode);

   getStreamNode(edge.getSourceId()).addOutEdge(edge);
   getStreamNode(edge.getTargetId()).addInEdge(edge);
  }
 }

 
  
2.2 作业图
 
  
JobGraph 可以由流计算的 StreamGraph 和批处理的 OptimizedPlan 转换而来。流计算中，在 StreamGraph 的基础上进行了一些优化，如果通过 OperatorChain 机制将算子合并起来，在执行时，调度在同一个 Task 线程上，避免数据的跨线程、跨网段的传递。
 
  
详解Flink作业提交流程_第7张图片
 
  
2.2.1 JobGraph 核心对象
 
  
     
   
  •  
    JobVertex
     
    经过算子融合优化后符合条件的多个 SteramNode 可能会融合在一起生成一个 JobVertex，即一个 JobVertex 包含一个或多个算子，JobVertex 的输入是 JobEdge，输出是 IntermediateDataSet。
     
    •  
   
  •  
    JobEdge
     
    JobEdge 是 JobGraph 中连接 IntermediateDataSet 和 JobVertex 的边，表示 JobGraph 中的一个数据流转通道，其上游数据源是 IntermediateDataSet，下游消费者是 JobVertex。数据通过 JobEdge 由 IntermediateDataSet 传递给 JobVertex。
     
    •  
   
  •  
    IntermediateDataSet
     
    中间数据集 IntermediateDataSet 是一种逻辑结构，用来表示 JobVertex 的输出，即该 JobVertex 中包含的算子会产生的数据集。不同的执行模式下，其对应的结果分区类型不同，决定了在执行时刻数据交换的模式。
     
    IntermediateDataSet 的个数与该 JobVertex 对应的 StreamNode 的出边数量相同，可以是一个或者多个。
     
    •  
  
 
  
2.2.2 JobGraph 生成过程
 
  
 
  
 
  
StreamingJobGraphGenerator 负责流计算 JobGraph 的生成，在转换前需要进行一系列的预处理。
 
  
    private JobGraph createJobGraph() {
     preValidate();

     // make sure that all vertices start immediately
     //设置调度模式
     jobGraph.setScheduleMode(streamGraph.getScheduleMode());

     // Generate deterministic hashes for the nodes in order to identify them across
     // submission iff they didn't change.
     //为每个节点生成确定的hashid作为唯一表示，在提交和执行过程中保持不变。
     Map hashes = defaultStreamGraphHasher.traverseStreamGraphAndGenerateHashes(streamGraph);

     // Generate legacy version hashes for backwards compatibility
     //为了向后保持兼容，为每个节点生成老版本的hash id
     List> legacyHashes = new ArrayList<>(legacyStreamGraphHashers.size());
     for (StreamGraphHasher hasher : legacyStreamGraphHashers) {
      legacyHashes.add(hasher.traverseStreamGraphAndGenerateHashes(streamGraph));
     }

     Map>> chainedOperatorHashes = new HashMap<>();
     //真正对SteramGraph进行转换，生成JobGraph图
     setChaining(hashes, legacyHashes, chainedOperatorHashes);
     setPhysicalEdges();

     //设置共享slotgroup
     setSlotSharingAndCoLocation();

     setManagedMemoryFraction(
      Collections.unmodifiableMap(jobVertices),
      Collections.unmodifiableMap(vertexConfigs),
      Collections.unmodifiableMap(chainedConfigs),
      id -> streamGraph.getStreamNode(id).getMinResources(),
      id -> streamGraph.getStreamNode(id).getManagedMemoryWeight());
     //配置checkpoint
     configureCheckpointing();

     jobGraph.setSavepointRestoreSettings(streamGraph.getSavepointRestoreSettings());
     //如果有之前的缓存文件的配置，则重新读入
     JobGraphGenerator.addUserArtifactEntries(streamGraph.getUserArtifacts(), jobGraph);

     // set the ExecutionConfig last when it has been finalized
     try {
      //设置执行环境配置
      jobGraph.setExecutionConfig(streamGraph.getExecutionConfig());
     }
     catch (IOException e) {
      throw new IllegalConfigurationException("Could not serialize the ExecutionConfig." +
        "This indicates that non-serializable types (like custom serializers) were registered");
     }

     return jobGraph;
    }


 
  
预处理完毕后，开始构建 JobGraph 中的点和边，从 Source 向下遍历 StreamGraph，逐步创建 JObGraph，在创建的过程中同事完成算子融合(OperatorChain)优化。
 
  
详解Flink作业提交流程_第8张图片
 
  
执行具体的 Chain 和 JobVertex 生成、JobEdge 的关联、IntermediateDataSet。从 StreamGraph 读取数据的 StreamNode 开始，递归遍历同时将 StreamOperator 连接在一起。
 
  
整理构建的逻辑如下（看上图！！！）：
 
  
1）从 Source 开始，Source 与下游的 FlatMap 不可连接，Source 是起始节点，自己成为一个 JobVertx。
 
  
2）此时开始一个新的连接分析，FlatMap 是起始节点，与下游的 KeyedAgg 也不可以连接，那么 FlatMap 自己成为一个 JobVertex。
 
  
3）此时开始一个新的连接分析。KeyedAgg 是起始节点，并且与下游的 Sink 可以连接，那么递归地分析 Sink 节点，构造 Sink 与其下游是否可以连接，因为 Slink 没有下游，所以 KeyedAgg 和 Sink 节点连接在一起，共同构成了一个 JobVertex。在这个 JobVertex 中，KeyedAgg 是起始节点，index 编号为 0，sink 节点 index 编号为 1.
 
  
构建 JobVertex 的时候需要将 StreamNode 中的重要配置信息复制到 JobVertex 中。构建好 JobVertex 之后，需要构建 JobEdge 将 JobVertex 连接起来。KeyedAgg 和 Sink 之间构成了一个算子连接，连接内部的算子之间无序构成 JobEdge 进行连接。
 
  
在构建 JobEdge 的时候，很重要的一点是确定上游 JobVertex 和下游 JobVertex 的数据交换方式。此时根据 ShuffleMode 来确定 ResultPartition 类型，用 FlinkPartition 来确定 JobVertex 的连接方式。
 
  
Shuffle 确定了 ResultPartition,那么就可以确定上游 JobVertex 输出的 IntermediateDataSet 的类型了，也就知道 JobEdge 的输入 IntermediateDataSet。
 
  
ForwardPartitioner 和 RescalePartitioner 两种类型的 Partitioner 转换为 DistributionPattern.POINTWISE 的分发模式。其他类型的 Partitioner 统一转换为 DistributionPattern.ALL_TO_ALL 模式。
 
  
JobGraph 的构建和 OperatorChain 优化：
 
  
private List createChain(
Integer startNodeId,
Integer currentNodeId,
Map hashes,
List> legacyHashes,
int chainIndex,
Map>> chainedOperatorHashes) {

     if (!builtVertices.contains(startNodeId)) {

      List transitiveOutEdges = new ArrayList();

      List chainableOutputs = new ArrayList();
      List nonChainableOutputs = new ArrayList();

      StreamNode currentNode = streamGraph.getStreamNode(currentNodeId);
      //获取当前节点的出边，判断是否符合OperatorChain的条件
      //分为两类：chainableoutputs,nonchainableoutputs
      for (StreamEdge outEdge : currentNode.getOutEdges()) {
       if (isChainable(outEdge, streamGraph)) {
        chainableOutputs.add(outEdge);
       } else {
        nonChainableOutputs.add(outEdge);
       }
      }
      //对于chainable的边，递归调用createchain
      //返回值添加到transitiveOutEdges中
      for (StreamEdge chainable : chainableOutputs) {
       transitiveOutEdges.addAll(
         createChain(startNodeId, chainable.getTargetId(), hashes, legacyHashes, chainIndex + 1, chainedOperatorHashes));
      }

      //对于无法chain在一起的边，边的下游节点作为Operatorchain的Head节点
      //进行递归调用，返回值添加到transitiveOutEdges中
      for (StreamEdge nonChainable : nonChainableOutputs) {
       transitiveOutEdges.add(nonChainable);
       createChain(nonChainable.getTargetId(), nonChainable.getTargetId(), hashes, legacyHashes, 0, chainedOperatorHashes);
      }

      List> operatorHashes =
       chainedOperatorHashes.computeIfAbsent(startNodeId, k -> new ArrayList<>());

      byte[] primaryHashBytes = hashes.get(currentNodeId);
      OperatorID currentOperatorId = new OperatorID(primaryHashBytes);

      for (Map legacyHash : legacyHashes) {
       operatorHashes.add(new Tuple2<>(primaryHashBytes, legacyHash.get(currentNodeId)));
      }

      chainedNames.put(currentNodeId, createChainedName(currentNodeId, chainableOutputs));
      chainedMinResources.put(currentNodeId, createChainedMinResources(currentNodeId, chainableOutputs));
      chainedPreferredResources.put(currentNodeId, createChainedPreferredResources(currentNodeId, chainableOutputs));

      if (currentNode.getInputFormat() != null) {
       getOrCreateFormatContainer(startNodeId).addInputFormat(currentOperatorId, currentNode.getInputFormat());
      }

      if (currentNode.getOutputFormat() != null) {
       getOrCreateFormatContainer(startNodeId).addOutputFormat(currentOperatorId, currentNode.getOutputFormat());
      }
      //如果当前节点是起始节点，则直接创建JobVertex，否则返回一个空的StreamConfig
      StreamConfig config = currentNodeId.equals(startNodeId)
        ? createJobVertex(startNodeId, hashes, legacyHashes, chainedOperatorHashes)
        : new StreamConfig(new Configuration());

      //将StreamNode中的配置信息序列化到Streamconfig中。
      setVertexConfig(currentNodeId, config, chainableOutputs, nonChainableOutputs);
      //再次判断，如果是Chain的起始节点，执行connect（）方法，创建JobEdge和IntermediateDataset
      //否则将当前节点的StreamConfig 添加到chainedConfig中。
      if (currentNodeId.equals(startNodeId)) {

       config.setChainStart();
       config.setChainIndex(0);
       config.setOperatorName(streamGraph.getStreamNode(currentNodeId).getOperatorName());

       for (StreamEdge edge : transitiveOutEdges) {
        connect(startNodeId, edge);
       }

       config.setOutEdgesInOrder(transitiveOutEdges);
       config.setTransitiveChainedTaskConfigs(chainedConfigs.get(startNodeId));

      } else {
       chainedConfigs.computeIfAbsent(startNodeId, k -> new HashMap());

       config.setChainIndex(chainIndex);
       StreamNode node = streamGraph.getStreamNode(currentNodeId);
       config.setOperatorName(node.getOperatorName());
       chainedConfigs.get(startNodeId).put(currentNodeId, config);
      }

      config.setOperatorID(currentOperatorId);

      if (chainableOutputs.isEmpty()) {
       config.setChainEnd();
      }
      return transitiveOutEdges;

     } else {
      return new ArrayList<>();
     }
    }


 
  
2.2.3 算子融合
 
  
一个 Operatorchain 在同一个 Task 线程内执行。OperatorChain 内的算子之间，在同一个线程内通过方法调用的方式传递数据，能减少线程之间的切换，减少消息的序列化/反序列化，无序借助内存缓存区，也无须通过网络在算子间传递数据，可在减少延迟的同时提高整体吞吐量
 
  
operatorchain 的条件:
 
  
1）下游节点的入度为 1
 
  
2）SteramEdge 的下游节点对应的算子不为 null
 
  
3）StreamEdge 的上游节点对应的算子不为 null
 
  
4）StreamEdge 的上下游节点拥有相同的 slotSharingGroup，默认都是 default.
 
  
5）下游算子的连接策略为 ALWAYS.
 
  
6）上游算子的连接策略为 ALWAYS 或者 HEAD.
 
  
7）StreamEdge 的分区类型为 ForwardPartitioner
 
  
8）上下游节点的并行度一致
 
  
9）当前 StreamGraph 允许 chain
 
  
2.3 执行图
 
  
详解Flink作业提交流程_第9张图片
 
  
2.3.1 ExecutionGraph 核心对象
 
  
     
   
  •  
    ExecutionJobVertex
     
    该对象和 JobGraph 中的 JobVertex 一一对应。该对象还包含了一组 ExecutionVertex，数量与该 JobVertex 中所包含的 SteramNode 的并行度一致。
     
    ExecutionJobVertex 用来将一个 JobVertex 封装成一 ExecutionJobVertex，并以此创建 ExecutionVertex、Execution、IntermediateResult 和 IntermediateResultPartition，用于丰富 ExecutionGraph。
     
    在 ExecutionJobVertex 的构造函数中，首先是依据对应的 JobVertex 的并发度，生成对应个数的 ExecutionVertex。其中，一个 ExecutionVertex 代表一个 ExecutionJobVertex 的并发子 Task。然后是将原来 JobVertex 的中间结果 IntermediateDataSet 转化为 ExecutionGrap 中 IntermediateResult
     
    •  
   
  •  
    ExecutionVertex
     
    ExecutionJobVertex 中会对作业进行并行化处理，构造可以并行执行的实例，每个并行执行的实例就是 ExecutionVertex.
     
    构建 ExecutionVertex 的同时，也回构建 ExecutionVertex 的输出 IntermediateResult。并且将 ExecutionEdge 输出为 IntermediatePartition。
     
    ExecutionVertex 的构造函数中，首先会创建 IntermediatePartition，并通过 IntermediateResult.setPartition（）建立 IntermediateResult 和 IntermediateResultPartition 之间的关系，然后生成 Execution，并配置资源相关。
     
    •  
   
  •  
    IntermediateResult
     
    IntermediateResult 又叫做中间结果集，该对象是个逻辑概念，表示 ExecutionJobVertex 的输出，和 JobGraph 中的 IntermediateDataSet 一一对应，同样，一个 ExecutionJobVertex 可以有多个中间二级果，取决于当前 JobVertex 有几个出边。
     
    一个中间结果集包含多个中间结果分区 IntermediateResultPartition，其个数等于该 JobVertex 的并发度。
     
    •  
   
  •  
    IntermediateResultPartition IntermediateResultPartition 又叫做中间结果分区，表示 1 个 ExecutionVertex 输出结果，与 ExecutionEdge 相关联。
     
    •  
   
  •  
    ExecutionEdge
     
    表示 ExecutionVertex 的输入，连接到上游产生的 IntermediateResultPartition。一个 Execution 对应于唯一的一个 IntermediateResultPartition 和一个 ExecutionVertex。一个 ExecutionVertex 可以有多个 ExecutionEdge。
     
    •  
   
  •  
    Execution
     
    ExecutionVertex 相当于每个 Task 的模板，在真正执行的时候，会将 ExecutionVertex 中的信息包装为一个 Execution,执行一个 ExecutionVertex 的一次尝试。JobManager 和 TaskManager 之间关于 Task 的部署和 Task 执行状态的更新都是通过 ExecutionAttemptID 来标识实例的。在故障或者数据需要重算的情况下，ExecutionVertex 可能会有多个 ExecutionAttemptID.一个 Execution 通过 ExecutionAttemptID 标识。
     
    •  
  
 
  
2.3.2 ExecutionGrap 生成过程
 
  
初始话作业调度器的时候，根据 JobGra ph 生活 ExecutionGraph。在 SchedulerBase 的构造方法中触发构建，最终调用 SchedulerBase#createExecutionGraph 触发实际的构建动作，使用 ExecutionGraphBuiler 构建 ExecutionGraph。
 
  
详解Flink作业提交流程_第10张图片
 
  
核心代码 attachJobGraph：
 
  
详解Flink作业提交流程_第11张图片
 
  
构建 ExecutionEdge 的连接策略：
 
  
     
   
  •  
    点对点连接（DistributionPatter n.POINTWISE）
     
    该策略用来连接当前 ExecutionVertex 与上游的 IntermediataeResultParition。
     
    连接分三种情况
     
    1）一对一连接：并发的 Task 数量与分区数相等。
     
    2）多对一连接：下游的 Task 数量小于上游的分区数，此时分两种情况：
     
     a：下游 Task 可以分配同数量的结果分区 IntermediataeResultParition。如上游有 4 个结果分区，下游有 2 个 Task，那么每个 Task 会分配两个结果分区进行消费。
     
    •  
  
 
  
       b：每个 Task 消费的上游分区结果数据不均，如上游有 3 个结果分区，下游有两个 Task，那么一个 Task 分配 2 个结果分区消费，另一个分配一个结果分区消费。
 
  
      3）一对多连接：下游的 Task 数量多余上游的分区数，此时两种情况：
 
  
a：每个结果分区的下游消费 Task 数据量相同，如上游有两个结果分区，下游有 4 个 Task，每个结果分区被两个 Task 消费。
 
  
b：每个结果分区的下游消费 Task 数量不相同，如上游有两个结果分区，下游有 3 个 Task，那么一个结果分区分配 2 个 Task 消费，另一个结果分区分配一个 Task 消费。
 
  
     
   
  •  
    全连接（DistributionPattern.ALL_TO_ALL）
     
    该策略下游的 ExecutionVertex 与上 游的所有 IntermediataeResultParition 建立连接，消费其生产的数据。一般全连接的情况意味着数据在 Shuffle。
     
    •  
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(数据技术,flink)

        

            

                
    
                    
  • nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    
                    
    • 
                    
  • 06选课支付模块之基于消息队列发送支付通知消息
                        echo 云清
学成在线javarabbitmq消息队列支付通知学成在线
                        
    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
    
                    
    • 
                    
  • 如何利用大数据与AI技术革新相亲交友体验
                        h17711347205
回归算法安全系统架构交友小程序
                        
    在数字化时代，大数据和人工智能（AI）技术正逐渐革新相亲交友体验，为寻找爱情的过程带来前所未有的变革（编辑h17711347205）。通过精准分析和智能匹配，这些技术能够极大地提高相亲交友系统的效率和用户体验。大数据的力量大数据技术能够收集和分析用户的行为模式、偏好和互动数据，为相亲交友系统提供丰富的信息资源。通过分析用户的搜索历史、浏览记录和点击行为，系统能够深入了解用户的兴趣和需求，从而提供更
    
                    
    • 
                    
  • 未来软件市场是怎么样的？做开发的生存空间如何？
                        cesske
软件需求
                        
    目录前言一、未来软件市场的发展趋势二、软件开发人员的生存空间前言未来软件市场是怎么样的？做开发的生存空间如何？一、未来软件市场的发展趋势技术趋势：人工智能与机器学习：随着技术的不断成熟，人工智能将在更多领域得到应用，如智能客服、自动驾驶、智能制造等，这将极大地推动软件市场的增长。云计算与大数据：云计算服务将继续普及，大数据技术的应用也将更加广泛。企业将更加依赖云计算和大数据来优化运营、提升效率，并
    
                    
    • 
                    
  • 全面指南：用户行为从前端数据采集到实时处理的最佳实践
                        数字沉思
营销流量运营系统架构前端内容运营大数据
                        
    引言在当今的数据驱动世界，实时数据采集和处理已经成为企业做出及时决策的重要手段。本文将详细介绍如何通过前端JavaScript代码采集用户行为数据、利用API和Kafka进行数据传输、通过Flink实时处理数据的完整流程。无论你是想提升产品体验还是做用户行为分析，这篇文章都将为你提供全面的解决方案。设计一个通用的ClickHouse表来存储用户事件时，需要考虑多种因素，包括事件类型、时间戳、用户信
    
                    
    • 
                    
  • 架构评审的自动化与人工智能: 如何提高效率
                        光剑书架上的书
架构自动化人工智能运维
                        
    1.背景介绍架构评审是软件开发过程中的一个关键环节，它旨在确保软件架构的质量、可维护性和可扩展性。传统的架构评审通常是由人工进行，需要大量的时间和精力。随着大数据技术和人工智能的发展，自动化和人工智能技术已经开始应用于架构评审，从而提高评审的效率和准确性。在本文中，我们将讨论如何通过自动化和人工智能技术来提高架构评审的效率。我们将从以下几个方面进行讨论：背景介绍核心概念与联系核心算法原理和具体操作
    
                    
    • 
                    
  • 详解 Flink 的常见部署方式
                        文刀小桂
Flinkflink大数据
                        
    一、常见部署模式分类1.按是否依赖外部资源调度1.1Standalone模式独立模式(Standalone)是独立运行的，不依赖任何外部的资源管理平台，只需要运行所有Flink组件服务1.2Yarn模式Yarn模式是指客户端把Flink应用提交给Yarn的ResourceManager,Yarn的ResourceManager会在Yarn的NodeManager上创建容器。在这些容器上，Flink
    
                    
    • 
                    
  • 大数据之flink与hive
                        星辰_mya
大数据flinkhive
                        
    其实吧我不太想写flink，因为线上经验确实不多，这也是我需要补的地方，没有条件创造条件，先来一篇吧flink：高性能低延迟流批一体的分布式计算框架基于事件时间对实时数据精准处理快速响应支持批处理，高效离线分析和数据挖掘数据仓库的引擎丰富数据源/接收器，集成多种数据存储格式和源，比较常见就是咱们今天的主题hive了checkpoint恢复机制，故障恢复快速恢复计算任务分布式弹性扩展，据业务灵活增加
    
                    
    • 
                    
  • Java中的大数据处理框架对比分析
                        省赚客app开发者
java开发语言
                        
    Java中的大数据处理框架对比分析大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天，我们将深入探讨Java中常用的大数据处理框架，并对它们进行对比分析。大数据处理框架是现代数据驱动应用的核心，它们帮助企业处理和分析海量数据，以提取有价值的信息。本文将重点介绍ApacheHadoop、ApacheSpark、ApacheFlink和ApacheStorm这四种流行的
    
                    
    • 
                    
  • 一文搞懂 Flink Task 数据交互之数据写源码
                        mn_kw
flink交互java
                        
    一文搞懂FlinkTask数据交互之数据写源码1.RecordWriterOutput2.RecordWriter3.数据分区器ChannelSelector4.数据输出模型ResultPartition5.子模型ResultSubpartition6.本地buffer池LocalBufferPool7.获取buffer8.将buffer添加到ResultSubpartitionFlink重要源码
    
                    
    • 
                    
  • 概率图模型（PGM）综述
                        医学影像处理
概率图模型概率图模型综述
                        
    RefLink:http://www.sigvc.org/bbs/thread-728-1-1.htmlGraphicalModel的基本类型基本的GraphicalModel可以大致分为两个类别：贝叶斯网络(BayesianNetwork)和马尔可夫随机场(MarkovRandomField)。它们的主要区别在于采用不同类型的图来表达变量之间的关系：贝叶斯网络采用有向无环图(DirectedAc
    
                    
    • 
                    
  • Python基础知识进阶之正则表达式_头歌python正则表达式进阶
                        前端陈萨龙
程序员python学习面试
                        
    最后硬核资料：关注即可领取PPT模板、简历模板、行业经典书籍PDF。技术互助：技术群大佬指点迷津，你的问题可能不是问题，求资源在群里喊一声。面试题库：由技术群里的小伙伴们共同投稿，热乎的大厂面试真题，持续更新中。知识体系：含编程语言、算法、大数据生态圈组件（Mysql、Hive、Spark、Flink）、数据仓库、Python、前端等等。网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是
    
                    
    • 
                    
  • 大数据新视界 --大数据大厂之Flink强势崛起：大数据新视界的璀璨明珠
                        青云交
大数据新视界Flink大数据数据类型实时处理流处理框架对比应用场景数据处理大数据新视界数据库
                        
    亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：Ja
    
                    
    • 
                    
  • flink增量检查点降低状态依赖实现的详细步骤
                        goTsHgo
Flink大数据分布式flink大数据
                        
    增量检查点启动恢复的时间是很久的，业务上不能接受，所以可以通过降低状态依赖来减少恢复的时间。降低状态依赖尽可能减少状态的复杂性和依赖关系，通过拆分状态或将状态外部化到其他服务中，从而降低恢复的开销。实施措施：将状态分割为更小的单元，减少每次恢复的状态量。使用外部状态存储服务，减少Flink状态后端的负担。拆分状态和将状态外部化到其他服务可以帮助减少作业的状态依赖，从而降低恢复时间和复杂度。以下是详
    
                    
    • 
                    
  • flink table factory基础知识
                        loukey_j

                        
    一、概述在flink中很多组件都是TableFactory的子类。比如序列化，反序列化，tableSinkFactory,tableSourceFactory.TableFactory是用来创建序列化，反序列器，tableSource和tableSink的工厂。二、TableFactory源码在flink框架中，TableFactory的子类并不是程序员自己随心new出来的。flink的提供给程序
    
                    
    • 
                    
  • 2024年最全使用Python求解方程_python解方程(1)，字节面试官迟到
                        2401_84569545
程序员python学习面试
                        
    最后硬核资料：关注即可领取PPT模板、简历模板、行业经典书籍PDF。技术互助：技术群大佬指点迷津，你的问题可能不是问题，求资源在群里喊一声。面试题库：由技术群里的小伙伴们共同投稿，热乎的大厂面试真题，持续更新中。知识体系：含编程语言、算法、大数据生态圈组件（Mysql、Hive、Spark、Flink）、数据仓库、Python、前端等等。网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是
    
                    
    • 
                    
  • 2020年10月国产数据库排行：GoldenDB跃升异军突起 PolarDB和GaussDB云化融合
                        数据和云
微软informix分布式存储microsoftcloudera
                        
    墨墨导读：2020年10月国产数据库流行度的前三位由TiDB、达梦数据库、GBase（南大通用）获得，其中TiDB以超过100分的优势领先第二位的达梦数据库。数据技术嘉年华，十周年盛大开启，点我立即报名！大会以“自研·智能·新基建——云和数据促创新生态融合新十年”为主题，相邀数据英雄，总结过往十年历程与成绩，展望未来十年趋势与目标！近60场演讲，大咖云集，李飞飞、苏光牛、林晓斌、黄东旭...，快来
    
                    
    • 
                    
  • 01-Flink安装部署及入门案例（仅供学习），音视频时代你还不会NDK开发
                        小猪佩琪962
2024年程序员学习flink学习大数据
                        
    先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《2024年最新大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵
    
                    
    • 
                    
  • 比较Spark与Flink
                        傲雪凌霜，松柏长青
大数据后端sparkflink大数据
                        
    ApacheSpark和ApacheFlink都是目前非常流行的大数据处理引擎，但它们在架构、处理模式、应用场景等方面有一些显著的区别。下面是二者的对比：1.处理模式Spark:主要支持批处理（BatchProcessing），也能通过SparkStreaming处理流式数据，但SparkStreaming本质上是通过微批（micro-batching）的方式处理流数据，延迟相对较高。SparkS
    
                    
    • 
                    
  • Apache Flink：实时流处理与批处理的统一框架
                        小码快撩
flink大数据
                        
    导语在大数据处理领域，流处理和批处理是两种主要的处理方式。然而，传统的系统通常将这两者视为独立的任务，需要不同的工具和框架来处理。ApacheFlink是一个开源的流处理框架，它打破了这种界限，提供了一个统一的平台来处理实时流数据和批处理数据。一、基本概念与架构ApacheFlink的基本概念与架构主要包括以下几个核心组成部分：基本概念1.流处理模型：无界流(UnboundedStreams):数
    
                    
    • 
                    
  • 使用python实现微信小程序自动签到
                        光头哥不光头
python
                        
    学校：重庆财经职业学院学院：应用技术学院专业班级：大数据技术与应用05班名字：吴雨璇指导老师：张彤老师一：使用python实现微信小程序自动签到意义1.首先对于咱们的APP有很大的作用,那就是当用户点击签到以后,平台就有那么多用户在使用,签到的人越多,产品的活跃度就越高。2.还有一点就是大家应该能够想到,那就是用户点击签到是在首页,有些点开就需要进行签到,点击较多,对于产品销售是非常重要的。3.微
    
                    
    • 
                    
  • flink独立集群部署
                        嘎子吱吱吱吱
flinkhadooplinux
                        
    #flink独立集群部署说明安装环境三台服务器47.106.23.1（master）47.112.173.2（worker1）47.115.162.3（worker1）提前装好jdk和ssh,以下操作最好不要用root账号提前下载好flink的包并解压设置三台服务器之间ssh免密登录生成本机秘钥以47.106.23.1为例（其他两台参考本服务器）#生成本机秘钥cd;ssh-keygen-trsa-
    
                    
    • 
                    
  • Flink的时间与watermarks详解
                        大数据技术与数仓

                        
    当我们在使用Flink的时候，避免不了要和时间(time)、水位线(watermarks)打交道，理解这些概念是开发分布式流处理应用的基础。那么Flink支持哪些时间语义？Flink是如何处理乱序事件的？什么是水位线？水位线是如何生成的？水位线的传播方式是什么？让我们带着这些问题来开始本文的内容。时间语义基本概念时间是Flink等流处理中最重要的概念之一，在Flink中Time可以分为三种：Eve
    
                    
    • 
                    
  • 实时数仓之实时数仓架构(Hudi)(1)
                        2401_84164527
程序员架构
                        
    目前比较流行的实时数仓架构有两类，其中一类是以Flink+Doris为核心的实时数仓架构方案；另一类是以湖仓一体架构为核心的实时数仓架构方案。本文针对Flink+Hudi湖仓一体架构进行介绍，这套架构的特点是可以基于一套数据完全实现Lambda架构。实时数仓架构图如下：技术框架Kafka：用于接入数据源；FlinkCDC：如果直接接入业务数据源可以考虑CDC方式，如果通过Kafka缓冲接入业务数据
    
                    
    • 
                    
  • 2024年大数据最新实时数仓之实时数仓架构(Hudi)
                        2401_84185556
程序员大数据架构
                        
    技术框架Kafka：用于接入数据源；FlinkCDC：如果直接接入业务数据源可以考虑CDC方式，如果通过Kafka缓冲接入业务数据可以忽略;Flink：用于数据ETL，包括接入数据、处理数据及输出数据全链路数据计算任务；Spark：用于数据ETL，包括处理数据及输出数据全链路数据计算任务；Hudi：湖仓一体数据管理框架，用来管理模型数据，包括ODS/DWD/DWS/DIM/ADS等；Doris：O
    
                    
    • 
                    
  • 实时数仓之实时数仓架构(Hudi)(1)，2024年最新熬夜整理华为最新大数据开发笔试题
                        2401_84181221
程序员架构大数据
                        
    +Hudi：湖仓一体数据管理框架，用来管理模型数据，包括ODS/DWD/DWS/DIM/ADS等；+Doris：OLAP引擎，同步数仓结果模型，对外提供数据服务支持；+Hbase：用来存储维表信息，维表数据来源一部分有Flink加工实时写入，另一部分是从Spark任务生产，其主要作用用来支持FlinkETL处理过程中的LookupJoin功能。这里选用Hbase原因主要因为Table的HbaseC
    
                    
    • 
                    
  • starrocks和clickhouse数据库比较
                        CodeMaster_37714848
clickhouse数据库
                        
    Starrocks和ClickHouse都是用于数据分析的数据库，但它们的设计理念和用途有所不同。下面是这两者的一些主要比较点：1.基础架构与设计目标Starrocks:Starrocks是一个专注于实时数据分析的平台，常用于大数据处理和商业智能应用。它设计用于高效处理大规模数据集，并且支持复杂查询和数据处理。支持多种数据源的集成，并且可以与其他大数据技术（如Hadoop、Spark）协同工作。C
    
                    
    • 
                    
  • MySQL数据库运维：深度解析与实践指南
                        野老杂谈
数据库mysql运维
                        
    欢迎来到我的博客，很高兴能够在这里和您见面！欢迎订阅相关专栏：+V:LAF20151116进行更多交流学习⭐️全网最全IT互联网公司面试宝典：收集整理全网各大IT互联网公司技术、项目、HR面试真题.⭐️AIGC时代的创新与未来：详细讲解AIGC的概念、核心技术、应用领域等内容。⭐️全流程数据技术实战指南：全面讲解从数据采集到数据可视化的整个过程，掌握构建现代化数据平台和数据仓库的核心技术和方法。⭐
    
                    
    • 
                    
  • Flink - CEP
                        kikiki1

                        
    Hadoop3.2集群新版本的搭建详细讲解过程，从下面第一张官方的图来看，最新版是3.2，所以大猪将使用3.2的版本来演示，过程中遇到的坑留给自己，把路留给你们，IT之路还有大猪。大猪为了把文章压缩极简方便小伙伴阅读，将使用root帐号进行所有操作。准备两台主机10.211.55.11、10.211.55.12对应的hostname为m1.example.com、m2.example.com具体命
    
                    
    • 
                    
  • Pinterest：从 Druid 到 StarRocks，实现 6 倍成本效益比提升
                        StarRocks_labs
数据库大数据
                        
    导读：开源无国界，StarRocks自开源以来，近3年的时间里已在全球数据技术领域崭露头角。我们欣喜地发现，越来越多的海外用户正在使用并积极推广着StarRocks。为了促进知识共享，StarRocks中文社区将精选优秀文章与大家共享。本篇文章摘自PinterestEngineering撰写的《DeliveringFasterAnalyticsatPinterest》，欢迎阅读原文深入了解：htt
    
                    
    • 
                                
  • Spring4.1新特性——综述
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • Schema与数据类型优化
                                    annan211
数据结构mysql
                                    
    

目前商城的数据库设计真是一塌糊涂，表堆叠让人不忍直视，无脑的架构师，说了也不听。
在数据库设计之初，就应该仔细揣摩可能会有哪些查询，有没有更复杂的查询，而不是仅仅突出
很表面的业务需求，这样做会让你的数据库性能成倍提高，当然，丑陋的架构师是不会这样去考虑问题的。

选择优化的数据类型
 1 更小的通常更好
   更小的数据类型通常更快，因为他们占用更少的磁盘、内存和cpu缓存，
    
                                
    • 
                                
  • 第一节 HTML概要学习
                                    chenke
htmlWebcss
                                    
    第一节 HTML概要学习 
 
1. 什么是HTML 
 
HTML是英文Hyper Text Mark-up Language(超文本标记语言)的缩写，它规定了自己的语法规则，用来表示比“文本”更丰富的意义，比如图片，表格，链接等。浏览器（IE,FireFox等）软件知道HTML语言的语法，可以用来查看HTML文档。目前互联网上的绝大部分网页都是使用HTML编写的。 
 
打开记事本 输入一下内
    
                                
    • 
                                
  • MyEclipse里部分习惯的更改
                                    Array_06
eclipse
                                    
    继续补充中---------------------- 
 
 
 
1.更改自己合适快捷键windows-->prefences-->java-->editor-->Content Assist--> 
     Activation triggers for java的右侧“.”就可以改变常用的快捷键 
 
选中 Text 
    
                                
    • 
                                
  • 近一个月的面试总结
                                    cugfy
面试
                                    
    本文是在学习中的总结，欢迎转载但请注明出处：http://blog.csdn.net/pistolove/article/details/46753275 
 
 
前言 
      打算换个工作，近一个月面试了不少的公司，下面将一些面试经验和思考分享给大家。另外校招也快要开始了，为在校的学生提供一些经验供参考，希望都能找到满意的工作。 
    
                                
    • 
                                
  • HTML5一个小迷宫游戏
                                    357029540
html5
                                    
         通过《HTML5游戏开发》摘抄了一个小迷宫游戏，感觉还不错，可以画画，写字，把摘抄的代码放上来分享下，喜欢的同学可以拿来玩玩！ 
 
<html> 
 <head> 
 <title>创建运行迷宫</title> 
 <script type="text/javascript"
    
                                
    • 
                                
  • 10步教你上传githib数据
                                    张亚雄
git
                                    
    官方的教学还有其他博客里教的都是给懂的人说得，对已我们这样对我大菜鸟只能这么来锻炼，下面先不玩什么深奥的，先暂时用着10步干净利索。等玩顺溜了再用其他的方法。 
操作过程（查看本目录下有哪些文件NO.1）ls 
（跳转到子目录NO.2）cd+空格+目录 
（继续NO.3）ls 
（匹配到子目录NO.4）cd+ 目录首写字母+tab键+（首写字母“直到你所用文件根就不再按TAB键了”） 
（查看文件
    
                                
    • 
                                
  • MongoDB常用操作命令大全
                                    adminjun
mongodb操作命令
                                    
    成功启动MongoDB后，再打开一个命令行窗口输入mongo，就可以进行数据库的一些操作。输入help可以看到基本操作命令，只是MongoDB没有创建数据库的命令，但有类似的命令   如：如果你想创建一个“myTest”的数据库，先运行use myTest命令，之后就做一些操作（如：db.createCollection('user')）,这样就可以创建一个名叫“myTest”的数据库。   
一
    
                                
    • 
                                
  • bat调用jar包并传入多个参数
                                    aijuans

                                    
    下面的主程序是通过eclipse写的： 
1.在Main函数接收bat文件传递的参数（String[] args） 
 如：   String ip =args[0];          String user=args[1];       &nbs
    
                                
    • 
                                
  • Java中对类的主动引用和被动引用
                                    ayaoxinchao
java主动引用对类的引用被动引用类初始化
                                    
      
在Java代码中，有些类看上去初始化了，但其实没有。例如定义一定长度某一类型的数组，看上去数组中所有的元素已经被初始化，实际上一个都没有。对于类的初始化，虚拟机规范严格规定了只有对该类进行主动引用时，才会触发。而除此之外的所有引用方式称之为对类的被动引用，不会触发类的初始化。虚拟机规范严格地规定了有且仅有四种情况是对类的主动引用，即必须立即对类进行初始化。四种情况如下：1.遇到ne
    
                                
    • 
                                
  • 导出数据库 提示 outfile disabled
                                    BigBird2012
mysql
                                    
    在windows控制台下，登陆mysql，备份数据库： 
  
mysql>mysqldump -u root -p test test > D:\test.sql 
使用命令 mysqldump 格式如下： mysqldump -u root -p *** DBNAME > E:\\test.sql。 
注意：执行该命令的时候不要进入mysql的控制台再使用，这样会报
    
                                
    • 
                                
  • Javascript 中的 && 和 ||
                                    bijian1013
JavaScript&&||
                                    
            准备两个对象用于下面的讨论 
var alice = {
    name: "alice",
    toString: function () {
        return this.name;
    }
}
var smith = {
    name: "smith",
 
    
                                
    • 
                                
  • [Zookeeper学习笔记之四]Zookeeper Client Library会话重建
                                    bit1129
zookeeper
                                    
    为了说明问题，先来看个简单的示例代码： 
  
package com.tom.zookeeper.book;

import com.tom.Host;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.Wat
    
                                
    • 
                                
  • 【Scala十一】Scala核心五：case模式匹配
                                    bit1129
scala
                                    
    package spark.examples.scala.grammars.caseclasses

object CaseClass_Test00 {

  def simpleMatch(arg: Any) = arg match {
    case v: Int => "This is an Int"
    case v: (Int, String)
    
                                
    • 
                                
  • 运维的一些面试题
                                    yuxianhua
linux
                                    
    1、Linux挂载Winodws共享文件夹 
  
mount -t cifs //1.1.1.254/ok /var/tmp/share/ -o username=administrator,password=yourpass
或
mount -t cifs -o username=xxx,password=xxxx //1.1.1.1/a /win 
  
 
    
                                
    • 
                                
  • Java lang包-Boolean
                                    BrokenDreams
boolean
                                    
             Boolean类是Java中基本类型boolean的包装类。这个类比较简单，直接看源代码吧。 
 

public final class Boolean implements java.io.Serializable,
                                      
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-命令模式-Command
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 


import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * GOF 在《设计模式》一书中阐述命令模式的意图：“将一个请求封装
    
                                
    • 
                                
  • matlab下GPU编程笔记
                                    cherishLC
matlab
                                    
    不多说，直接上代码 
 
gpuDevice   %   查看系统中的gpu,,其中的DeviceSupported会给出matlab支持的GPU个数。
g=gpuDevice(1);    %会清空 GPU 1中的所有数据,,将GPU1 设为当前GPU
reset(g)  %也可以清空GPU中数据。

a=1;
a=gpuArray(a);    %将a从CPU移到GPU中
onGP
    
                                
    • 
                                
  • SVN安装过程
                                    crabdave
SVN
                                    
    SVN安装过程 
  
subversion-1.6.12 
  
./configure --prefix=/usr/local/subversion --with-apxs=/usr/local/apache2/bin/apxs --with-apr=/usr/local/apr --with-apr-util=/usr/local/apr --with-openssl=/
    
                                
    • 
                                
  • sql　行列转换
                                    daizj
sql行列转换行转列列转行
                                    
    行转列的思想是通过case when 来实现 
列转行的思想是通过union all 来实现 
 
下面具体例子： 
 
假设有张学生成绩表(tb)如下: 
Name Subject Result 
张三 语文　　74 
张三 数学　　83 
张三 物理　　93 
李四 语文　　74 
李四 数学　　84 
李四 物理　　94 
*/ 
/* 
想变成 
姓名   &
    
                                
    • 
                                
  • MySQL--主从配置
                                    dcj3sjt126com
mysql
                                    
       linux下的mysql主从配置：   说明：由于MySQL不同版本之间的(二进制日志)binlog格式可能会不一样，因此最好的搭配组合是Master的MySQL版本和Slave的版本相同或者更低，   Master的版本肯定不能高于Slave版本。（版本向下兼容）   
   mysql1  : 192.168.100.1    //master   mysq
    
                                
    • 
                                
  • 关于yii 数据库添加新字段之后model类的修改
                                    dcj3sjt126com
Model
                                    
    rules: 
array('新字段','safe','on'=>'search') 
1、array('新字段', 'safe')//这个如果是要用户输入的话，要加一下， 
2、array('新字段', 'numerical'),//如果是数字的话 
3、array('新字段', 'length', 'max'=>100),//如果是文本 
1、2、3适当的最少要加一条，新字段才会被
    
                                
    • 
                                
  • sublime text3 中文乱码解决
                                    dyy_gusi
Sublime Text
                                    
    sublime text3中文乱码解决 
原因：缺少转换为UTF-8的插件 
目的：安装ConvertToUTF8插件包 
第一步：安装能自动安装插件的插件，百度“Codecs33”，然后按照步骤可以得到以下一段代码： 
import urllib.request,os,hashlib; h = 'eb2297e1a458f27d836c04bb0cbaf282' + 'd0e7a30980927
    
                                
    • 
                                
  • 概念了解：CGI，FastCGI，PHP-CGI与PHP-FPM
                                    geeksun
PHP
                                    
    CGI 
CGI全称是“公共网关接口”(Common Gateway Interface)，HTTP服务器与你的或其它机器上的程序进行“交谈”的一种工具，其程序须运行在网络服务器上。 
CGI可以用任何一种语言编写，只要这种语言具有标准输入、输出和环境变量。如php,perl,tcl等。 FastCGI 
FastCGI像是一个常驻(long-live)型的CGI，它可以一直执行着，只要激活后，不
    
                                
    • 
                                
  • Git push 报错 "error: failed to push some refs to " 解决
                                    hongtoushizi
git
                                    
    Git push 报错 "error: failed to push some refs to " . 
此问题出现的原因是：由于远程仓库中代码版本与本地不一致冲突导致的。 
由于我在第一次git pull --rebase 代码后，准备push的时候，有别人往线上又提交了代码。所以出现此问题。 
解决方案： 
1： git pull    
2：
    
                                
    • 
                                
  • 第四章 Lua模块开发
                                    jinnianshilongnian
nginxlua
                                    
    在实际开发中，不可能把所有代码写到一个大而全的lua文件中，需要进行分模块开发；而且模块化是高性能Lua应用的关键。使用require第一次导入模块后，所有Nginx 进程全局共享模块的数据和代码，每个Worker进程需要时会得到此模块的一个副本（Copy-On-Write），即模块可以认为是每Worker进程共享而不是每Nginx Server共享；另外注意之前我们使用init_by_lua中初
    
                                
    • 
                                
  • java.lang.reflect.Proxy
                                    liyonghui160com

                                    
      
1.简介 
  
Proxy 提供用于创建动态代理类和实例的静态方法 
（1）动态代理类的属性 
 
 代理类是公共的、最终的，而不是抽象的 
 未指定代理类的非限定名称。但是，以字符串 "$Proxy" 开头的类名空间应该为代理类保留 
 代理类扩展 java.lang.reflect.Proxy  
 代理类会按同一顺序准确地实现其创建时指定的接口
    
                                
    • 
                                
  • Java中getResourceAsStream的用法
                                    pda158
java
                                    
    1.Java中的getResourceAsStream有以下几种： 1. Class.getResourceAsStream(String path) ： path 不以’/'开头时默认是从此类所在的包下取资源，以’/'开头则是从ClassPath根下获取。其只是通过path构造一个绝对路径，最终还是由ClassLoader获取资源。   　　2. Class.getClassLoader.get
    
                                
    • 
                                
  • spring 包官方下载地址（非maven）
                                    sinnk
spring
                                    
    SPRING官方网站改版后，建议都是通过 Maven和Gradle下载，对不使用Maven和Gradle开发项目的，下载就非常麻烦，下给出Spring Framework jar官方直接下载路径: 
  
 http://repo.springsource.org/libs-release-local/org/springframework/spring/ 
  
s
    
                                
    • 
                                
  • Oracle学习笔记(7) 开发PLSQL子程序和包
                                    vipbooks
oraclesql编程
                                    
        哈哈，清明节放假回去了一下，真是太好了，回家的感觉真好啊！现在又开始出差之旅了，又好久没有来了，今天继续Oracle的学习！ 
     这是第七章的学习笔记，学习完第六章的动态SQL之后，开始要学习子程序和包的使用了……，希望大家能多给俺一些支持啊！ 
    编程时使用的工具是PLSQL
    
                                
    •