小编tkr*_*man的帖子

我不时会遇到System.nanoTime()速度慢很多(电话费用可能高达微秒)System.currentTimeMillis(),但是证据链接经常过时,或导致一些不太真实可信的博客帖子,或者包含有关的信息特定平台,或者这个,或那个等等.

我没有运行基准测试,因为我对这种敏感问题进行实验的能力是现实的,但我的条件确实很明确,所以我期待一个简单的答案.

因此,平均而言,64位Linux(意味着64位JRE),Java 8和现代硬件,将转换为nanoTime()花费我微秒才能调用？我应该待在一起currentTimeMillis()吗？

假设我有

def foo(x: Any) = x match {
  case s: String => println(0)
  case i: Int => println(1)
  case l: Long => println(2)
  //...
}

有没有办法制作如下的东西？

def foo(x: Any) = x match {
  case s: String => println(0)
  case i: Numeric => println("Numeric")
}

我有以下代码:

when(mockedOperation.getResult(anyDouble(), anyDouble())).thenCallRealMethod();
when(mockedOperation.division(anyDouble(), not(eq(0d)))).thenCallRealMethod();

哪里Operation是像Command模式-它封装了一些具体行动,在这种情况下,简化-除法运算.结果检索不是直接发生的,而是通过契约方法,比方说getResult(arg1, arg2).所以,我打电话

  mockedOperation.division(10d, 3d);

但是,(在我的具体执行的调试信息Operation),我可以看到,division()变得不10和3,但(0, 0).

据我了解,该参数是在两者之间失去了thenCallRealMethod()通过getResult(),并呼吁真正 division()算账.

这种行为的原因是什么？如果我确实需要它,我应该如何正确实现部分模拟？

UPD.也许我应该试着用另一种方式来说,例如,你是如何创建模拟的,callRealMethod以这种方式将参数正确地传递给端点？

我的问题主要是关于Scala,但是最后它仍然使用JVM的特性,我也把java标签.

我使用参数化类型越多,上述问题就越频繁出现.类型擦除带来了如此多的不便(模式匹配就像case x: A[B]变得不可能等等)并且存在相当繁重的基于运行时反射的变通方法,涉及在运行时携带类型信息的额外对象,所以我(从我的用户角度来看,只是普通的好奇心)想知道什么决定导致了当前的土地谎言.

到处运行完全类型到运行时信息太复杂了？或者可能没有那么多用例,所以它不仅仅是经常被需要？无论如何,类型擦除的利弊是什么？

编辑:我想有一些关于这个主题的合格的讨论,论文或帖子等,我希望答案在理论上得到支持或至少包含某种CS推测,而不仅仅是"运行时类型是一种不好的做法".这不是关于你是否确实遇到过这个问题的问题 - 这是关于导致决定的CS基础.

我有一段简单的代码，但它的工作方式与我预期的不同：

        try (OutputStream ostr = new BufferedOutputStream(System.out)) {
            ostr.write("lol".getBytes());
        }
        System.out.println("hmmm");

结果只是

lol

已打印，但未打印hmm。

我究竟做错了什么？我假设hmm没有打印，因为也ostr关闭了，这是正确的吗？System.out我知道这是一个非常综合的例子，但我仍然期待答案。

正如所看到这里,图的定义

以一种有点时髦的方式

为了完整起见,这里是代码:

implicit def FunctionFunctor[R] = new Functor[({type l[a] = R=>a})#l] {
  def map[A, B](fa: R => A)(f: A => B) : R => B = (x => f(fa(x)))
}

更具体地说 - new Functor[({type l[a] = R=>a})#l]

我确实认为我知道发生了什么,但不能说老实说我完全理解这个概念.而且由于没有任何暗示,我不能谷歌这个术语(我根本不知道谷歌).是否有一些教程(或评论,或其他)存在于更好的去除水平的解释？我更感谢有人可以在答案中解释它.

我想雇用com.sun.management.ThreadMXBean做这样的事情：

long before = threadMxBean.getThreadAllocatedBytes(currentThreadId);
seriousBusiness(); // some calls here
long after = threadMxBean.getThreadAllocatedBytes(currentThreadId);
long allocDiff = after - before; // use for stats or whatever

问题是，这个方法实际上返回什么：方法调用时分配的新内存量或分配对象的大小？要清楚我的意思是什么区别：

1) 假设我在seriousBusiness()调用中分配了一个巨大的数组，因此为此分配了一个新的内存区域，并按getThreadAllocatedBytes相应的值递增。

2) 过了一段时间，有一次 GC 运行，未使用的数组被收集，内存区域现在​​是空闲的。

3）我再次进行了一些调用（在同一个线程中），JVM 发现它不需要分配新内存并为新目的重用该内存区域，这导致getThreadAllocatedBytes值没有增长。

我可能不太清楚 JVM 内存管理是如何工作的，但问题应该很清楚。

另外，如果第一个假设是正确的（只是新的内存分配计数），那么进行per-thread object allocations / memory footprint测量的正确方法是什么？

更新。我试着自己检查：http : //pastebin.com/ECQpz8g4。（sleeps in the code是为了让我用JMC连接到JVM）。

TL;DR：分配一个巨大的 int 数组，然后对其进行 GC，然后分配一些新对象并检查分配的内存。这是我得到的：

所以，看起来 GC 确实运行了，虽然内存肯定被分配并随后被释放，但我得到了这个输出：

665328          // before …

假设一个人有一个简单的类:

public class Point implements Comparable<Point> {

    public int compareTo(Point p) {
        if ((p.x == this.x) && (p.y == this.y)) {
            return 0;
        } else if (((p.x == this.x) && (p.y > this.y)) || p.x > this.x) {
            return 1;
        } else {
            return -1;
        }
    }

    private int x;
    private int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    } …

from concurrent.futures import ThreadPoolExecutor, as_completed

def main():
    with ThreadPoolExecutor(max_workers=16) as producersPool:
        for i in [1,2,3,4,5,6,7,8,9,0]:
            producersPool.submit((lambda i : print(i))(i))


if __name__ == "__main__":
    main()

使用python3运行:

1
2
3
4
5
6
7
8
9
0

总是一样.

现在我希望你让我正确 - 我不一定希望重新安排这些任务,但我只是想知道为什么排序会发生？我的意思是,人们可以期望在一个线程内以确定的方式完成任务,但线程的严格排队对我来说似乎有些奇怪.

无论如何,我如何在Python 3中获得真正的并发？(据我所知,Jython和IronPython只支持2.x).

在GridFS FAQ中,有人说应该存储大小> 16MB的上述GridFS文件.我有很多文件~500KB.

问题是:哪种方法更有效 - 将文件内容存储在文档中或将文件本身存储在GridFS中？我应该考虑其他方法吗？