小编Jat*_*tin的帖子

我是一个新手scala程序员,并遇到了一个奇怪的行为.

def balanceMain(elem: List[Char]): Boolean =
  {
    if (elem.isEmpty)
      if (count == 0)
        true;
      else false;

    if (elem.head == '(')
      balanceMain(elem.tail, open, count + 1);....

以上我基本上想要返回true,如果elem.isEmpty和count == 0.否则,我想返回false.

现在我已经读过,不需要在scala中添加return语句.所以我return上面省略了.但它不返回布尔值.如果我添加一个return语句return true.它完美地运作.为什么会这样？

另外,为什么在scala中使用return语句被认为是一种不好的做法

我想转换List<CompletableFuture<X>>成CompletableFuture<List<T>>.这非常有用,因为当您有许多异步任务并且需要获得所有异步任务的结果时.

如果其中任何一个失败,则最终的未来将失败.这就是我实施的方式:

  public static <T> CompletableFuture<List<T>> sequence2(List<CompletableFuture<T>> com, ExecutorService exec) {
        if(com.isEmpty()){
            throw new IllegalArgumentException();
        }
        Stream<? extends CompletableFuture<T>> stream = com.stream();
        CompletableFuture<List<T>> init = CompletableFuture.completedFuture(new ArrayList<T>());
        return stream.reduce(init, (ls, fut) -> ls.thenComposeAsync(x -> fut.thenApplyAsync(y -> {
            x.add(y);
            return x;
        },exec),exec), (a, b) -> a.thenCombineAsync(b,(ls1,ls2)-> {
            ls1.addAll(ls2);
            return ls1;
        },exec));
    }

要运行它:

ExecutorService executorService = Executors.newCachedThreadPool();
        Stream<CompletableFuture<Integer>> que = IntStream.range(0,100000).boxed().map(x -> CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep((long) (Math.random() * 10));
            } catch (InterruptedException e) {
                e.printStackTrace(); …

存储字典所有单词的最佳数据结构是什么？我能想到的最好的就是使用a HashMap,它将映射到a HashTable.基本上,根据第一个字符,我们将得到关联HashTable,然后使用它,我们可以添加从该字符开始的单词.然后我们将根据字符串选择一个好的哈希函数.

有更好的方法吗？

是不是要列出一个将某些内容转换为List的方法？

如果是的话,为什么我不能用它括号？我必须在这里遗漏一些更基本的东西.

这是一个例子:

val l = Array(1,2,3).toList // works fine

val l = Array(1,2,3).toList() // gives the error below

方法适用的参数不足:(n:Int)特征LinearSeqOptimized中的Int.未指定的值参数n.

我想在我的tomcat容器中设置一个默认的http标头 -

Access-Control-Allow-Origin:*

来自stackoverslow和谷歌的各种不同链接,大多数指向资源.这再次说明如何做到这一点.我已经复制了相同的,但仍然没有显示标题.这就是我所做的:1)在tomcat的/ lib文件夹中复制cors.jar文件2)在web.xml中插入此文本

<filter>
    <filter-name>CORS</filter-name>
    <filter-class>com.thetransactioncompany.cors.CORSFilter</filter-class>
    <init-param>
     <param-name>cors.allowOrigin</param-name>
        <param-value>*</param-value>
    </init-param>
    <init-param>
     <param-name>cors.supportedMethods</param-name>
        <param-value>GET, POST, HEAD, PUT, DELETE</param-value>
    </init-param>
    <init-param>
     <param-name>cors.supportedHeaders</param-name>
        <param-value>Content-Type, Last-Modified</param-value>
    </init-param>
    <init-param>
        <param-name>cors.exposedHeaders</param-name>
        <param-value>Set-Cookie</param-value>
    </init-param>
    <init-param>
        <param-name>cors.supportsCredentials</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>

<filter-mapping>
    <filter-name>CORS</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

它不起作用,我很无奈.我的tomcat版本是-6.0.6.请帮忙.

我在Windows上工作,但我被困在Mac上.我有佳能SDK,并JNA在它上面构建了一个包装器.它适用于Windows,需要一些Mac帮助.在sdk中,有一个函数可以注册回调函数.基本上当相机发生事件时,它会调用回调函数.

在Windows上,注册后,我需要用来User32获取事件并通过以下方式调度事件:

private static final User32 lib = User32.INSTANCE;
boolean hasMessage = lib.PeekMessage( msg, null, 0, 0, 1 ); // peek and remove
if( hasMessage ){
    lib.TranslateMessage( msg ); 
    lib.DispatchMessage( msg ); //message gets dispatched and hence the callback function is called
}

在api中,我在Mac中找不到类似的类.我怎么去这个？

PS:unix 的JNA api很广泛,我无法弄清楚要寻找什么.该参考可能有助于

有什么区别 -

newSingleThreadExecutor vs newFixedThreadPool(20)

从操作系统和编程的角度来看.

每当我运行我的程序使用newSingleThreadExecutor我的程序工作得很好,端到端延迟(第95百分位)出现5ms.

但是一旦我开始运行我的程序 -

newFixedThreadPool(20)

我的程序性能下降,我开始看到端到端延迟37ms.

所以现在我试图从架构的角度来理解这里有多少线程意味着什么？以及如何确定我应该选择的最佳线程数？

如果我使用更多的线程,那会发生什么？

如果有人能用外行语言向我解释这些简单的事情那么这对我来说非常有用.谢谢您的帮助.

我的机器配置规范 - 我从Linux机器运行我的程序 -

processor       : 0
vendor_id       : GenuineIntel
cpu family      : 6
model           : 45
model name      : Intel(R) Xeon(R) CPU E5-2670 0 @ 2.60GHz
stepping        : 7
cpu MHz         : 2599.999
cache size      : 20480 KB
fpu             : yes
fpu_exception   : yes
cpuid level     : 13
wp              : yes
flags           : fpu vme de pse tsc msr …

我已经阅读了一些关于akka如何以及为何不保证邮件传递的帖子.该文档,这个讨论和小组其他讨论做解释它做好.

我对akka很新,并希望了解案例的合适设计.比如说我在不同的机器上有3个不同的演员.一个负责烹饪书,另一个负责历史,最后一个负责技术书籍.

我在另一台机器上有一个主演员.假设有一个主要参与者的查询来搜索我们是否有一本书可用.主actor向3个远程actor发送请求,并期望结果.所以我这样做:

  val scatter = system.actorOf(
        Props[SearchActor].withRouter(ScatterGatherFirstCompletedRouter(
              routees=someRoutees, within = 10 seconds)), "router")
  implicit val timeout = Timeout(10 seconds)
  val futureResult = scatter ?  Text("Concurrency in Practice")
  //      What should I do here?.
  //val result = Await.result(futureResult, timeout.duration) line(a)

简而言之,我已经向所有3个远程演员发送了请求,并期望在10秒内得到结果.

应该采取什么行动？

1. 假设我在10秒钟内没有得到结果,我是否应该再次向所有人发送新请求？
2. 如果within时间过早就过早怎么办？但我不知道预先花了多少时间.
3. 如果within时间充足但消息丢失了怎么办？

如果我没有及时得到回复within并再次重新发送请求.像这样的东西,它仍然是异步的:

futureResult onComplete{
  case Success(i) => println("Result "+i)
  case Failure(e) => //send again
}

但是在太多的问题下,通话中的线程太多而且体积庞大？如果我取消注释line(a),它将变为同步,并且在负载下可能会执行不良.

说我10秒内没有得到回复.如果within时间不成熟,那么它的重大无用计算再次发生.如果消息掉落,那么10浪费了宝贵的时间.如果说我知道消息已经发送,我可能会等待更长的时间而不会持怀疑态度.

人们如何解决这些问题？ACK …

在这里提供一些背景信息，我一直在关注项目织机一段时间。我看过织机的状态。我做过异步编程。

异步编程（由 java nio 提供）在任务等待时将线程返回到线程池，并且它竭尽全力不阻塞线程。这带来了很大的性能提升，我们现在可以处理更多的请求，因为它们不受操作系统线程数量的直接限制。但我们在这里失去的是上下文。同一个任务现在不仅仅与一个线程相关联。一旦我们将任务与线程分离，所有上下文都将丢失。异常跟踪不提供非常有用的信息并且调试很困难。

随之而来的项目织机virtual threads成为单一的并发单元。现在您可以在单个virtual thread.

直到现在一切都很好，但文章继续指出，项目织机：

一个简单的、同步的 Web 服务器将能够处理更多的请求，而无需更多的硬件。

我不明白我们如何通过异步 API 的项目机获得性能优势？在asynchrounous APIs确保不要保留任何线程空闲。那么，项目织机如何使其比asynchronousAPI更高效和高性能？

编辑

让我重新表述这个问题。假设我们有一个 http 服务器，它接收请求并使用支持的持久数据库执行一些 crud 操作。比如说，这个 http 服务器处理了很多请求 - 100K RPM。两种实现方式：

1. HTTP 服务器有一个专用的线程池。当一个请求进来时，一个线程将这个任务带上直到它到达数据库，其中任务必须等待来自数据库的响应。此时，线程返回线程池，继续执行其他任务。当 DB 响应时，它再次由线程池中的某个线程处理并返回 HTTP 响应。
2. HTTP 服务器只是virtual threads为每个请求生成。如果有IO，虚拟线程只是等待任务完成。然后返回 HTTP 响应。基本上，没有针对virtual threads.

鉴于硬件和吞吐量保持不变，在响应时间或处理更多吞吐量方面，任何一种解决方案会比另一种更好吗？

我的猜测是，与性能没有任何区别。

我有一个接收消息的actor,在文件系统中搜索文件并返回File的完整路径.

为了保持异步,我做了:

def receive = {
  case s:String => {

    val f = future{
      val ans = search(s)
      println("Input Request: "+s+" output:"+ans+" "+sender.path)
    }
    f.onComplete{
      case Success(x) => sender ! x
      case Failure(y) => println("Could not complete it")
    }
  } 
}

但我观察到它将消息返回给akka://FileSystem/deadLetters而不是sender.文档说:

仅在Actor本身内有效,所以不要关闭它并将其发布到其他线程!

这是什么意思,我必须保持同步？还有其他方法吗？