小编Mal*_*alt的帖子

以下哪项是获取Java当前计算机主机名的最佳和最便携方式？

Runtime.getRuntime().exec("hostname")

VS

InetAddress.getLocalHost().getHostName()

我们有一个Java应用程序需要在虚拟(Hyper-V)Windows 2012 R2 Server上运行,以及其他环境.在此虚拟Windows服务器上执行时,似乎遇到了奇怪的计时问题.我们已经将问题跟踪到Java预定执行程序中的不稳定调度:

public static class TimeRunnable implements Runnable {

    private long lastRunAt;

    @Override
    public void run() {
        long now = System.nanoTime();
        System.out.println(TimeUnit.NANOSECONDS.toMillis(now - lastRunAt));
        lastRunAt = now;
    }

}

public static void main(String[] args) {
    ScheduledExecutorService exec = Executors.newScheduledThreadPool(1);
    exec.scheduleAtFixedRate(new TimeRunnable(), 0, 10, TimeUnit.MILLISECONDS);
}

此代码应每10ms运行一次TimeRunnable,在服务器上生成如下结果:

12
15
2
12
15
0
14
16
2
12
140
0
0
0
0
0
0
0
0
0
0
0
0
1
0
7
15
0
14
16
2
12 …

在Java中,实例化一个接口对象就像new Interface()... 一样简单,并覆盖所有必需的函数,如下所示AnimationListener

private void doingSomething(Context context) {
    Animation animation = AnimationUtils.loadAnimation(context, android.R.anim.fade_in);
    animation.setAnimationListener(new Animation.AnimationListener() {
        // All the other override functions
    });
}

但是,在Kotlin我们打字的时候

private fun doingSomething(context: Context) {
    val animation = AnimationUtils.loadAnimation(context, android.R.anim.fade_in)
    animation.setAnimationListener(Animation.AnimationListener(){
        // All the other override functions
    })
}

它错误投诉未解决参考AnimationListener.

假设我有一个包含2个更改的文件.我如何使用egit只提交其中一个？

命令行版本可以在这个问题中找到.

我是java中的多线程新手,我有一个问题,有些人可能会发现微不足道.

我必须调试第三方代码,我需要一些基本信息,知道在哪里寻找问题,因为代码非常大.

运行以下代码时:

public void method()
{
   long startTime = System.currentTimeMillis();
   synchronized (obj)
   {
      log( "time:" + System.currentTimeMillis() - startTime + " ms" );
      ...
   }
}

我明白了:

11:13:12 - time: 3816 ms
...
11:14:14 - time: 0 ms

为什么需要这么长时间(3816毫秒)才能获得对象的锁定？我应该在哪里看？例如,我想可能的答案是寻找获取"obj"锁定的代码,例如:

synchronized (obj) { ... }

或者是否可能在没有"synchronized"的对象"obj"上进行任何修改也可以锁定对象？

一个共同的(1,2)实现单的方式是使用具有静态构件的内部类:

public class Singleton  {    
    private static class SingletonHolder {    
        public static final Singleton instance = new Singleton();
    }    

    public static Singleton getInstance() {    
        return SingletonHolder.instance;    
    }

    private Singleton() {
        //...
    }
}

据说这个实现是懒惰的初始化和线程安全的.但究竟是什么保证了它的线程安全？处理 线程和锁定的JLS 17没有提到静态字段具有任何类型的先发生关系.我怎样才能确定初始化只发生一次并且所有线程都看到同一个实例？

以下是最新HTTP RFC 7230中的HTTP消息定义

 HTTP-message   = start-line
                  *( header-field CRLF )
                  CRLF
                  [ message-body ]

下面是header-field的定义,

 header-field   = field-name ":" OWS field-value OWS

 field-name     = token
 field-value    = *( field-content / obs-fold )
 field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
 field-vchar    = VCHAR / obs-text

 obs-fold       = CRLF 1*( SP / HTAB )

..和:

obs-text       = %x80-FF

..和ABNF的:

 VCHAR          =  %x21-7E
                                 ; visible (printing) characters

正如我们所看到的,场值可以有多个障碍折叠,而障碍折叠有一个CRLF.我认为CRLF是标题行的结尾对我来说很奇怪.是否有一个例子表明多个CRLF被编码到一个标题字段中？或者,我是否误解了这个定义？

码头9支持两种它自己的Jetty的WebSocket API,以及标准的JSR 356 API,为我承担其历史原因(Jetty的API 之前的最后JSR 356).

我查看了两个API的基本文档,以及一些示例.这两个API看起来相当完整且非常相似.但是,我需要为我正在编写的新项目选择一个而不是另一个,并且我希望避免使用可能在将来被弃用的API,或者可能会变得功能不足.

那么两者之间是否有任何重要的区别,除了一个标准化的明显事实？

我有三个Observables,我和combineLastest合并:

    Observable<String> o1 = Observable.just("1");
    Observable<String> o2 = Observable.just("2");
    Observable<String> o3 = Observable.just("3");

    Observable.combineLatest(o1, o2, o3, new Func3<String, String, String, Object>() {
        @Override
        public Object call(String s, String s2, String s3) {
            return null;
        }
    });

我想通知其中一个Observable的第一次发射而不忽略后面的发射,我想第一个操作员会这样做.是否有一个方便的操作员(例如):

    o1.doOnFirst(new Func1<String, Void>() {
        @Override
        public Void call(String s) {
            return null;
        }
    })

在JDK 8中，默认最大堆大小为

物理内存的 1/4 或 1GB

并且可以使用开关覆盖它-Xmx：

您可以使用 -Xmx 命令行选项覆盖此默认值。

该Xmx开关使用字节，而不是分数。有没有一种简单的方法将最大堆设置为机器物理内存的 X%？

编辑：

你为什么问？嗯，首先是好奇心。我觉得很奇怪，默认的 Xmx 是根据物理内存的一小部分定义的，但是一旦我触摸它，它就会突然变成一个绝对值。其次，如果我将相同（或类似）的应用程序部署到两台不同的服务器，并且其中一台具有更多的物理内存，我希望能够选择自动让 JVM 利用额外的内存。它并不总是有意义，但有时确实有意义。

显而易见的解决方案是使用 shell 脚本来检查可用空间量并计算 Xmx，但这似乎是一个笨拙的解决方案。我想用纯Java应该可以实现。