小编Jen*_*ens的帖子

我需要在任何连接上启用TCP keepalive,现在我正在努力处理测试用例的结果.我想这是因为我真的不明白第一次发送keepalive探测器的时间.我tcp_keepalive_time在Linux 的文档中阅读了以下内容:

发送的最后一个数据包(简单的ACK不被认为是数据)和第一个keepalive探针之间的间隔; 在连接被标记为需要保持连接后,此计数器不再使用

其他一些消息来源表示这是连接空闲的时间,但它们没有进一步定义这意味着什么.我还调查了史蒂文斯找到一个更正式的定义,因为我想知道"最后发送的数据包"在考虑重传时实际意味着什么.

在我的测试用例中,我有一个连接,其中数据仅以相当高的速率从服务器发送到客户端.为了测试keepalive,我们拔掉了客户端网卡上的电缆.我现在可以看到网络堆栈尝试发送数据并进入重传状态,但是没有发送保持活动探测.在重传期间不发送保持活动探测是否正确？

我们有一个项目布局,包含bom文件中的子模块和依赖项:

projectA
    bom           
    module1
    module2

实际版本号被定义为bom文件中的属性,因此对于每个依赖项我们都有类似的东西

    <properties>
        <guice-version>4.1.0</guice-version>
    </properties>

<dependencies>
    <dependency>
        <groupId>com.google.inject</groupId>
        <artifactId>guice</artifactId>
        <version>${guice-version}</version>
    </dependency>
</dependencies>

projectA中的顶级pom导入dependecyManagement部分中的bom

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>group</groupId>
            <artifactId>bom</artifactId>
            <version>1.0.0</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
    </dependencies>
</dependencyManagement>

这一切都很好,我们有集中的依赖定义.

但是,在构建过程中的某个时刻,我们需要使用其中一个依赖项的版本.我希望在dependencyManagement部分中导入bom也会将属性导入顶级pom,但事实并非如此.也不可能将bom作为顶级pom的子节点,因为这会在pom文件之间创建循环依赖关系.

我考虑将属性放入外部文件,并在需要时使用maven属性插件读取它.那显然是在我们需要获取依赖版本的bom文件和pom文件中.但是,由于bom没有打包成jar,所以路径必须是硬编码的.

我可以通过将属性复制到两个地方来修复它,但我不想这样做.有没有办法获得依赖的版本,例如使用依赖项定义的属性？

问题似乎很常见,我想知道我们是否在项目结构中做错了.在这种情况下,集中属性的标准方法是什么？

我似乎误解了java.util.Date转换java.time.Instance.我有一些遗留代码,我需要使用java.util.Date它,并且此代码在其API中使用.

在DateAPI 中添加偏移量时,我有点困惑.据我所知,这Date是一个UTC时间("Date类旨在反映协调的通用时间(UTC)"),但是当我创建一个Date来自Instant一个偏移时添加:

public class TestDateInstant {
    @Test
    public void instantdate() {
        Instant i = Instant.now();
        System.out.println(i);
        Date d = Date.from(i);
        System.out.println(d);

        assertThat(i, equalTo(d.toInstant()));
    }
}

断言成立,但控制台上的输出是:

2017-09-26T08:24:40.858Z 
Tue Sep 26 10:24:40 CEST 2017

我想知道为什么Date.from在这种情况下使用偏移量.

常识是std::unique_ptr不引入性能损失(并且不使用删除器参数时不会造成内存损失),但我最近偶然发现了一个讨论,显示它实际上引入了一个额外的间接,因为unique_ptr无法在平台上的寄存器中传递安腾ABI.发布的示例类似于

#include <memory>

int foo(std::unique_ptr<int> u) {
    return *u;
}

int boo(int* i) {
    return *i;
}

与boo相比,这在foo中生成了额外的汇编指令.

foo(std::unique_ptr<int, std::default_delete<int> >):
        mov     rax, QWORD PTR [rdi]
        mov     eax, DWORD PTR [rax]
        ret
boo(int*):
        mov     eax, DWORD PTR [rdi]
        ret

解释是Itanium ABI要求unique_ptr由于非平凡的构造函数而不能在寄存器中传递,因此它在堆栈上创建,然后该对象的地址在寄存器中传递.

我知道这并没有真正影响现代PC平台的性能,但我想知道是否有人可以提供更多详细信息,说明为什么不能将其复制到寄存器中.由于零成本抽象是C++的主要目标之一,我想知道这是否已经在标准化过程中被讨论为可接受的偏差或者是否是实施质量问题.在考虑其优势时,性能损失肯定很小,特别是在现代PC平台上.

评论者指出,这两个函数并不完全等效,因此比较存在缺陷,因为它foo也会调用unique_ptr参数上的删除函数,但boo不会释放内存.但是,我只对传递一个unique_ptrby-value与传递一个普通指针所产生的差异感兴趣.我修改了示例代码并包含了一个delete释放普通指针的调用 ; 调用是在调用者中,因为unique_ptr调用者的上下文中也调用了删除函数,以使生成的代码更加相同.此外,手册delete也会检查,ptr != nullptr因为析构函数也会这样做.但是,foo不会在寄存器中传递参数并且必须进行间接访问.

我也想知道为什么编译器nullptr在调用之前不会忽略检查,operator delete …

以下程序被gcc拒绝为含糊不清的:

struct Aint 
{
    virtual void foo(int);
};

struct Astring 
{
    virtual void foo(std::string);
};

struct A: public Aint, public Astring {};

int main()
{
  std::string s;

  A a;
  a.foo(s);

  return 0; 
}

> vt.cpp: In function ‘int main()’: vt.cpp:13:9: error: request for
> member ‘foo’ is ambiguous
>        a.foo(s);
>          ^ vt.cpp:5:34: note: candidates are: virtual void Astring::foo(std::__cxx11::string)
>      struct Astring {virtual void foo(std::string);};
>                                   ^ vt.cpp:4:31: note:                 virtual void Aint::foo(int)
>      struct Aint {virtual void foo(int);};

由于同样的原因,Clang一直拒绝该计划:

clang …

我尝试使用get_unchecked()而不是[]索引运算符来获得s()我的des箱子功能的性能提升.

但是,即使在我的基准测试中将[](或get_unchecked())函数调用了48亿次,它也不会导致可见的性能提升.我原本认为,调用get_unchecked()48亿次而不是[]将使我的英特尔酷睿2双核2.4 GHz处理器的时间缩短2秒.

我做了这个小基准测试,有一个小代码向您展示:

#![feature(test)]

extern crate test;

fn main() {
}

pub fn s(box_id: usize, block: u64) -> u64 {
    const TABLES: [[[u64; 16]; 4]; 8] =
        [[[ 14,  4, 13, 1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9, 0, 7]
        , [  0, 15,  7, 4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5, 3, 8]
        , …

我想知道是否有一种方法可以直接在定义的相同表达式中调用.apply()或.get()使用lambda函数.当我想初始化一个可能是私有的变量时,我想到了这个问题,但我无法将其声明为final,因为该值是可以抛出异常的函数的返回值.例如,考虑Files.size(path):

 final s = Files.size(path);
 // code that uses s

现在,如果我想使用默认值,s如果有异常,我必须添加一个try/catch,但这是一个语句,而不是一个表达式:

s = 0;
try {
    s = Files.size();
}
catch (IOException e) {}

 // code that uses s

显而易见的解决方案是只声明一个包装try/catch的小辅助函数,例如getFileSizeOrZero.我也可以编写一个通用函数来包装它作为一般情况.这很好并且具有描述性,但更局部的函数方法会更好.

在C++中,我使用了lambdas:

const s = []() {
    try {
        return Files.size(path);
    } catch (...) {
        return 0;
    }
}();

所以我想知道这是否可以用Java完成.我能想到的最好的是

final int s = new IntSupplier() {
    @Override
    public int getAsInt() {
        try {
            return Files.size(path);
        }
        catch (IOException …

今天我一直在玩拥抱,并陷入一个非常简单的问题:

? 1 1
:: (Num a, Num (a -> t)) => t

那种类型是什么？我很难读到这个.

如果它有类型,为什么？我猜测表达式1 1是错误的,因此类型检查失败,Haskell编译器支持.

是否有可能教Doxygen将类型成员识别std::shared_ptr<T>为聚合？我认为它适用于普通指针,尽管我已添加BUILTIN_STL_SUPPORT=YES.

这个问题还延伸到std::unique_ptr这应该是一个组合,我想std::map<K,V>,std::vector<V>等可以被记录为有多重1 ... N组成,但我敢肯定我不会在所有情况下,希望这样.

如果Doxygen无法做到这一点,我会对C++的替代文档系统感兴趣.

假设我们有一个类和一个重载函数:

public class Main {
    static final class A {
    }

    public static String g(ToIntFunction<? extends A> f) {
        return null;
    }

    public static String g(ToDoubleFunction<? extends A> f) {
        return null;
    }
}

我想用方法引用调用g来调用类型为A的函数 - > int:

public class Main {
    static final class A {
    }

    public static String g(ToIntFunction<? extends A> f) {
        return null;
    }

    public static String g(ToDoubleFunction<? extends A> f) {
        return null;
    }

    private static int toInt(A x) {
        return 2;
    }

    public …