weixin_34406796
weixin_34406796

Flink – metrics V1.2

WebRuntimeMonitor

 

.GET("/jobs/:jobid/vertices/:vertexid/metrics", handler(new JobVertexMetricsHandler(metricFetcher)))
.GET("/jobs/:jobid/metrics", handler(new JobMetricsHandler(metricFetcher)))
.GET("/taskmanagers/:" + TaskManagersHandler.TASK_MANAGER_ID_KEY + "/metrics", handler(new TaskManagerMetricsHandler(metricFetcher)))
.GET("/jobmanager/metrics", handler(new JobManagerMetricsHandler(metricFetcher)))
 

JobVertexMetricsHandler

 

AbstractMetricsHandler

 

MetricFetcher

核心就是fetchMetrics函数，会从JobManager获取数据，

private void fetchMetrics() {
    try {
        Option> jobManagerGatewayAndWebPort = retriever.getJobManagerGatewayAndWebPort();
        if (jobManagerGatewayAndWebPort.isDefined()) {
            ActorGateway jobManager = jobManagerGatewayAndWebPort.get()._1(); //得到JobManager的ActorGateway

            /**
             * Remove all metrics that belong to a job that is not running and no longer archived.
             */
            Future jobDetailsFuture = jobManager.ask(new RequestJobDetails(true, true), timeout); //生成request获取job状态
            jobDetailsFuture
                .onSuccess(new OnSuccess() {
                    @Override
                    public void onSuccess(Object result) throws Throwable {
                        MultipleJobsDetails details = (MultipleJobsDetails) result;
                        ArrayList toRetain = new ArrayList<>();
                        for (JobDetails job : details.getRunningJobs()) {
                            toRetain.add(job.getJobId().toString());
                        }
                        for (JobDetails job : details.getFinishedJobs()) {
                            toRetain.add(job.getJobId().toString());
                        }
                        synchronized (metrics) {
                            metrics.jobs.keySet().retainAll(toRetain); //只保留Runing和Finished的job，即不正常的都删掉
                        }
                    }
                }, ctx);
            logErrorOnFailure(jobDetailsFuture, "Fetching of JobDetails failed.");

            String jobManagerPath = jobManager.path();
            String queryServicePath = jobManagerPath.substring(0, jobManagerPath.lastIndexOf('/') + 1) + MetricQueryService.METRIC_QUERY_SERVICE_NAME;
            ActorRef jobManagerQueryService = actorSystem.actorFor(queryServicePath);

            queryMetrics(jobManagerQueryService); //查询jobManager的Metrics

            /**
             * We first request the list of all registered task managers from the job manager, and then
             * request the respective metric dump from each task manager.
             *
             * All stored metrics that do not belong to a registered task manager will be removed.
             */
            Future registeredTaskManagersFuture = jobManager.ask(JobManagerMessages.getRequestRegisteredTaskManagers(), timeout); //查询所有taskManager
            registeredTaskManagersFuture
                .onSuccess(new OnSuccess() {
                    @Override
                    public void onSuccess(Object result) throws Throwable {
                        Iterable taskManagers = ((JobManagerMessages.RegisteredTaskManagers) result).asJavaIterable();
                        List activeTaskManagers = new ArrayList<>();
                        for (Instance taskManager : taskManagers) { //遍历taskManager
                            activeTaskManagers.add(taskManager.getId().toString());

                            String taskManagerPath = taskManager.getTaskManagerGateway().getAddress();
                            String queryServicePath = taskManagerPath.substring(0, taskManagerPath.lastIndexOf('/') + 1) + MetricQueryService.METRIC_QUERY_SERVICE_NAME + "_" + taskManager.getTaskManagerID().getResourceIdString();
                            ActorRef taskManagerQueryService = actorSystem.actorFor(queryServicePath);

                            queryMetrics(taskManagerQueryService); //查询每个taskMananger的metrics
                        }
                        synchronized (metrics) { // remove all metrics belonging to unregistered task managers
                            metrics.taskManagers.keySet().retainAll(activeTaskManagers); //删除所有的未注册的TaskManager
                        }
                    }
                }, ctx);
            logErrorOnFailure(registeredTaskManagersFuture, "Fetchin list of registered TaskManagers failed.");
        }
    } catch (Exception e) {
        LOG.warn("Exception while fetching metrics.", e);
    }
} 
    
   
 
 
   
queryMetrics
 
   
 
    
/**
 * Requests a metric dump from the given actor.
 *
 * @param actor ActorRef to request the dump from
 */
private void queryMetrics(ActorRef actor) {
    Future metricQueryFuture = new BasicGateway(actor).ask(MetricQueryService.getCreateDump(), timeout); //获取metrics dump
    metricQueryFuture
        .onSuccess(new OnSuccess() {
            @Override
            public void onSuccess(Object result) throws Throwable {
                addMetrics(result);
            }
        }, ctx);
    logErrorOnFailure(metricQueryFuture, "Fetching metrics failed.");
}

private void addMetrics(Object result) throws IOException {
    byte[] data = (byte[]) result;
    List dumpedMetrics = deserializer.deserialize(data);
    for (MetricDump metric : dumpedMetrics) {
        metrics.add(metric); //把metrics dump加入metrics store
    }
} 
    
   
 
 
   
MetricStore
 
   
用嵌套的hashmap来存储metrics，瞬时值
 
   
 
    
final JobManagerMetricStore jobManager = new JobManagerMetricStore();
final Map taskManagers = new HashMap<>();
final Map jobs = new HashMap<>();
 
   
 
   
 
 
   
 
    
public static class JobManagerMetricStore extends ComponentMetricStore {
}

private static abstract class ComponentMetricStore {
    public final Map metrics = new HashMap<>(); //store就是一个map

    public String getMetric(String name, String defaultValue) {
        String value = this.metrics.get(name);
        return value != null
            ? value
            : defaultValue;
    }
}
 
   
 
   
 
 
   
MetricQueryService
 
   
 
    
public class MetricQueryService extends UntypedActor {
    private static final Logger LOG = LoggerFactory.getLogger(MetricQueryService.class);

    public static final String METRIC_QUERY_SERVICE_NAME = "MetricQueryService";

    private static final CharacterFilter FILTER = new CharacterFilter() {
        @Override
        public String filterCharacters(String input) {
            return replaceInvalidChars(input);
        }
    };

    private final MetricDumpSerializer serializer = new MetricDumpSerializer();

    private final Map, Tuple2> gauges = new HashMap<>();
    private final Map> counters = new HashMap<>();
    private final Map> histograms = new HashMap<>();
    private final Map> meters = new HashMap<>();
 
   
 
   
 
 
   
收到CreateDump请求，
 
   
 
    
} else if (message instanceof CreateDump) {
    byte[] dump = serializer.serialize(counters, gauges, histograms, meters);
    getSender().tell(dump, getSelf());
 
   
 
   
 
 
   
Start
 
   
 
    
   /**
     * Starts the MetricQueryService actor in the given actor system.
     *
     * @param actorSystem The actor system running the MetricQueryService
     * @param resourceID resource ID to disambiguate the actor name
     * @return actor reference to the MetricQueryService
     */
    public static ActorRef startMetricQueryService(ActorSystem actorSystem, ResourceID resourceID) {
        String actorName = resourceID == null
            ? METRIC_QUERY_SERVICE_NAME
            : METRIC_QUERY_SERVICE_NAME + "_" + resourceID.getResourceIdString();
        return actorSystem.actorOf(Props.create(MetricQueryService.class), actorName);
    }
 
   
 
   
 
 
   
在MetricRegistry中把metrics注册到QueryService中，
 
   
 
    
if (queryService != null) {
    MetricQueryService.notifyOfAddedMetric(queryService, metric, metricName, group);
}
 
   
 
   
 
 
   
采集点
 
   
numRecordsIn
 
   
StreamInputProcessor –> processInput
 
   
 
    
    @SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
    public boolean processInput(OneInputStreamOperator streamOperator, final Object lock) throws Exception {
        if (numRecordsIn == null) {
            numRecordsIn = ((OperatorMetricGroup) streamOperator.getMetricGroup()).getIOMetricGroup().getNumRecordsInCounter();
        }
        //......
        
                        
        // now we can do the actual processing
        StreamRecord record = recordOrMark.asRecord();
        synchronized (lock) {
            numRecordsIn.inc(); //执行processElement前加一
            streamOperator.setKeyContextElement1(record);
            streamOperator.processElement(record);
        }
        return true;
 
   
 
   
如果是chaining，
 
   
ChainingOutput
 
   
 
    
private static class ChainingOutput implements Output> {
    
    protected final OneInputStreamOperator operator;
    protected final Counter numRecordsIn;

    public ChainingOutput(OneInputStreamOperator operator) {
        this.operator = operator;
        this.numRecordsIn = ((OperatorMetricGroup) operator.getMetricGroup()).getIOMetricGroup().getNumRecordsInCounter(); //初始化
    }

    @Override
    public void collect(StreamRecord record) {
        try {
            numRecordsIn.inc(); //对于chain，在output时调用processElement
            operator.setKeyContextElement1(record);
            operator.processElement(record);
        }
        catch (Exception e) {
            throw new ExceptionInChainedOperatorException(e);
        }
    }
 
   
 
   
 
 
   
numRecordsOut
 
   
在AbstractStreamOperator初始化时，
 
   
生成CountingOutput
 
   
 
    
    @Override
    public void setup(StreamTask containingTask, StreamConfig config, Output> output) {
        this.container = containingTask;
        this.config = config;
        
        this.metrics = container.getEnvironment().getMetricGroup().addOperator(config.getOperatorName());
        this.output = new CountingOutput(output, ((OperatorMetricGroup) this.metrics).getIOMetricGroup().getNumRecordsOutCounter()); //生成CountingOutput
 
   
 
   
这个output，
 
   
在processWatermark，processElement中会用于emit数据
 
   
output.emitWatermark(mark);
 
   
 
 
   
 
    
    public class CountingOutput implements Output> {
        private final Output> output;
        private final Counter numRecordsOut;

        public CountingOutput(Output> output, Counter counter) {
            this.output = output;
            this.numRecordsOut = counter;
        }

        @Override
        public void emitWatermark(Watermark mark) {
            output.emitWatermark(mark);
        }

        @Override
        public void emitLatencyMarker(LatencyMarker latencyMarker) {
            output.emitLatencyMarker(latencyMarker);
        }

        @Override
        public void collect(StreamRecord record) {
            numRecordsOut.inc(); //发出的时候，inc numRecordsOut
            output.collect(record);
        }

        @Override
        public void close() {
            output.close();
        }
    }
 
   
 
   
 
 
   
注意numRecordsOut和numRecordsIn，除了会统计operator级别的，还会统计task级别的，逻辑在
 
   
AbstractStreamOperator
 
   
 
    
    public void setup(StreamTask containingTask, StreamConfig config, Output> output) {
        this.container = containingTask;
        this.config = config;
        
        this.metrics = container.getEnvironment().getMetricGroup().addOperator(config.getOperatorName());
        this.output = new CountingOutput(output, ((OperatorMetricGroup) this.metrics).getIOMetricGroup().getNumRecordsOutCounter());
        if (config.isChainStart()) {
            ((OperatorMetricGroup) this.metrics).getIOMetricGroup().reuseInputMetricsForTask();
        }
        if (config.isChainEnd()) {
            ((OperatorMetricGroup) this.metrics).getIOMetricGroup().reuseOutputMetricsForTask();
        }
 
   
 
   
OperatorIOMetricGroup
 
   
 
    
    public void reuseInputMetricsForTask() {
        TaskIOMetricGroup taskIO = parentMetricGroup.parent().getIOMetricGroup();
        taskIO.reuseRecordsInputCounter(this.numRecordsIn);
        
    }

    public void reuseOutputMetricsForTask() {
        TaskIOMetricGroup taskIO = parentMetricGroup.parent().getIOMetricGroup();
        taskIO.reuseRecordsOutputCounter(this.numRecordsOut);
    }
 
   
 
   
可以看到，会将ChainHead的numRecordsIn，set到task的TaskIOMetricGroup
 
   
而将ChainEnd的numRecordsOut，set到task的TaskIOMetricGroup
 
   
看起来很合理
 
   
 
 
   
numRecordInPerSecond，numRecordsOutPerSecond
 
   
在OperatorIOMetricGroup
 
   
 
    
public OperatorIOMetricGroup(OperatorMetricGroup parentMetricGroup) {
        super(parentMetricGroup);
        numRecordsIn = parentMetricGroup.counter(MetricNames.IO_NUM_RECORDS_IN);
        numRecordsOut = parentMetricGroup.counter(MetricNames.IO_NUM_RECORDS_OUT);
        numRecordsInRate = parentMetricGroup.meter(MetricNames.IO_NUM_RECORDS_IN_RATE, new MeterView(numRecordsIn, 60));
        numRecordsOutRate = parentMetricGroup.meter(MetricNames.IO_NUM_RECORDS_OUT_RATE, new MeterView(numRecordsOut, 60));
    }
 
   
 
   
可以看到numRecordsInRate和numRecordsOutRate，只是numRecordsIn和numRecordsOut的MeterView
 
   
 
    
public class MeterView implements Meter, View {
    /** The underlying counter maintaining the count */
    private final Counter counter;
    /** The time-span over which the average is calculated */
    private final int timeSpanInSeconds;
    /** Circular array containing the history of values */
    private final long[] values;
    /** The index in the array for the current time */
    private int time = 0;
    /** The last rate we computed */
    private double currentRate = 0;

    public MeterView(Counter counter, int timeSpanInSeconds) {
        this.counter = counter;
        this.timeSpanInSeconds = timeSpanInSeconds - (timeSpanInSeconds % UPDATE_INTERVAL_SECONDS); //timeSpanInSeconds需要是UPDATE_INTERVAL_SECONDS(5)的倍数，
        this.values = new long[this.timeSpanInSeconds / UPDATE_INTERVAL_SECONDS + 1]; //比如timeSpanInSeconds为60，那么就需要保存12个value
    }

    @Override
    public void markEvent() {
        this.counter.inc();
    }

    @Override
    public void markEvent(long n) {
        this.counter.inc(n);
    }

    @Override
    public long getCount() {
        return counter.getCount();
    }

    @Override
    public double getRate() { //获取平均值
        return currentRate;
    }

    @Override
    public void update() { //会被以UPDATE_INTERVAL_SECONDS为间隔调用
        time = (time + 1) % values.length;
        values[time] = counter.getCount();
        currentRate =  ((double) (values[time] - values[(time + 1) % values.length]) / timeSpanInSeconds); //values保存了timeSpanInSeconds时间段的counter的变化过程，所以用最新的减最老的，再除以timeSpanInSeconds
    }
}
 
   
 
   
这个实现真是tricky，不好的设计
 
   
在MetricRegistry中，会创建
 
   
ViewUpdater
 
   
 
    
    public void register(Metric metric, String metricName, AbstractMetricGroup group) {
        try {
            if (reporters != null) {
                for (int i = 0; i < reporters.size(); i++) {
                    MetricReporter reporter = reporters.get(i);
                    if (reporter != null) {
                        FrontMetricGroup front = new FrontMetricGroup>(i, group);
                        reporter.notifyOfAddedMetric(metric, metricName, front);
                    }
                }
            }
            if (queryService != null) {
                MetricQueryService.notifyOfAddedMetric(queryService, metric, metricName, group);
            }
            if (metric instanceof View) {
                if (viewUpdater == null) {
                    viewUpdater = new ViewUpdater(executor);
                }
                viewUpdater.notifyOfAddedView((View) metric);
            }
        } catch (Exception e) {
            LOG.error("Error while registering metric.", e);
        }
    }
 
   
 
   
并且在register metrics的时候，除了注册到reporter，MetricQueryService
 
   
如果是view的子类还要，注册到ViewUpdater
 
   
 
    
    public ViewUpdater(ScheduledExecutorService executor) {
        executor.scheduleWithFixedDelay(new ViewUpdaterTask(lock, toAdd, toRemove), 5, UPDATE_INTERVAL_SECONDS, TimeUnit.SECONDS);
    }
 
   
 
   
ViewUpdater会定期执行ViewUpdaterTask，task中就会调用view的update
 
   
 
 
   
numBytesInLocal, numBytesInRemote
 
   
在RemoteInputChannel和LocalInputChannel中，
 
   
 
    
    public LocalInputChannel(
        SingleInputGate inputGate,
        int channelIndex,
        ResultPartitionID partitionId,
        ResultPartitionManager partitionManager,
        TaskEventDispatcher taskEventDispatcher,
        int initialBackoff,
        int maxBackoff,
        TaskIOMetricGroup metrics) {

        super(inputGate, channelIndex, partitionId, initialBackoff, maxBackoff, metrics.getNumBytesInLocalCounter()); //metrics.getNumBytesInLocalCounter()
        
    public RemoteInputChannel(
        SingleInputGate inputGate,
        int channelIndex,
        ResultPartitionID partitionId,
        ConnectionID connectionId,
        ConnectionManager connectionManager,
        int initialBackOff,
        int maxBackoff,
        TaskIOMetricGroup metrics) {

        super(inputGate, channelIndex, partitionId, initialBackOff, maxBackoff, metrics.getNumBytesInRemoteCounter()); // metrics.getNumBytesInRemoteCounter()
 
   
 
   
并且都会在
 
   
BufferAndAvailability getNextBuffer()
 
   
会调用，
 
   
numBytesIn.inc(next.getSize());
 
   
  
 
   
numBytesOut
 
   
RecordWriter
 
   
 
    
public class RecordWriterextends IOReadableWritable> {
    private Counter numBytesOut = new SimpleCounter();
    
    public void emit(T record) throws IOException, InterruptedException {
        for (int targetChannel : channelSelector.selectChannels(record, numChannels)) {
            sendToTarget(record, targetChannel);
        }
    }
    
    private void sendToTarget(T record, int targetChannel) throws IOException, InterruptedException {
        RecordSerializer serializer = serializers[targetChannel];

        synchronized (serializer) {
            SerializationResult result = serializer.addRecord(record);

            while (result.isFullBuffer()) {
                Buffer buffer = serializer.getCurrentBuffer();

                if (buffer != null) {
                    numBytesOut.inc(buffer.getSize()); //计数numBytesOut
                    writeAndClearBuffer(buffer, targetChannel, serializer);

                    // If this was a full record, we are done. Not breaking
                    // out of the loop at this point will lead to another
                    // buffer request before breaking out (that would not be
                    // a problem per se, but it can lead to stalls in the
                    // pipeline).
                    if (result.isFullRecord()) {
                        break;
                    }
                } else {
                    buffer = targetPartition.getBufferProvider().requestBufferBlocking();
                    result = serializer.setNextBuffer(buffer);
                }
            }
        }
    }
 
   
 
   
RecordWriterOutput.collect –> StreamRecordWriter.emit –> RecordWriter.emit
 
   
 
 
   
inputQueueLength, outputQueueLength, inPoolUsage, outPoolUsage
 
   
TaskIOMetricGroup
 
   
 
    
   /**
     * Initialize Buffer Metrics for a task
     */
    public void initializeBufferMetrics(Task task) {
        final MetricGroup buffers = addGroup("buffers");
        buffers.gauge("inputQueueLength", new InputBuffersGauge(task));
        buffers.gauge("outputQueueLength", new OutputBuffersGauge(task));
        buffers.gauge("inPoolUsage", new InputBufferPoolUsageGauge(task));
        buffers.gauge("outPoolUsage", new OutputBufferPoolUsageGauge(task));
    }
 
   
 
   
 
 
   
inputQueueLength
 
   
 
    
for (SingleInputGate inputGate : task.getAllInputGates()) {
    totalBuffers += inputGate.getNumberOfQueuedBuffers();
}
 
   
 
   
inputGate.getNumberOfQueuedBuffers
 
   
 
    
for (InputChannel channel : inputChannels.values()) {
    if (channel instanceof RemoteInputChannel) { // 只统计RemoteInputChannel
        totalBuffers += ((RemoteInputChannel) channel).getNumberOfQueuedBuffers();
    }
}
 
   
 
   
getNumberOfQueuedBuffers
 
   
 
    
/**
     * The received buffers. Received buffers are enqueued by the network I/O thread and the queue
     * is consumed by the receiving task thread.
     */
    private final Queue receivedBuffers = new ArrayDeque<>();

    public int getNumberOfQueuedBuffers() {
        synchronized (receivedBuffers) {
            return receivedBuffers.size();
        }
    }
 
   
 
   
 
 
   
outputQueueLength
 
   
 
    
for (ResultPartition producedPartition : task.getProducedPartitions()) {
    totalBuffers += producedPartition.getNumberOfQueuedBuffers();
}
 
   
 
   
ResultPartition getNumberOfQueuedBuffers
 
   
 
    
for (ResultSubpartition subpartition : subpartitions) {
    totalBuffers += subpartition.getNumberOfQueuedBuffers();
}
 
   
 
   
SpillableSubpartition getNumberOfQueuedBuffers
 
   
 
    
class SpillableSubpartition extends ResultSubpartition {
    /** Buffers are kept in this queue as long as we weren't ask to release any. */
    private final ArrayDeque buffers = new ArrayDeque<>();
    
    @Override
    public int getNumberOfQueuedBuffers() {
        return buffers.size();
    }
 
   
 
   
inputQueueLength, outputQueueLength
 
   
指标的含义是，inputchannel和resultparitition，持有的buffer个数，这些buffer被读完后会release，所以链路通畅的话，length应该会很小
 
   
 
 
   
inPoolUsage
 
   
 
    
int usedBuffers = 0;
int bufferPoolSize = 0;

for (SingleInputGate inputGate : task.getAllInputGates()) {
    usedBuffers += inputGate.getBufferPool().bestEffortGetNumOfUsedBuffers();
    bufferPoolSize += inputGate.getBufferPool().getNumBuffers();
}

if (bufferPoolSize != 0) {
    return ((float) usedBuffers) / bufferPoolSize;
} else {
    return 0.0f;
}
 
   
 
   
bestEffortGetNumOfUsedBuffers()
 
   
 
    
@Override
public int bestEffortGetNumOfUsedBuffers() {
    return Math.max(0, numberOfRequestedMemorySegments - availableMemorySegments.size());
}
 
   
 
   
numberOfRequestedMemorySegments，从bufferpool申请多少 
availableMemorySegments，可用的 
所以相减就是使用多少
 
   
 
 
   
outPoolUsage
 
   
 
    
int usedBuffers = 0;
int bufferPoolSize = 0;

for (ResultPartition resultPartition : task.getProducedPartitions()) {
    usedBuffers += resultPartition.getBufferPool().bestEffortGetNumOfUsedBuffers();
    bufferPoolSize += resultPartition.getBufferPool().getNumBuffers();
}

if (bufferPoolSize != 0) {
    return ((float) usedBuffers) / bufferPoolSize;
} else {
    return 0.0f;
}
 
   
 
   
和inPoolUsage类似，也是看bufferPool的情况
 
   
所以inPoolUsage，outPoolUsage表示的是inputgate和resultpartition中bufferpool的使用情况
 
   
这个bufferpool是inputgate初始化的时候，注册到NetworkEnvironment创建的，
 
   
 
    
// Setup the buffer pool for each buffer reader
final SingleInputGate[] inputGates = task.getAllInputGates();

for (SingleInputGate gate : inputGates) {
    BufferPool bufferPool = null;

    try {
        bufferPool = networkBufferPool.createBufferPool(gate.getNumberOfInputChannels(), false);
        gate.setBufferPool(bufferPool);
    }
 
   
 
   
可以看到默认大小是，inputchanels的size
 
   
如果pool用完了，那么inputGate和ResultPartiton就无法继续读取新的数据
 
   
 
 
   
latency
 
   
在AbstractStreamOperator中，
 
   
setup，
 
   
protected LatencyGauge latencyGauge;
 
   
latencyGauge = this.metrics.gauge("latency", new LatencyGauge(historySize));
 
   
 
 
   
注意，这里metrics是OperatorMetricGroup
 
   
this.metrics = container.getEnvironment().getMetricGroup().addOperator(config.getOperatorName());
 
   
TaskMetricGroup
 
   
 
    
    public OperatorMetricGroup addOperator(String name) {
        OperatorMetricGroup operator = new OperatorMetricGroup(this.registry, this, name);

        synchronized (this) {
            OperatorMetricGroup previous = operators.put(name, operator);
            if (previous == null) {
                // no operator group so far
                return operator;
            } else {
                // already had an operator group. restore that one.
                operators.put(name, previous);
                return previous;
            }
        }
    }
 
   
 
   
 
 
   
 
 
   
LatencyGauge的定义，
 
   
 
    
/**
     * The gauge uses a HashMap internally to avoid classloading issues when accessing
     * the values using JMX.
     */
    protected static class LatencyGauge implements Gauge>> {
    
        //LatencySourceDescriptor，包含vertexID和subtaskIndex
        //DescriptiveStatistics，统计模块
        private final Map latencyStats = new HashMap<>();
        private final int historySize;

        LatencyGauge(int historySize) {
            this.historySize = historySize;
        }

        public void reportLatency(LatencyMarker marker, boolean isSink) {
            LatencySourceDescriptor sourceDescriptor = LatencySourceDescriptor.of(marker, !isSink);
            DescriptiveStatistics sourceStats = latencyStats.get(sourceDescriptor);
            if (sourceStats == null) { //初始化DescriptiveStatistics
                // 512 element window (4 kb)
                sourceStats = new DescriptiveStatistics(this.historySize);
                latencyStats.put(sourceDescriptor, sourceStats);
            }
            long now = System.currentTimeMillis();
            sourceStats.addValue(now - marker.getMarkedTime()); //当前时间和source发出时时间差值作为延迟
        }

        @Override
        public Map> getValue() {
            while (true) {
                try {
                    Map> ret = new HashMap<>();
                    for (Map.Entry source : latencyStats.entrySet()) {
                        HashMap sourceStatistics = new HashMap<>(6);
                        sourceStatistics.put("max", source.getValue().getMax());
                        sourceStatistics.put("mean", source.getValue().getMean());
                        sourceStatistics.put("min", source.getValue().getMin());
                        sourceStatistics.put("p50", source.getValue().getPercentile(50));
                        sourceStatistics.put("p95", source.getValue().getPercentile(95));
                        sourceStatistics.put("p99", source.getValue().getPercentile(99));
                        ret.put(source.getKey().toString(), sourceStatistics);
                    }
                    return ret;
                    // Concurrent access onto the "latencyStats" map could cause
                    // ConcurrentModificationExceptions. To avoid unnecessary blocking
                    // of the reportLatency() method, we retry this operation until
                    // it succeeds.
                } catch(ConcurrentModificationException ignore) {
                    LOG.debug("Unable to report latency statistics", ignore);
                }
            }
        }
    }
     
   
 
   
这个Gauge.getValue返回的是个map，太奇葩
 
   
latencyStats里面有多少entry，取决于有多少source，以及每个source有几个并发
 
   
因为他要记录，每个source operator的某个subtask，到当前operator的该subtask的延迟
 
   
 
    
        public static LatencySourceDescriptor of(LatencyMarker marker, boolean ignoreSubtaskIndex) {
            if (ignoreSubtaskIndex) {
                return new LatencySourceDescriptor(marker.getVertexID(), -1);
            } else {
                return new LatencySourceDescriptor(marker.getVertexID(), marker.getSubtaskIndex());
            }

        }
 
   
 
   
LatencySourceDescriptor构造函数，由vertexid，和subtaskIndex组成
 
   
如果忽略subtaskindex，置为-1
 
   
 
 
   
 
 
   
流程
 
   
StreamSource
 
   
定义LatencyMarksEmitter
 
   
 
    
private static class LatencyMarksEmitter {
        private final ScheduledFuture latencyMarkTimer;

        public LatencyMarksEmitter(
                final ProcessingTimeService processingTimeService,
                final Output> output,
                long latencyTrackingInterval,
                final int vertexID,
                final int subtaskIndex) {

            latencyMarkTimer = processingTimeService.scheduleAtFixedRate( //根据processingTime定期发送latencyMarker
                new ProcessingTimeCallback() {
                    @Override
                    public void onProcessingTime(long timestamp) throws Exception {
                        try {
                            // ProcessingTimeService callbacks are executed under the checkpointing lock
                            output.emitLatencyMarker(new LatencyMarker(timestamp, vertexID, subtaskIndex)); //emitLatencyMarker，以processTime为初始时间
                        } catch (Throwable t) {
                            // we catch the Throwables here so that we don't trigger the processing
                            // timer services async exception handler
                            LOG.warn("Error while emitting latency marker.", t);
                        }
                    }
                },
                0L,
                latencyTrackingInterval);
        }
 
   
 
   
 
 
   
source.run，当isLatencyTrackingEnabled，schedule latency marker
 
   
 
    
public void run(final Object lockingObject, final Output> collector) throws Exception {
        final TimeCharacteristic timeCharacteristic = getOperatorConfig().getTimeCharacteristic();

        LatencyMarksEmitter latencyEmitter = null;
        if(getExecutionConfig().isLatencyTrackingEnabled()) {
            latencyEmitter = new LatencyMarksEmitter<>(
                getProcessingTimeService(),
                collector,
                getExecutionConfig().getLatencyTrackingInterval(),
                getOperatorConfig().getVertexID(),
                getRuntimeContext().getIndexOfThisSubtask());
        }
 
   
 
   
 
 
   
 
 
   
StreamInputProcessor –> processInput
 
   
如果是isLatencyMarker
 
   
 
    
else if(recordOrMark.isLatencyMarker()) {
    // handle latency marker
    synchronized (lock) {
        streamOperator.processLatencyMarker(recordOrMark.asLatencyMarker());
    }
    continue;
}
 
   
 
   
对于，chaining， ChainingOutput
 
   
 
    
private static class ChainingOutput implements Output> {
    
    protected final OneInputStreamOperator operator;
    protected final Counter numRecordsIn;

    @Override
    public void emitLatencyMarker(LatencyMarker latencyMarker) {
        try {
            operator.processLatencyMarker(latencyMarker);
        }
        catch (Exception e) {
            throw new ExceptionInChainedOperatorException(e);
        }
    }
 
   
 
   
 
 
   
AbstractStreamOperator
 
   
 
    
public void processLatencyMarker(LatencyMarker latencyMarker) throws Exception {
        reportOrForwardLatencyMarker(latencyMarker);
    }
 
   
 
   
 
 
   
 
    
protected void reportOrForwardLatencyMarker(LatencyMarker marker) {
        // all operators are tracking latencies
        this.latencyGauge.reportLatency(marker, false);

        // everything except sinks forwards latency markers
        this.output.emitLatencyMarker(marker);
    }
 
   
 
   
调用到latencyGauge.reportLatency，逻辑如上
 
   
后续继续emitLatencyMarker
 
   
 
   
 
 
   
currentLowWatermark, checkpointAlignmentTime
 
   
OneInputStreamTask
 
   
 
    
@Override
    public void init() throws Exception {
         if (numberOfInputs > 0) {
            InputGate[] inputGates = getEnvironment().getAllInputGates();
            inputProcessor = new StreamInputProcessor(
                    inputGates, inSerializer,
                    this, 
                    configuration.getCheckpointMode(),
                    getEnvironment().getIOManager(),
                    getEnvironment().getTaskManagerInfo().getConfiguration());

            // make sure that stream tasks report their I/O statistics
            inputProcessor.setMetricGroup(getEnvironment().getMetricGroup().getIOMetricGroup());
        }
    }
 
   
 
   
 
 
   
StreamInputProcessor
 
   
 
    
    public void setMetricGroup(TaskIOMetricGroup metrics) {
        metrics.gauge("currentLowWatermark", new Gauge() {
            @Override
            public Long getValue() {
                return lastEmittedWatermark;
            }
        });

        metrics.gauge("checkpointAlignmentTime", new Gauge() {
            @Override
            public Long getValue() {
                return barrierHandler.getAlignmentDurationNanos();
            }
        });
    }
 
   
 
   
 
 
   
currentLowWatermark，即lastEmittedWatermark
 
   
默认值是，
 
   
lastEmittedWatermark = Long.MIN_VALUE;
 
   
所以如果没有assignTimestampsAndWatermarks，那么currentLowWatermark会是一个极大的负数
 
   
 
    
    public boolean processInput(OneInputStreamOperator streamOperator, final Object lock) throws Exception {
        while (true) {
            if (currentRecordDeserializer != null) {
              
                if (result.isFullRecord()) {
                    StreamElement recordOrMark = deserializationDelegate.getInstance();

                    if (recordOrMark.isWatermark()) {
                        long watermarkMillis = recordOrMark.asWatermark().getTimestamp();
                        if (watermarkMillis > watermarks[currentChannel]) { // 更新每个channel对应的waterMark
                            watermarks[currentChannel] = watermarkMillis;
                            long newMinWatermark = Long.MAX_VALUE;
                            for (long watermark: watermarks) { // 找出所有channel最小的watermark，以最小的为准
                                newMinWatermark = Math.min(watermark, newMinWatermark); 
                            }
                            if (newMinWatermark > lastEmittedWatermark) {
                                lastEmittedWatermark = newMinWatermark; // 将最小的watermark设为lastEmittedWatermark
                                synchronized (lock) {
                                    streamOperator.processWatermark(new Watermark(lastEmittedWatermark));
                                }
                            }
                        }
                        continue;
                    }
 
   
 
   
 
 
   
checkpointAlignmentTime
 
   
barrierHandler.getAlignmentDurationNanos
 
   
 
    
    @Override
    public long getAlignmentDurationNanos() {
        long start = this.startOfAlignmentTimestamp;
        if (start <= 0) {
            return latestAlignmentDurationNanos;
        } else {
            return System.nanoTime() - start;
        }
    }
 
   
 
   
startOfAlignmentTimestamp是在这次checkpoint开始的时候打的时间戳，即beginNewAlignment
 
   
 
    
    private void beginNewAlignment(long checkpointId, int channelIndex) throws IOException {
        currentCheckpointId = checkpointId;
        onBarrier(channelIndex);

        startOfAlignmentTimestamp = System.nanoTime();
    }
 
   
 
   
beginNewAlignment在
 
   
processBarrier中被调用，
 
   
 
    
        if (numBarriersReceived > 0) {
            // this is only true if some alignment is already progress and was not canceled

            if (barrierId == currentCheckpointId) {
                // regular case
                onBarrier(channelIndex);
            }
            else if (barrierId > currentCheckpointId) {// 当收到新的checkpointid，所以老的id已经过期，需要产生新的checkpoint
                // we did not complete the current checkpoint, another started before
                LOG.warn("Received checkpoint barrier for checkpoint {} before completing current checkpoint {}. " +
                        "Skipping current checkpoint.", barrierId, currentCheckpointId);

                // let the task know we are not completing this
                notifyAbort(currentCheckpointId, new CheckpointDeclineSubsumedException(barrierId));

                // abort the current checkpoint
                releaseBlocksAndResetBarriers();

                // begin a the new checkpoint
                beginNewAlignment(barrierId, channelIndex); //标识checkpoint开始
            }
            else {
                // ignore trailing barrier from an earlier checkpoint (obsolete now)
                return;
            }
        }
        else if (barrierId > currentCheckpointId) { //新的checkpoint开始
            // first barrier of a new checkpoint
            beginNewAlignment(barrierId, channelIndex); //标识checkpoint开始
        }
 
   
 
   
所以checkpointAlignmentTime的意思是，当前的checkpoint已经等待多久，因为要等到所有input channel的barrier，checkpoint才会触发
 
   
单位是纳秒，所以billion级别代表秒
 
   
如果比较大，说明各个并发之前的延迟差异较大，或延迟较高
 
   
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Flink – metrics V1.2)

        

            

                
    
                    
  • nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    
                    
    • 
                    
  • K近邻算法_分类鸢尾花数据集
                        _feivirus_
算法机器学习和数学分类机器学习K近邻
                        
    importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
    
                    
    • 
                    
  • 全面指南：用户行为从前端数据采集到实时处理的最佳实践
                        数字沉思
营销流量运营系统架构前端内容运营大数据
                        
    引言在当今的数据驱动世界，实时数据采集和处理已经成为企业做出及时决策的重要手段。本文将详细介绍如何通过前端JavaScript代码采集用户行为数据、利用API和Kafka进行数据传输、通过Flink实时处理数据的完整流程。无论你是想提升产品体验还是做用户行为分析，这篇文章都将为你提供全面的解决方案。设计一个通用的ClickHouse表来存储用户事件时，需要考虑多种因素，包括事件类型、时间戳、用户信
    
                    
    • 
                    
  • 详解 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、前端等等。网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是
    
                    
    • 
                    
  • 使用3DUNet训练自己的数据集（pytorch）— 医疗影像分割
                        编程日记✧
智能医疗pytorch人工智能python计算机视觉图像处理深度学习健康医疗
                        
    代码：lee-zq/3DUNet-Pytorch:3DUNetimplementedwithpytorch(github.com)文章<cicek16miccai.pdf(uni-freiburg.de)3DU-Net:LearningDenseVolumetricSegmentation
    
                    
    • 
                    
  • 弹性资源组件集成系列(一)datax集成弹性资源设计解释
                        中间件XL
弹性资源组件k8s分布式dataX弹性资源分布式dataxk8s
                        
    简介弹性组件集成有弹性需求的组件，为组件增加高弹性容量，规划集成datax，elastic-job，xxl-job，sentineldashboard，dolphinscheduer，eventbridgedatax基于社区版，此前已对datax进行重构，增加其metricsexporter，分布式特性，分布式模型是基于启动的worker分配，固定的worker数量，如果分片少，浪费资源；分片多，
    
                    
    • 
                    
  • 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):数
    
                    
    • 
                    
  • 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-
    
                    
    • 
                    
  • 如何辨别python2？转python3 | v1.2
                        大白python

                        
    如何辨别python2教学视频中，如何辨别python2？学习python，免不了收集一大堆的教学视频，如前篇说到，python3不再向下兼容2了，手上的视频如何辨别？官方给出的修文档中，可知最明显的改变是：print改为函数形式，代码需写成：print()在教学者没有提示的情况下，可以从print函数判断出是python2还是3.print函数虽然print语法是Python3中一个很小的改动，
    
                    
    • 
                    
  • 推荐算法学习记录2.2——kaggle数据集的动漫电影数据集推荐算法实践——基于内容的推荐算法、协同过滤推荐
                        萱仔学习自我记录
推荐算法学习pythonmatplotlib开发语言
                        
    1、基于内容的推荐：这种方法根据项的相关信息（如描述信息、标签等）和用户对项的操作行为（如评论、收藏、点赞等）来构建推荐算法模型。它可以直接利用物品的内容特征进行推荐，适用于内容较为丰富的场景。‌#1.基于内容的推荐算法fromsklearn.feature_extraction.textimportTfidfVectorizerfromsklearn.metrics.pairwiseimport
    
                    
    • 
                    
  • 详解 JuiceFS sync 新功能，选择性同步增强与多场景性能优化
                        Juicedata
性能优化
                        
    JuiceFSsync是一个强大的数据同步工具，支持在多种存储系统之间进行并发同步或迁移数据，包括对象存储、JuiceFS、NFS、HDFS、本地文件系统等。此外，该工具还提供了增量同步、模式匹配（类似Rsync）、分布式同步等高级功能。在最新的v1.2版本中，针对Juicesync我们引入了多项新功能，并对多个场景进行了性能优化，以提高用户在处理大目录和复杂迁移时的数据同步效率。新增功能增强选择
    
                    
    • 
                    
  • 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
    
                    
    • 
                    
  • CPR曲面重建代码
                        peanut_wu
算法
                        
    废话不说，直接上代码：#include"vtkAutoInit.h"#include"vtkPolyData.h"#include"vtkProbeFilter.h"#include"vtkParametricFunctionSource.h"#include"vtkParametricSpline.h"#include"vtkDICOMImageReader.h"#include"vtkPoin
    
                    
    • 
                    
  • 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具体命
    
                    
    • 
                    
  • chapter01 Java语言概述 知识点Note
                        月下绯烟
Javajava开发语言
                        
    JavaSEJavaEEJavaME大数据Java基础常用技术栈mysqlJDBCSSMspring+springmvc+mybatisLinuxnacosHadoopFlinkJAVAEE消息队列rabbitMQdocker数据库redisspringbootspringcloudsshstruts+spring+hibernate过时技术栈很少用JAVA虚拟机jvm分布式微服务高并发常见dos
    
                    
    • 
                    
  • 【无标题】大数据之批处理，流处理，批流一体概念
                        数字天下
大数据
                        
    批处理批处理是将一定量的数据集合在一起，形成一个数据批次，然后对这个批次中的数据进行处理。Spark和Flink都支持批处理，其中Spark使用的是批处理模型，即将一批数据一次性读入内存，然后对其进行处理，处理完成后再将结果写入磁盘。Flink也支持批处理，但使用的是基于流处理的批处理模式，即将一批数据分成多个数据流进行处理，可以实现更高效的内存管理和更低的延迟。流处理流式处理是一种将数据流式地处
    
                    
    • 
                                
  • C/C++Win32编程基础详解视频下载
                                    择善Zach
编程C++Win32
                                    
    课题视频：C/C++Win32编程基础详解 
视频知识：win32窗口的创建 
                  windows事件机制 
主讲：择善Uncle老师 
学习交流群：386620625 
验证码：625 
 
--
    
                                
    • 
                                
  • Guava Cache使用笔记
                                    bylijinnan
javaguavacache
                                    
    1.Guava Cache的get/getIfPresent方法当参数为null时会抛空指针异常 
 
我刚开始使用时还以为Guava Cache跟HashMap一样，get(null)返回null。 
实际上Guava整体设计思想就是拒绝null的，很多地方都会执行com.google.common.base.Preconditions.checkNotNull的检查。 
 
 
2.Guava
    
                                
    • 
                                
  • 解决ora-01652无法通过128（在temp表空间中）
                                    0624chenhong
oracle
                                    
    解决ora-01652无法通过128（在temp表空间中）扩展temp段的过程 
 
一个sql语句后，大约花了10分钟，好不容易有一个结果，但是报了一个ora-01652错误，查阅了oracle的错误代码说明：意思是指temp表空间无法自动扩展temp段。这种问题一般有两种原因：一是临时表空间空间太小，二是不能自动扩展。 
分析过程： 
   既然是temp表空间有问题，那当
    
                                
    • 
                                
  • Struct在jsp标签
                                    不懂事的小屁孩
struct
                                    
    非UI标签介绍： 
控制类标签： 
1：程序流程控制标签   if   elseif    else 
<s:if test="isUsed"> 
 <span class="label label-success">True</span> 
</
    
                                
    • 
                                
  • 按对象属性排序
                                    换个号韩国红果果
JavaScript对象排序
                                    
    利用JavaScript进行对象排序，根据用户的年龄排序展示 
 
<script>
var bob={
name;bob,
age:30
}
var peter={
name;peter,
age:30
}
var amy={
name;amy,
age:24
}
var mike={
name;mike,
age:29
}
var john={

    
                                
    • 
                                
  • 大数据分析让个性化的客户体验不再遥远
                                    蓝儿唯美
数据分析
                                    
    顾客通过多种渠道制造大量数据，企业则热衷于利用这些信息来实现更为个性化的体验。 
分析公司Gartner表示，高级分析会成为客户服务的关键，但是大数据分析的采用目前仅局限于不到一成的企业。 挑战在于企业还在努力适应结构化数据，疲于根据自身的客户关系管理（CRM）系统部署有效的分析框架，以及集成不同的内外部信息源。 
然而，面对顾客通过数字技术参与而产生的快速变化的信息，企业需要及时作出反应。要想实
    
                                
    • 
                                
  • java笔记4
                                    a-john
java
                                    
    操作符 
1，使用java操作符 
      操作符接受一个或多个参数，并生成一个新值。参数的形式与普通的方法调用不用，但是效果是相同的。加号和一元的正号（+）、减号和一元的负号（-）、乘号（*）、除号（/）以及赋值号（=）的用法与其他编程语言类似。 
      操作符作用于操作数，生成一个新值。另外，有些操作符可能会改变操作数自身的
    
                                
    • 
                                
  • 从裸机编程到嵌入式Linux编程思想的转变------分而治之：驱动和应用程序
                                    aijuans
嵌入式学习
                                    
        笔者学习嵌入式Linux也有一段时间了，很奇怪的是很多书讲驱动编程方面的知识，也有很多书将ARM9方面的知识，但是从以前51形式的（对寄存器直接操作，初始化芯片的功能模块）编程方法，和思维模式，变换为基于Linux操作系统编程，讲这个思想转变的书几乎没有，让初学者走了很多弯路，撞了很多难墙。 
    笔者因此写上自己的学习心得，希望能给和我一样转变
    
                                
    • 
                                
  • 在springmvc中解决FastJson循环引用的问题
                                    asialee
循环引用fastjson
                                    
              我们先来看一个例子： 
          
package com.elong.bms;

import java.io.OutputStream;
import java.util.HashMap;
import java.util.Map;

import co
    
                                
    • 
                                
  • ArrayAdapter和SimpleAdapter技术总结
                                    百合不是茶
androidSimpleAdapterArrayAdapter高级组件基础
                                    
    ArrayAdapter比较简单，但它只能用于显示文字。而SimpleAdapter则有很强的扩展性，可以自定义出各种效果 
  
ArrayAdapter;的数据可以是数组或者是队列 
  
     // 获得下拉框对象 
AutoCompleteTextView textview = (AutoCompleteTextView) this

    
                                
    • 
                                
  • 九封信
                                    bijian1013
人生励志
                                    
            有时候，莫名的心情不好，不想和任何人说话，只想一个人静静的发呆。有时候，想一个人躲起来脆弱，不愿别人看到自己的伤口。有时候，走过熟悉的街角，看到熟悉的背影，突然想起一个人的脸。有时候，发现自己一夜之间就长大了。         2014，写给人
    
                                
    • 
                                
  • Linux下安装MySQL Web 管理工具phpMyAdmin
                                    sunjing
PHPInstallphpMyAdmin
                                    
    PHP http://php.net/ 
phpMyAdmin http://www.phpmyadmin.net 
Error compiling PHP on CentOS x64 
  
一、安装Apache 
请参阅http://billben.iteye.com/admin/blogs/1985244 
  
二、安装依赖包 
sudo yum install gd 
    
                                
    • 
                                
  • 分布式系统理论
                                    bit1129
分布式
                                    
    FLP 
One famous theory in distributed computing, known as FLP after the authors Fischer, Lynch, and Patterson, proved that in a distributed system with asynchronous communication and process crashes, 
    
                                
    • 
                                
  • ssh2整合(spring+struts2+hibernate)-附源码
                                    白糖_
eclipsespringHibernatemysql项目管理
                                    
    最近抽空又整理了一套ssh2框架，主要使用的技术如下： 
spring做容器，管理了三层(dao,service,actioin)的对象 
struts2实现与页面交互(MVC)，自己做了一个异常拦截器，能拦截Action层抛出的异常 
hibernate与数据库交互 
BoneCp数据库连接池，据说比其它数据库连接池快20倍，仅仅是据说 
MySql数据库 
  
项目用eclipse
    
                                
    • 
                                
  • treetable bug记录
                                    braveCS
table
                                    
    // 插入子节点删除再插入时不能正常显示。修改：
//不知改后有没有错，先做个备忘
 Tree.prototype.removeNode = function(node) {
      // Recursively remove all descendants of +node+
      this.unloadBranch(node);

      // Remove
    
                                
    • 
                                
  • 编程之美-电话号码对应英语单词
                                    bylijinnan
java算法编程之美
                                    
    

import java.util.Arrays;

public class NumberToWord {

	/**
	 * 编程之美 电话号码对应英语单词
	 * 题目：
     *  手机上的拨号盘，每个数字都对应一些字母，比如2对应ABC，3对应DEF.........，8对应TUV，9对应WXYZ，
     *  要求对一段数字，输出其代表的所有可能的字母组合
    
                                
    • 
                                
  • jquery ajax读书笔记
                                    chengxuyuancsdn
jQuery ajax
                                    
    1、jsp页面 
 
<%@ page language="java" import="java.util.*" pageEncoding="GBK"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()
    
                                
    • 
                                
  • JWFD工作流拓扑结构解析伪码描述算法
                                    comsci
数据结构算法工作活动J#
                                    
      对工作流拓扑结构解析感兴趣的朋友可以下载附件，或者下载JWFD的全部代码进行分析 
 
 
  /*  流程图拓扑结构解析伪码描述算法 
 
        public java.util.ArrayList DFS(String graphid, String stepid, int j) 
    
                                
    • 
                                
  • oracle I/O 从属进程
                                    daizj
oracle
                                    
    I/O 从属进程 
 
　　I/O从属进程用于为不支持异步I/O的系统或设备模拟异步I/O.例如，磁带设备(相当慢)就不支持异步I/O.通过使用I/O 从属进程，可以让磁带机模仿通常只为磁盘驱动器提供的功能。就好像支持真正的异步I/O 一样，写设备的进程(调用者)会收集大量数据，并交由写入器写出。数据成功地写出时，写入器(此时写入器是I/O 从属进程，而不是操作系统)会通知原来的调用者，调用者则会
    
                                
    • 
                                
  • 高级排序:希尔排序
                                    dieslrae
希尔排序
                                    
    
    public void shellSort(int[] array){
        int limit = 1;
        int temp;
        int index;
        
        while(limit <= array.length/3){
            limit = limit * 3 + 1;
    
    
                                
    • 
                                
  • 初二下学期难记忆单词
                                    dcj3sjt126com
englishword
                                    
    kitchen 厨房 
cupboard 厨柜 
salt 盐 
sugar 糖 
oil 油 
fork 叉；餐叉 
spoon 匙；调羹 
chopsticks 筷子 
cabbage 卷心菜；洋白菜 
soup 汤 
Italian 意大利的 
  
Indian 印度的 
workplace  工作场所 
even 甚至；更 
Italy 意大利 
laugh 笑 
m
    
                                
    • 
                                
  • Go语言使用MySQL数据库进行增删改查
                                    dcj3sjt126com
mysql
                                    
    目前Internet上流行的网站构架方式是LAMP，其中的M即MySQL, 作为数据库，MySQL以免费、开源、使用方便为优势成为了很多Web开发的后端数据库存储引擎。MySQL驱动Go中支持MySQL的驱动目前比较多，有如下几种，有些是支持database/sql标准，而有些是采用了自己的实现接口,常用的有如下几种: 
 
  http://code.google.c...o-mysql-dri
    
                                
    • 
                                
  • git命令
                                    shuizhaosi888
git
                                    
    ---------------设置全局用户名：
git config --global user.name "HanShuliang" //设置用户名 
git config --global user.email "[email protected]" //设置邮箱

---------------查看环境配置
git config --li
    
                                
    • 
                                
  • qemu-kvm 网络 nat模式 (四)
                                    haoningabc
kvmqemu
                                    
    qemu-ifup-NAT 
 

#!/bin/bash
BRIDGE=virbr0
NETWORK=192.168.122.0
GATEWAY=192.168.122.1
NETMASK=255.255.255.0
DHCPRANGE=192.168.122.2,192.168.122.254
TFTPROOT=
BOOTP=
function check_bridge()

    
                                
    • 
                                
  • 不要让未来的你，讨厌现在的自己
                                    jingjing0907
生活 奋斗 工作 梦想
                                    
     故事one 
　23岁，他大学毕业，放弃了父母安排的稳定工作，独闯京城，在家小公司混个小职位，工作还算顺手，月薪三千，混了混，混走了一年的光阴。　　　　24岁，有了女朋友，从二环12人的集体宿舍搬到香山民居，一间平房，二人世界，爱爱爱。偶然约三朋四友，打扑克搓麻将，日子快乐似神仙；　　　　25岁，出了几次差，调了两次岗，薪水涨了不过百，生猛狂飙的物价让现实血淋淋，无力为心爱银儿购件大牌
    
                                
    • 
                                
  • 枚举类型详解
                                    一路欢笑一路走
enum枚举详解enumsetenumMap
                                    
    枚举类型详解 
一.Enum详解 
     1.1枚举类型的介绍 
  
JDK1.5加入了一个全新的类型的”类”—枚举类型，为此JDK1.5引入了一个新的关键字enum,我们可以这样定义一个枚举类型。 
  
   Demo:一个最简单的枚举类 
  
public enum ColorType {
   RED
    
                                
    • 
                                
  • 第11章 动画效果（上）
                                    onestopweb
动画
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • Eclipse中jsp、js文件编辑时，卡死现象解决汇总
                                    ljf_home
eclipsejsp卡死js卡死
                                    
    使用Eclipse编辑jsp、js文件时，经常出现卡死现象，在网上百度了N次，经过N次优化调整后，卡死现象逐步好转，具体那个方法起到作用，不太好讲。将所有用过的方法罗列如下： 
  
1、取消验证 
windows–>perferences–>validation 
把 除了manual 下面的全部点掉，build下只留 classpath dependency Valida
    
                                
    • 
                                
  • MySQL编程中的6个重要的实用技巧
                                    tomcat_oracle
mysql
                                    
    每一行命令都是用分号(;)作为结束 
对于MySQL，第一件你必须牢记的是它的每一行命令都是用分号(;)作为结束的，但当一行MySQL被插入在PHP代码中时，最好把后面的分号省略掉，例如： 
mysql_query("INSERT INTO tablename(first_name,last_name)VALUES('$first_name',$last_name')"); 

    
                                
    • 
                                
  • zoj 3820 Building Fire Stations(二分+bfs)
                                    阿尔萨斯
Build
                                    
     题目链接：zoj 3820 Building Fire Stations 
 题目大意：给定一棵树，选取两个建立加油站，问说所有点距离加油站距离的最大值的最小值是多少，并且任意输出一种建立加油站的方式。 
 解题思路：二分距离判断，判断函数的复杂度是o(n)，这样的复杂度应该是o(nlogn)，即使常数系数偏大，但是居然跑了4.5s，也是醉了。 判断函数里面做了3次bfs，但是每次bfs节点最多
    
                                
    •