要实现并发运行每个FTP文件的Spring Integration流程，可以使用Spring Integration的并发处理器（concurrent）和executor-channel来实现。

下面是一个示例代码：

@Configuration
@EnableIntegration
public class FtpIntegrationConfig {

    @Value("${ftp.host}")
    private String ftpHost;

    @Value("${ftp.port}")
    private int ftpPort;

    @Value("${ftp.username}")
    private String ftpUsername;

    @Value("${ftp.password}")
    private String ftpPassword;

    @Value("${ftp.remote.directory}")
    private String ftpRemoteDirectory;

    @Autowired
    private FtpTaskExecutor ftpTaskExecutor;

    @Bean
    public SessionFactory ftpSessionFactory() {
        DefaultFtpSessionFactory ftpSessionFactory = new DefaultFtpSessionFactory();
        ftpSessionFactory.setHost(ftpHost);
        ftpSessionFactory.setPort(ftpPort);
        ftpSessionFactory.setUsername(ftpUsername);
        ftpSessionFactory.setPassword(ftpPassword);
        return new CachingSessionFactory<>(ftpSessionFactory);
    }

    @Bean
    public ConcurrentTaskExecutor concurrentTaskExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(5);
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setThreadNamePrefix("ftpTaskExecutor");
        return new ConcurrentTaskExecutor(threadPoolTaskExecutor);
    }

    @Bean
    public PollableChannel ftpInputChannel() {
        return new QueueChannel();
    }

    @Bean
    public MessageProducer ftpMessageProducer() {
        FtpInboundFileSynchronizingMessageSource source =
                new FtpInboundFileSynchronizingMessageSource(ftpInboundFileSynchronizer());
        source.setLocalDirectory(new File(System.getProperty("java.io.tmpdir")));
        source.setAutoCreateLocalDirectory(true);
        source.setLocalFilter(new AcceptOnceFileListFilter<>());
        source.setMaxFetchSize(1);
        return new SourcePollingChannelAdapter(source);
    }

    @Bean
    public FtpInboundFileSynchronizer ftpInboundFileSynchronizer() {
        FtpInboundFileSynchronizer fileSynchronizer = new FtpInboundFileSynchronizer(ftpSessionFactory());
        fileSynchronizer.setRemoteDirectory(ftpRemoteDirectory);
        fileSynchronizer.setDeleteRemoteFiles(true);
        fileSynchronizer.setFilter(new FtpSimplePatternFileListFilter("*.txt"));
        return fileSynchronizer;
    }

    @Bean
    public MessageHandler ftpMessageHandler() {
        return new MessageHandler() {
            @Override
            public void handleMessage(Message message) throws MessagingException {
                // 处理FTP文件的逻辑
                System.out.println("Handle FTP file: " + message.getPayload());
            }
        };
    }

    @Bean
    public IntegrationFlow ftpIntegrationFlow() {
        return IntegrationFlows.from(ftpMessageProducer(),
                c -> c.poller(Pollers.fixedDelay(500)))
                .channel(ftpInputChannel())
                .handle(ftpMessageHandler(), e -> e.advice(expressionAdvice()))
                .get();
    }

    @Bean
    public ExpressionEvaluatingRequestHandlerAdvice expressionAdvice() {
        ExpressionEvaluatingRequestHandlerAdvice advice = new ExpressionEvaluatingRequestHandlerAdvice();
        advice.setOnSuccessExpressionString("payload.delete()");
        advice.setSuccessChannelName("successChannel");
        advice.setTrapException(true);
        return advice;
    }

    @Bean
    public MessageChannel successChannel() {
        return new QueueChannel();
    }

    @Bean
    public IntegrationFlow successFlow() {
        return IntegrationFlows.from(successChannel())
                .handle(ftpSuccessHandler())
                .get();
    }

    @Bean
    public MessageHandler ftpSuccessHandler() {
        return new MessageHandler() {
            @Override
            public void handleMessage(Message message) throws MessagingException {
                System.out.println("FTP file processed successfully: " + message.getPayload());
            }
        };
    }

    @Bean
    public IntegrationFlow mainFlow() {
        return IntegrationFlows.from(ftpInputChannel())
                .channel(MessageChannels.executor(ftpTaskExecutor))
                .handle(ftpMessageHandler())
                .get();
    }

}

在以上代码中，我们首先配置了FTP的连接信息和会话工厂（ftpSessionFactory），并且使用了并发处理器（concurrentTaskExecutor）来实现并发处理每个FTP文件。

然后我们定义了一个FTPMessageProducer来监听FTP服务器上的文件变化，并使用FtpInboundFileSynchronizer来同步FTP文件到本地目录。接下来，我们定义了一个FTPMessageHandler来处理FTP文件，你可以在