Apache nifi NiFi处理器任务计数非常高，原因是什么？

我编写了一个基本的自定义处理器，它将流发送到“重试”关系并调用惩罚

package nlsn.processors.core.main;

import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.apache.nifi.annotation.behavior.ReadsAttribute;
import org.apache.nifi.annotation.behavior.ReadsAttributes;
import org.apache.nifi.annotation.behavior.WritesAttribute;
import org.apache.nifi.annotation.behavior.WritesAttributes;
import org.apache.nifi.annotation.documentation.CapabilityDescription;
import org.apache.nifi.annotation.documentation.SeeAlso;
import org.apache.nifi.annotation.documentation.Tags;
import org.apache.nifi.annotation.lifecycle.OnScheduled;
import org.apache.nifi.components.PropertyDescriptor;
import org.apache.nifi.flowfile.FlowFile;
import org.apache.nifi.logging.ComponentLog;
import org.apache.nifi.processor.AbstractProcessor;
import org.apache.nifi.processor.ProcessContext;
import org.apache.nifi.processor.ProcessSession;
import org.apache.nifi.processor.ProcessorInitializationContext;
import org.apache.nifi.processor.Relationship;
import org.apache.nifi.processor.exception.ProcessException;

@Tags({ "wait", "wait on time"})
@CapabilityDescription("Wait on time")
@SeeAlso({})
@ReadsAttributes({ @ReadsAttribute(attribute = "", description = "") })
@WritesAttributes({ @WritesAttribute(attribute = "", description = "") })
public class CustomWait extends AbstractProcessor {

    public static final Relationship SUCCESS_RELATIONSHIP = new Relationship.Builder()
            .name("SUCCESS").description("well done, carry on").build();

    public static final Relationship FAILURE_RELATIONSHIP = new Relationship.Builder()
            .name("FAILURE.").description("fail").build();

    public static final Relationship POINT_TO_SELF_RELATIONSHIP = new Relationship.Builder()
            .name("RETRY").description("point it back to processor").build();

    private List<PropertyDescriptor> descriptors;

    private Set<Relationship> relationships;


    @Override
    protected void init(final ProcessorInitializationContext context) {

        final Set<Relationship> relationships = new HashSet<Relationship>();
        relationships.add(SUCCESS_RELATIONSHIP);
        relationships.add(FAILURE_RELATIONSHIP);
        relationships.add(POINT_TO_SELF_RELATIONSHIP);
        this.relationships = Collections.unmodifiableSet(relationships);
    }

    @Override
    public Set<Relationship> getRelationships() {
        return this.relationships;
    }

    @Override
    public final List<PropertyDescriptor> getSupportedPropertyDescriptors() {
        return descriptors;
    }

    @OnScheduled
    public void onScheduled(final ProcessContext context) {

    }

    @Override
    public void onTrigger(final ProcessContext context, final ProcessSession session) throws ProcessException {
        final ComponentLog logger = getLogger();
        FlowFile flowFile = session.get();
        if (flowFile != null) {
            logger.info("flow file is not null.");
            String state = flowFile.getAttribute("_wait_state");
            if (state == null || state.isEmpty()) {
                logger.info("\"_wait_state\" attribute is missing, going into WAIT.");
                flowFile = session.putAttribute( flowFile, "_wait_state", "1");
                flowFile = session.penalize(flowFile);
                session.transfer( flowFile, POINT_TO_SELF_RELATIONSHIP );
            } else {
                logger.info("\"_wait_state\" attribute is available, breaking WAIT.");
                flowFile = session.removeAttribute( flowFile, "_wait_state" );
                session.transfer( flowFile, SUCCESS_RELATIONSHIP); 
            }
        } else {
            //logger.info("flow file is null (bad)!!!.");
        }
    }
}

包nlsn.processors.core.main；
导入java.util.Collections；
导入java.util.HashSet；
导入java.util.List；
导入java.util.Set；
导入org.apache.nifi.annotation.behavior.ReadsAttribute；
导入org.apache.nifi.annotation.behavior.ReadsAttributes；
导入org.apache.nifi.annotation.behavior.WriteAttribute；
导入org.apache.nifi.annotation.behavior.WriteAttribute；
导入org.apache.nifi.annotation.documentation.CapabilityDescription；
导入org.apache.nifi.annotation.documentation.see；
导入org.apache.nifi.annotation.documentation.Tags；
导入org.apache.nifi.annotation.lifecycle.OnScheduled；
导入org.apache.nifi.components.PropertyDescriptor；
导入org.apache.nifi.flowfile.flowfile；
导入org.apache.nifi.logging.ComponentLog；
导入org.apache.nifi.processor.AbstractProcessor；
导入org.apache.nifi.processor.ProcessContext；
导入org.apache.nifi.processor.ProcessSession；
导入org.apache.nifi.processor.ProcessorInitializationContext；
导入org.apache.nifi.processor.Relationship；
导入org.apache.nifi.processor.exception.ProcessException；
@标记（{“等待”、“等待时间”}）
@能力描述（“等待时间”）
@另见（{}）
@ReadsAttributes（{@ReadsAttribute（attribute=，description=）}）
@WriteAttribute（{@WriteAttribute（attribute=“”，description=“”）}）
公共类CustomWait扩展了抽象处理器{
public static final Relationship SUCCESS\u Relationship=newrelationship.Builder（）
.name（“成功”）.description（“干得好，继续进行”）.build（）；
公共静态最终关系失败\u Relationship=newrelationship.Builder（）
.name（“失败”）.description（“失败”）.build（）；
public static final Relationship POINT_TO_SELF_Relationship=newrelationship.Builder（）
.name（“重试”）.description（“将其指向处理器”）.build（）；
私有列表描述符；
私人关系；
@凌驾
受保护的void init（最终ProcessorInitializationContext上下文）{
最终集关系=新HashSet（）；
添加（成功关系）；
添加（失败关系）；
关系。添加（点对点关系）；
this.relationships=Collections.unmodifiableSet（关系）；
}
@凌驾
公共集getRelationships（）{
返回此项。关系；
}
@凌驾
公共最终列表getSupportedPropertyDescriptors（）{
返回描述符；
}
@如期
已调度的公共void（最终ProcessContext上下文）{
}
@凌驾
public void OnTigger（最终ProcessContext上下文，最终ProcessSession会话）引发ProcessException{
最终组件日志记录器=getLogger（）；
FlowFile FlowFile=session.get（）；
if（flowFile！=null）{
info（“流文件不为null”）；
字符串状态=flowFile.getAttribute（“\u wait\u state”）；
if（state==null | | state.isEmpty（））{
logger.info（“\”\u wait\u state\”属性丢失，正在等待中。“）；
flowFile=session.puttribute（flowFile，“\u wait\u state”，“1”）；
flowFile=会话。惩罚（flowFile）；
会话传输（流文件、点对点自相关）；
}否则{
info（“\”\u wait\u state\”属性可用，正在中断等待。”）；
flowFile=session.removeAttribute（flowFile，“\u wait\u state”）；
会话传输（流文件、成功关系）；
}
}否则{
//info（“流文件为空（错误）！！！”）；
}
}
}

代码正在按预期工作。但我想知道为什么任务数（192569）这么高。正如预期的那样，过程在30秒内完成

（请参阅CustomWait处理器任务计数）

nifi在后台运行什么

这个大计数实际上占用了CPU吗

如果这是坏的，如何修复它

谢谢

当队列中有流文件（FF）向进程提供信息时，NiFi控制器会安排处理器运行，而不检查FFs的惩罚状态。在处理器的onTrigger中，它将尝试从输入队列中获取FFs（

session.get（）

）。这个

session.get（）

不会得到任何惩罚的FFs，因此它最终将返回null。这就是为什么需要检查空FF，而且还不错。我假设您没有更改运行计划，这意味着控制器将尝试以尽可能快的速度运行该处理器。这导致任务计数膨胀

它正在尝试检查要处理的输入，因此正在使用CPU。这是否会占用内存取决于可用任务的数量和系统上运行的处理器

本质上不坏，但可以通过设置运行计划来减少！=0

---

在“处理器计划”选项卡中设置的惩罚持续时间是多少？默认为30秒。我没有更改它。好的，那么另一个想法，你的处理器类上有@TriggerWhenEmpty注释吗？添加了完整的代码，没有使用@TriggerWhenEmpty注释。谢谢。对于这个简单的处理器，将更改运行计划=（惩罚持续时间/2）。只是为了减少CPU的负载。想知道thr是否是OnTigger函数的注释，如果thr没有非惩罚FF，它可以停止函数调用本身。您可以使用{context.yield（）}手动“暂停”控制器调度处理器（将其视为惩罚整个处理器）。通常，当处理器遇到异常时会使用此选项，该异常将通过处理其他FFs（如远程服务关闭）而持续存在。您可以在{FF==null}的主体中使用它，但如果您使用多个任务和快速运行持续时间运行处理器，则可能会意外地碰到它。谢谢您的提示