问题[scala](coding)

我试图将一个附加Seq[String]到现有的空Seq[String]

var enrichmentColumnsList: Seq[String] = Seq.empty
datasetEnricherConf.map(u => u.columnMappingsConf).foreach {
  columnMappingConf =>
    for (i <- 0 to columnMappingConf.size) {
      var cond = columnMappingConf.map(_.destColumnName)
      println(s"cond:$cond")
      enrichmentColumnsList= cond
    }
}


println(s"enrichmentColumnsList:$enrichmentColumnsList")

cond:List(NODE)
cond:List(NODE)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
cond:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)
enrichmentColumnsList:List(NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)

它使用列表中的最后一次出现来初始化它。

我期望的是下面这样的情况：

enrichmentColumnsList:List(NODE,NODE_temp, NETWORK, SITETYPE, STATEORPROVINCE, DISTRICT, CLUSTER, REGION)

我从 telegram/bot4s 存储库复制了代码，将部分代码放入“object Main extends App”，创建 sbt 文件，安装库。

import cats.instances.future._
import cats.syntax.functor._
import com.bot4s.telegram.api.RequestHandler
import com.bot4s.telegram.api.declarative.Commands
import com.bot4s.telegram.clients.{FutureSttpClient, ScalajHttpClient}
import com.bot4s.telegram.future.{Polling, TelegramBot}
import com.bot4s.telegram.methods.SendDice

import scala.util.Try
import scala.concurrent.Future

/** Generates random values.
 */


class RandomBot(val token: String) extends TelegramBot
  with Polling
  with Commands[Future] {

  //LoggerConfig.factory = PrintLoggerFactory()
  // set log level, e.g. to TRACE
  //LoggerConfig.level = LogLevel.TRACE

  // Use sttp-based backend
  implicit val backend = SttpBackends.default
  override val client: RequestHandler[Future] = new FutureSttpClient(token)

  // Or just the scalaj-http backend
  // override val client: RequestHandler[Future] = new ScalajHttpClient(token)

  val rng = new scala.util.Random(System.currentTimeMillis())
  onCommand("coin" or "flip") { implicit msg =>
    reply(if (rng.nextBoolean()) "Head!" else "Tail!").void
  }
  onCommand("real" | "double" | "float") { implicit msg =>
    reply(rng.nextDouble().toString).void
  }
  onCommand("/die" | "roll") { implicit msg =>
    reply("⚀⚁⚂⚃⚄⚅" (rng.nextInt(6)).toString).void
  }
  onCommand("random" or "rnd") { implicit msg =>
    withArgs {
      case Seq(Int(n)) if n > 0 =>
        reply(rng.nextInt(n).toString).void
      case _ => reply("Invalid argumentヽ(ಠ_ಠ)ノ").void
    }
  }
  onCommand("choose" | "pick" | "select") { implicit msg =>
    withArgs { args =>
      replyMd(if (args.isEmpty) "No arguments provided." else args(rng.nextInt(args.size))).void
    }
  }

  onCommand("auto") { implicit msg =>
    request(SendDice(msg.chat.id)).void
  }
  // Extractor
  object Int {
    def unapply(s: String): Option[Int] = Try(s.toInt).toOption
  }
}


object Main extends App {
  val bot = new RandomBot("tokenhere")
  val eol = bot.run()
  println("Press [ENTER] to shutdown the bot, it may take a few seconds...")
  scala.io.StdIn.readLine()
  bot.shutdown() // initiate shutdown
  // Wait for the bot end-of-life
  Await.result(eol, Duration.Inf)
}

ThisBuild / version := "0.1.0-SNAPSHOT"

ThisBuild / scalaVersion := "2.13.16"

lazy val root = (project in file("."))
  .settings(
    name := "Meower"
  )

// Core with minimal dependencies, enough to spawn your first bot.
libraryDependencies += "com.bot4s" %% "telegram-core" % "5.8.4"

// Extra goodies: Webhooks, support for games, bindings for actors.
libraryDependencies += "com.bot4s" %% "telegram-akka" % "5.8.4"

但此后我构建失败：

C:\Users\днс\Music\play-samples-3.0.x\Meower\src\main\scala\Main.scala:25:26 未找到：值 SttpBackends 隐式 val backend = SttpBackends.default

C:\Users\днс\Music\play-samples-3.0.x\Meower\src\main\scala\Main.scala:26:49 找不到参数后端的隐式值：sttp.client3.SttpBackend[scala.concurrent.Future,Any] 涉及默认参数的应用程序中发生错误。override val client：RequestHandler[Future] = new FutureSttpClient(token)

C:\Users\днс\Music\play-samples-3.0.x\Meower\src\main\scala\Main.scala:71:3 未找到：值 Await Await.result(eol，Duration.Inf)

C:\Users\днс\Music\play-samples-3.0.x\Meower\src\main\scala\Main.scala:71:21 未找到：值 Duration Await.result(eol，Duration.Inf)

我需要做什么来解决这些问题？

我研究了“找不到 SttpBackends + “涉及默认参数的应用程序中发生错误。”” 并试图修复我的代码，但没有成功……

背景：

我有一个名为 的 Actor Peer。在我的应用程序中，Peer表示创建它的服务器与另一台服务器之间的连接。它本质上是一个http-client。

首次运行实例时，它PeerManager会查询数据库以获取服务器条目列表。然后，它会Peer为该服务器创建一个参与者。状态Peer取决于其RegistrationStatus字段（PENDING_OUT、PENDING_IN、REGISTERED，...）

APeer有一个默认的接收函数，如下所示：

  override def receive: Receive = {
    case FirstTick =>
      system.log.info("receive FirstTick")
      timers.startTimerWithFixedDelay(TickKey, Tick, FiniteDuration(2, TimeUnit.SECONDS))
    case Tick =>
      system.log.info("receive Tick")
      // process every state until all are complete
      var statesLeft = false
      
      states = states.sortWith{ (s1, s2) => s1.order > s2.order }

      for (state <- states) {
        if (!state.complete) {
          statesLeft = true
          if (state.waitForPing) {
            context.become(pingService(state))
          } else {
            context.become(state.behavior)
          }
        }
      }

      if (!statesLeft) context.become(pingService(null))
  }

这基本上允许Peer通过状态列表进行转换，执行每个状态的行为直到状态完成。

一组状态可能看起来像这样：

    case PENDING_OUT =>
        Seq(
          new InitState(0, peer),
          new SessionHandshake(1, peer),
          new WaitMessages(2, peer)
        )

其中一个状态的示例：

class WaitAccept(order: Int, peer: Peer)(implicit system: ActorSystem) extends PeerState(order, false, true) {

  override def behavior: Receive = {
    case Tick =>
      system.log.info("Waiting for accept")
      if (complete) peer.getContext.unbecome()

    case rA@RegistrationAccept(serverID, serverIP, _) =>
      system.log.info(s"Processing RegistrationAccept: ${rA.toProtoString}")
      complete = true
  }
  
}

PeerState超类（superclass）：

abstract case class PeerState(var order: Int, var complete: Boolean, var waitForPing: Boolean) {

  def behavior: Receive // <- must be overridden
  
}

此状态使对等方坐等“RegistrationAccept”消息，该消息在用户单击网页上的“接受”时生成。

问题：

某些州（例如，Handshake负责交换加密密钥的州）会向为其生成 的 发送消息http。如果接收消息的实例发现 具有所请求的，则会将该消息转发给 ，如下所示：serverPeerPeerserverIDPeerManagerPeerask

case peerRequest@PeerRequest(serverID, SessionRequest(sessionRequest), _) =>
      // get the relevant peer for the requested serverID
      val peerEntry = peerMap.get(serverID)
      if (peerEntry.isDefined) {
        // ask the peer Actor for a response to the sessionRequest, block and wait for this response, then send it back to the peerManager

        val peerState = queryPeerState(peerEntry.get)    // <-- the issue

        if (peerState.isInstanceOf[SessionHandshake]) {  // <-- the issue
          try {
            sender() ! Await.result((peerEntry.get ? (self, sessionRequest)).mapTo[PeerResponse.Response], timeout.duration)
          } catch {
            case e: TimeoutException =>
              sender() ! PeerResponse.Response.StatusResponse(HydraStatusCodes.PEER_MANAGER_TIMEOUT.getStatusResponse)
          }
        } else {
          sender() ! PeerResponse.Response.StatusResponse(HydraStatusCodes.PEER_NOT_READY.getStatusResponse)
        }
      } else {
        sender() ! PeerResponse.Response.StatusResponse(HydraStatusCodes.PEER_NOT_READY.getStatusResponse)
      }

当其他实例Peer处于接收消息的不正确状态时，就会出现问题。如果发生这种情况，我希望用适当的 做出响应HydraStatusCode。对我来说，最正常的方法是在转发消息之前以某种方式询问Peer它处于什么状态，如果处于错误状态，则返回适当的 StatusCode。

但是，为了实现这一点，我必须QueryState在有Receive行为的每个地方实现案例。这看起来笨重而混乱，作为一名熟练的工程师，我觉得这不是正确的做法。

我希望以某种方式将其实现到PeerState类中作为始终被调用的默认行为QueryState，或者以某种方式允许直接PeerManager调用对Peer对象的引用而不是对 ActorRef 的引用（但我知道这是不可能的）

还有其他方法可以解决这个问题吗？或者混乱的方法可能是最好的？

我想将案例类 UserDTO 转换为案例类 User 我在无形案例类转换中找到了解决方案

class SameFieldConverter[T] {
def apply[S, SR <: HList, TR <: HList, MR <: HList, IR <: HList](s: S)(implicit
  genS: LabelledGeneric.Aux[S, SR],
  genT: LabelledGeneric.Aux[T, TR],
  merger: Merger.Aux[SR, HNil, MR],
  intersection: Intersection.Aux[MR, TR, IR],
  align: Align[IR, TR]) = genT.from(intersection(merger(genS.to(s), HNil)))

但是我对不同的字段有问题，例如在 UserDTO 中我有字段名称、姓氏，但在 User 中我有全名。

  case class UserDTO(name:String, surname:String, age:Int){
    def toDomain:User = User(name + surname, age)
  }
  case class User(fullName:String, age:Int)

另外，我对不同的字段名称也有问题，例如姓名 -> 姓氏

case class UserDTO(name:String, surname:String, age:Int)
case class User(firstName:String, surname:String, age:Int)

我想到的解决方案就像在羽毛笔别名（“name”，_.surname）中一样，但我的脑子很小。我还考虑过研究使用 scala 反射 API

问题：

在过去一周左右的时间里，我一直在反复尝试配置我的 Scala+AKKA 客户端，以便能够向运行 NGINX 的服务器发送消息。

我不断收到错误： javax.net.ssl.SSLHandshakeException: (certificate_unknown)

设置：

nginx配置：

server {
    listen 443 ssl default_server;
    listen [::]:443 ssl default_server;
    server_name localhost;

    ssl_certificate /home/hydra/.localhost-ssl/localhost.crt;           //<- combined certificates (server_cert + rootCA)
    ssl_certificate_key /home/hydra/.localhost-ssl/localhost-key.key;

    ssl_trusted_certificate /home/hydra/.localhost-ssl/rootCA.crt;      //<- just the rootCA

    index index.html index.htm;
    root /home/hydra/ui/;

    location / {
        try_files $uri.html $uri/index.html
        @public
        @nextjs;
        add_header Cache-Control "public, max-age=3600";
    }

    location @public {
        add_header Cache-Control "public, max-age=3600";
    }

    location /ping {
        proxy_pass http://localhost:8080;
    }

    location @nextjs {
            proxy_pass http://localhost:3000;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection 'upgrade';
            proxy_set_header Host $host;
            proxy_cache_bypass $http_upgrade;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-Proto https;
            proxy_set_header X-Forwarded-For $remote_addr;
            proxy_set_header X-Forwarded-Host $remote_addr;
    }
}

客户要求：

  private val sslContext: SSLContext = SSLManager.getClientSSLContext
  private val connectionContext = ConnectionContext.httpsClient(sslContext)

...

    val request = HttpRequest(method = HttpMethods.GET, uri = s"https://${server.serverIP}/ping")
    http.singleRequest(request, connectionContext).pipeTo(self)

createClientContext：

  def getClientSSLContext: SSLContext = {
    val keyStore = KeyStore.getInstance("JKS")
    keyStore.load(null, null) // Create an empty keystore
    keyStore.setCertificateEntry("rootCA", loadRootCertificate())

    // Set up a TrustManager that trusts the root CA certificate
    val trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm)
    trustManagerFactory.init(keyStore)
    val trustManagers = trustManagerFactory.getTrustManagers

    // Create an SSLContext with the custom TrustManager
    val sslContext = SSLContext.getInstance("TLS")
    sslContext.init(null, trustManagers, new SecureRandom())
    sslContext
  }

写入rootCA文件：

    val rootCA = new StringBuilder()
    rootCA.append("-----BEGIN CERTIFICATE-----\n")
    rootCA.append(Base64.getEncoder.encodeToString(rootCACertificate.getEncoded))
    rootCA.append("\n-----END CERTIFICATE-----")
    writeFile(ROOT_CA_PATH, Seq(rootCA.toString))

如何创建签名的服务器证书：

def createCSR(keyPair: KeyPair, subject: String, keyAlgorithm: String): PKCS10CertificationRequest = {
    val csrGen = new PKCS10CertificationRequestBuilder(new X500Name(subject), SubjectPublicKeyInfo.getInstance(keyPair.getPublic.getEncoded))
    val signer = new JcaContentSignerBuilder("SHA256with" + keyAlgorithm).build(keyPair.getPrivate)
    csrGen.build(signer)
  }

  // Sign the CSR with the root CA's private key to generate a certificate
  def signCertificate(csr: PKCS10CertificationRequest, rootCACertificate: X509Certificate, rootCAPrivateKey: PrivateKey): X509Certificate = {
    val notBefore = new Date()
    val notAfter = new Date(notBefore.getTime + 36500L * 24 * 60 * 60 * 1000) // Valid for 1 year

    val certGen = new X509v3CertificateBuilder(
      new X500Name("CN=Hydra SSL Certificate"),
      new BigInteger(128, new Random()),
      notBefore,
      notAfter,
      csr.getSubject,
      csr.getSubjectPublicKeyInfo
    )

    // Add SubjectAlternativeName (SAN) extension
    val sanNames = Array[GeneralName](
      new GeneralName(GeneralName.iPAddress, SERVER_IP)
    )

    val generalNames = new GeneralNames(sanNames)
    certGen.addExtension(Extension.subjectAlternativeName, false, generalNames)

    // Sign with root CA's private key
    val signer = new JcaContentSignerBuilder("SHA256withRSA").build(rootCAPrivateKey)
    val certificateHolder: X509CertificateHolder = certGen.build(signer)

    // Convert to a JCE certificate
    val converter = new JcaX509CertificateConverter().setProvider("BC")
    converter.getCertificate(certificateHolder)
  }

...

    // Step 1: Load Root CA certificate and private key
    val rootCACertificate = loadRootCertificate()
    val rootCAPrivateKey = loadRootPrivateKey()

    // Step 2: Generate new key pair for SSL certificate
    val keyPair = generateKey("RSA")

    // Step 3: Create CSR (Certificate Signing Request)
    val csr = createCSR(keyPair, s"CN=hydra_server_$SERVER_ID, O=Hydra, C=UK", "RSA")

    // Step 4: Sign the CSR with the Root CA to generate the SSL certificate
    val sslCertificate = signCertificate(csr, rootCACertificate, rootCAPrivateKey)

我尝试过的：

咨询后chatGPT，我尝试了该命令openssl s_client -connect 192.168.0.4:443 -showcerts

该命令的输出可以在这里找到。

这帮助我验证是否nginx确实按正确的顺序发送了整个链（可以通过日期确认 - rootCA（输出中的证书 1）是在 2025 年 7 月 2 日生成的，服务器证书（证书 0）是在今天生成的。

那么我的设置中哪里做错了/遗漏了什么？

我有以下由第三方发布的 CSV 文件，其中特定列的值包含逗号（出于某些无法解释的原因）。该列的值要么不存在，要么括在方括号/双引号内，因为它表示一个范围。

以下是 CSV 中的一条记录：

A,B
xxxxxxxxx,"['05-01', '06-30']"
yyyyyyyyy,"['04-01', '04-30']"
zzzzzzzzz,

罪魁祸首显然是第二列。有没有办法在 Apache Spark（Scala）中正确解析此 CSV，以便获得以下数据框：

+---+----------+------------------------+
|A             |B                       |
+---+-----------------------------------+
|xxxxxxxxx     |"['05-01', '06-30']"    |
|yyyyyyyyy     |"['04-01', '04-30']"    |
|zzzzzzzzz     |null                    |
+---+----------+------------------------+

我有一个类，它本身就是一个演员：

class Client(server: Server, systemActor: ActorRef) extends Actor {
...
}

我有一个管理已连接客户端的列表。生成客户端 Actor 的 Actor 监视数据库中的“服务器”列表，并为每个服务器生成一个客户端连接，如下所示：

private val clientList = mutable.ArrayBuffer.empty[Client]

class RegistrationWatcherActor(val systemActor: ActorSystem) extends Actor with Timers {

  implicit val system: ActorSystem = context.system

  timers.startSingleTimer(TickKey, FirstTick, FiniteDuration(1, TimeUnit.SECONDS)) // wait 10 seconds to give database time to initiate

  private def checkRegistrations(): Unit = {
    val database = DatabaseUtil.getInstance
    val serversOutgoing: Seq[Server] = database.getAll[Server](classOf[Server])

    for (server <- serversOutgoing) {
      val client = clientList.find{ client => client.server == server }
      if (client.isEmpty) { // client for this server was not found, so create one
        
      }
    }
  }

  def receive: Receive = {
    case FirstTick =>
      timers.startTimerWithFixedDelay(TickKey, Tick, FiniteDuration(1, TimeUnit.SECONDS))
    case Tick =>
      checkRegistrations()
  }
}

问题

在检查中，if (client.isEmpty)我想创建一个实例Client，将其作为参与者生成，并将引用放入列表中，这样它就不会再次被创建。如您所见，我确定客户端是否已创建的方法是将其serverID与数据库中存储的客户端进行检查。

理想情况下，我想这样做：

val client = new Client(server, systemActor)
systemActor.actorOf(Props(client), server.serverID)
clientList.append(client)

请问有什么建议吗？

选择

我意识到我可以列出clientList并将String存储serverID在这里。但是，我最终希望RegistrationWatcher能够控制客户端的各个方面，因此Client最好引用该对象。

我正在使用scala-test-containers、munit和munit-cats-effect以及Mill和 Scala 3 编写针对 postgres的skunk代码集成测试。我是Cats Effect的新手。

我正在努力实现的设置是：

• 测试套件启动 postgres 容器并为整个套件创建一次 skunk 会话（并在套件完成时停止容器）。
• 每个测试都在其自己的 skunk 数据库事务中进行回滚，以保持测试隔离。

下面是目前为止的代码，除了对 的调用rollback（需要隐式 ）之外，编译器都可以接受skunk.util.Origin。我在 skunk 文档中没有看到对这种类型的任何引用，我不明白如何将其纳入范围。

我怎样才能让这段代码中的调用rollback进行编译？缺少的隐式 Origin 在哪里？

import cats.effect.IO
import munit.CatsEffectSuite
import org.testcontainers.utility.DockerImageName
import cats.effect.kernel.Resource
import skunk.*
import skunk.implicits.*
import natchez.Trace.Implicits.noop
import munit.catseffect.IOFixture
import cats.implicits.catsSyntaxFlatMapOps

val container: Resource[IO, PostgreSQLContainer] =
  Resource.make
    (for {
      c <- IO(PostgreSQLContainer(
        DockerImageName.parse("postgres:17-alpine")
      ))
      _ <- IO.blocking(c.start())
    } yield c)
    (c => IO.blocking(c.stop()))

val sessionResource: Resource[IO, Session[IO]] =
  container.flatMap { c =>
    Session.single[IO](
      host = "localhost",
      port = 5432,
      user = c.username,
      password = Some(c.password),
      database = c.databaseName
    )
  }

def useWithRollback[T](s: Session[IO])(f: Transaction[IO] => IO[T]) =
  s.transaction.use { xa =>
    for {
      result <- f(xa)
      _ <- xa.rollback()  // fails compilation: needs implicit skunk.util.Origin
    } yield result
  }

class PgIntegrationTests extends CatsEffectSuite:

  val session = ResourceSuiteLocalFixture(
    "skunk session",
    sessionResource
  )

  override def munitFixtures = List(session)

  def withDb[T](f: Transaction[IO] => IO[T]) =
    useWithRollback(session())(f)

这个想法是，测试看起来像

  test("something") {
    withDb { xa =>
      for {
        result <- callMyCode(xa)
        _ <- assertIO(result, <expected result>)
      } yield ()
    }
  }

以上内容编译失败useWithRollback，

[error] 41 |      _ <- xa.rollback()
[error]    |           ^^^^^^^^^^^
[error]    |           None of the overloaded alternatives of method rollback in trait Transaction with types
[error]    |            (implicit o: skunk.util.Origin): cats.effect.IO[skunk.data.Completion]
[error]    |            (savepoint: xa.Savepoint)(implicit o: skunk.util.Origin): cats.effect.IO[skunk.data.Completion]
[error]    |           match arguments ()

据我所知，它正在寻找一个Origin范围内的。我怎样才能将其纳入范围？为什么 skunk Transaction 页面（上面链接）在其示例中Origin调用时没有这个问题？rollback

感谢您的时间。

PS：Mill 构建文件build.sc：

import mill._, scalalib._

object devmap extends ScalaModule {
  def scalaVersion = "3.5.1"
  def ivyDeps = Agg(
    ivy"org.tpolecat::skunk-core:0.6.4",
    ivy"org.typelevel::cats-effect:3.5.7"
  )

  object test extends ScalaTests with TestModule.Munit {
    def ivyDeps = Agg(
      ivy"org.scalameta::munit::0.7.29",
      ivy"org.typelevel::munit-cats-effect:2.0.0",
      ivy"com.dimafeng::testcontainers-scala-postgresql:0.41.5",
      ivy"org.postgresql:postgresql:42.7.4",
      ivy"com.lihaoyi::pprint:0.9.0"
    )
  }
}

好的，我一直在尝试从教科书中学习 Scala，但是它是在 Scala 3 发布之前编写的，因此很多示例代码无法编译。

本书是这样介绍命令行参数的：

println(args(0).toDouble+args(1).toDouble)

我尽最大努力将其转换为与 Scala 3 兼容的内容：

@main def main(args: Array[String]) = {  
  println(args(0).toDouble+args(1).toDouble)
}

以下是编译器告诉我的内容：

[error] ./add.scala:1:1
[error] No given instance of type scala.util.CommandLineParser.FromString[Array[String]] was found for parameter fs of method parseArgument in object CommandLineParser
[error] @main def main(args: Array[String]) = {
[error] ^

我该如何解决这个问题？已经发布了另一个类似的问题，但答案似乎都是在 Scala 的早期版本中写的。至于官方发布指南，它建议使用与 CLP 相关的东西，我不明白。

假设我有一个定义如下的未来

val fut = Future {
  println("Doing some work")
  Thread.sleep(5000)
  println("Work done")
}

我稍后会访问这个未来，但希望它在启动时执行，而不是在我引用 fut 时执行

我在某处读到过，可以通过执行以下操作立即执行：

scala.concurrent.ExecutionContext.Implicits.global.execute(fut)

但是这不会编译，因为执行仅需要一个 Runnable。有没有办法可以在另一个线程中立即执行这个未来？