标签: performance

使用CROSS APPLY的主要目的是什么？

我已经阅读(模糊地,通过互联网上的帖子),cross apply如果你正在进行分区,那么在选择大型数据集时可以更有效率.(寻找灵感)

我也知道CROSS APPLY 不需要UDF作为右表.

在大多数INNER JOIN查询(一对多关系)中,我可以重写它们以供使用CROSS APPLY,但它们总是给我相同的执行计划.

任何人都可以给我一个很好的例子,告诉我什么时候能有效的CROSS APPLY情况INNER JOIN？

编辑:

这是一个简单的例子,执行计划完全相同.(告诉我一个他们不同的地方,哪里cross apply更快/更有效率)

create table Company (
    companyId int identity(1,1)
,   companyName varchar(100)
,   zipcode varchar(10) 
,   constraint PK_Company primary key (companyId)
)
GO

create table Person (
    personId int identity(1,1)
,   personName varchar(100)
,   companyId int
,   constraint FK_Person_CompanyId foreign key (companyId) references dbo.Company(companyId)
,   constraint PK_Person primary key (personId)
) …

鉴于toString()下面的两个实现,首选哪一个:

public String toString(){
    return "{a:"+ a + ", b:" + b + ", c: " + c +"}";
}

要么

public String toString(){
    StringBuilder sb = new StringBuilder(100);
    return sb.append("{a:").append(a)
          .append(", b:").append(b)
          .append(", c:").append(c)
          .append("}")
          .toString();
}

？

更重要的是,鉴于我们只有3个属性,它可能没有什么区别,但你会在什么时候从+concat 切换到 StringBuilder？

在网上无数的地方,我已经看到了在JavaScript之前包含CSS的建议.一般来说,推理的形式如下:

在订购CSS和JavaScript时,您希望首先使用CSS.原因是渲染线程具有渲染页面所需的所有样式信息.如果首先包含JavaScript,则JavaScript引擎必须先解析它,然后再继续使用下一组资源.这意味着渲染线程无法完全显示页面,因为它没有所需的所有样式.

我的实际测试揭示了一些截然不同

我的测试工具

我使用以下Ruby脚本为各种资源生成特定的延迟:

require 'rubygems'
require 'eventmachine'
require 'evma_httpserver'
require 'date'

class Handler  < EventMachine::Connection
  include EventMachine::HttpServer

  def process_http_request
    resp = EventMachine::DelegatedHttpResponse.new( self )

    return unless @http_query_string

    path = @http_path_info
    array = @http_query_string.split("&").map{|s| s.split("=")}.flatten
    parsed = Hash[*array]

    delay = parsed["delay"].to_i / 1000.0
    jsdelay = parsed["jsdelay"].to_i

    delay = 5 if (delay > 5)
    jsdelay = 5000 if (jsdelay > 5000)

    delay = 0 if (delay < 0) 
    jsdelay = 0 if (jsdelay < 0)

    # Block which …

我正在研究涉及大量数据库写入的项目,我会说(70%的插入和30%的读取).该比率还包括我认为是一次读取和一次写入的更新.读取可能很脏(例如,在读取时我不需要100%准确的信息).
有问题的任务将是每小时进行超过100万次数据库事务.

我在网上看到了一些关于MyISAM和InnoDB之间差异的东西,对于我将用于此任务的特定数据库/表格来说,MyISAM似乎是我的明显选择.从我似乎正在阅读的内容来看,如果需要事务处理,InnoDB很好,因为支持行级锁定.

有没有人有这种负载(或更高)的经验？MyISAM是走的路吗？

大多数拥有CS学位的人肯定会知道Big O代表什么.它可以帮助我们衡量算法的实际效率(如何),如果你知道你试图解决的问题属于哪个类别,你可以弄清楚是否仍然可以挤出那么少的额外性能.¹

但我很好奇,你如何计算或近似算法的复杂性？

¹ _{但正如他们所说,不要过度,过早优化是所有邪恶的根源,没有正当理由的优化也应该得到这个名称.}

以下Java程序平均需要在0.50到0.55之间运行:

public static void main(String[] args) {
    long startTime = System.nanoTime();
    int n = 0;
    for (int i = 0; i < 1000000000; i++) {
        n += 2 * (i * i);
    }
    System.out.println((double) (System.nanoTime() - startTime) / 1000000000 + " s");
    System.out.println("n = " + n);
}

如果我更换2 * (i * i)用2 * i * i,它需要0.60〜0.65s之间运行.怎么会？

我运行了每个版本的程序15次,在两者之间交替.结果如下:

 2*(i*i)  |  2*i*i
----------+----------
0.5183738 | 0.6246434
0.5298337 | 0.6049722
0.5308647 | 0.6603363
0.5133458 | 0.6243328
0.5003011 | …

我需要使用Java逐行读取大约5-6 GB的大文本文件.

我该怎么办？

def main():
    for i in xrange(10**8):
        pass
main()

Python中的这段代码运行(注意:时序是在Linux中的BASH中使用时间函数完成的.)

real    0m1.841s
user    0m1.828s
sys     0m0.012s

但是,如果for循环没有放在函数中,

for i in xrange(10**8):
    pass

然后它会运行更长的时间:

real    0m4.543s
user    0m4.524s
sys     0m0.012s

为什么是这样？

我为Project Euler Q14编写了这两个解决方案,在汇编和C++中.它们是用于测试Collat​​z猜想的相同蛮力方法.装配解决方案与组装

nasm -felf64 p14.asm && gcc p14.o -o p14

C++是用.编译的

g++ p14.cpp -o p14

部件, p14.asm

section .data
    fmt db "%d", 10, 0

global main
extern printf

section .text

main:
    mov rcx, 1000000
    xor rdi, rdi        ; max i
    xor rsi, rsi        ; i

l1:
    dec rcx
    xor r10, r10        ; count
    mov rax, rcx

l2:
    test rax, 1
    jpe even

    mov rbx, 3
    mul rbx
    inc rax
    jmp c1

even:
    mov rbx, 2 …

在Java的隐藏功能中,最佳答案提到了Double Brace Initialization,它具有非常诱人的语法:

Set<String> flavors = new HashSet<String>() {{
    add("vanilla");
    add("strawberry");
    add("chocolate");
    add("butter pecan");
}};

这个成语创建了一个匿名内部类,其中只包含一个实例初始化程序,"可以使用包含作用域中的任何[...]方法".

主要问题:这听起来效率低吗？它的使用是否应限于一次性初始化？(当然炫耀!)

第二个问题:新的HashSet必须是实例初始化程序中使用的"this"...任何人都可以了解机制吗？

第三个问题:在生产代码中使用这个成语是否过于模糊？

简介:非常非常好的答案,谢谢大家.在问题(3)中,人们认为语法应该是清楚的(尽管我建议偶尔发表评论,特别是如果你的代码会传递给可能不熟悉它的开发人员).

在问题(1)上,生成的代码应该快速运行.额外的.class文件会导致jar文件混乱,并且会稍微减慢程序启动速度(感谢@coobird测量它).@Thilo指出垃圾收集可能会受到影响,在某些情况下,额外加载类的内存成本可能是一个因素.

问题(2)对我来说最有趣.如果我理解答案,那么DBI中发生的事情是匿名内部类扩展了由new运算符构造的对象的类,因此具有引用正在构造的实例的"this"值.井井有条.

总的来说,DBI让我感到非常好奇.Coobird和其他人指出,您可以使用Arrays.asList,varargs方法,Google Collections和提议的Java 7 Collection文字获得相同的效果.Scala,JRuby和Groovy等较新的JVM语言也为列表构建提供了简明的符号,并且与Java良好地互操作.鉴于DBI使类路径混乱,减慢了类加载速度,并使代码更加模糊,我可能会回避它.但是,我打算在一位刚刚获得SCJP的朋友身上发表这篇文章,并且喜欢关于Java语义的好朋友!;-) 感谢大家!

7/2017:Baeldung 对双支撑初始化有很好的总结,并认为它是一种反模式.

12/2017:@Basil Bourque指出,在新的Java 9中你可以说:

Set<String> flavors = Set.of("vanilla", "strawberry", "chocolate", "butter pecan");

这肯定是要走的路.如果您遇到早期版本,请查看Google Collections的ImmutableSet.