小编Pet*_*rey的帖子

在下面的示例中,一个线程通过消费者正在采用的ByteBuffer发送"消息".最好的表现非常好,但不一致.

public class Main {
    public static void main(String... args) throws IOException {
        for (int i = 0; i < 10; i++)
            doTest();
    }

    public static void doTest() {
        final ByteBuffer writeBuffer = ByteBuffer.allocateDirect(64 * 1024);
        final ByteBuffer readBuffer = writeBuffer.slice();
        final AtomicInteger readCount = new PaddedAtomicInteger();
        final AtomicInteger writeCount = new PaddedAtomicInteger();

        for(int i=0;i<3;i++)
            performTiming(writeBuffer, readBuffer, readCount, writeCount);
        System.out.println();
    }

    private static void performTiming(ByteBuffer writeBuffer, final ByteBuffer readBuffer, final AtomicInteger readCount, final AtomicInteger writeCount) {
        writeBuffer.clear();
        readBuffer.clear();
        readCount.set(0);
        writeCount.set(0); …

我有一个模块负责读取,处理和写入磁盘的字节.字节通过UDP传入,在汇编各个数据报之后,处理并写入磁盘的最终字节数组通常在200字节到500,000字节之间.偶尔会有一些字节数组,在汇编后,超过500,000字节,但这些数组相对较少.

我现在正在使用FileOutputStream的write(byte\[\])方法.我也在尝试包装FileOutputStreamin BufferedOutputStream,包括使用接受缓冲区大小作为参数的构造函数.

似乎使用的BufferedOutputStream是趋向于略微更好的性能,但我只是开始尝试不同的缓冲区大小.我只有一组有限的样本数据可供使用(来自样本运行的两个数据集,我可以通过我的应用程序管道).是否有一般的经验法则我可以应用于尝试计算最佳缓冲区大小以减少磁盘写入并最大化磁盘写入的性能,因为我知道有关我正在编写的数据的信息？

我正在为一个包含2,509个类的模块构建一个Javadoc.这目前每秒需要7分钟或6个文件.

我试过了

mvn -T 1C install

但是javadoc只使用1个CPU.有没有办法使用更多和/或加快？

我正在使用Oracle JDK 8更新112.我的开发机器有16个内核和128 GB内存.

运行飞行记录器我可以看到只有一个线程 main

对于那些感兴趣的人,我使用了以下选项:

<plugin>
    <artifactId>maven-javadoc-plugin</artifactId>
    <configuration>
        <additionalJOptions>
            <additionalJOption>-J-XX:+UnlockCommercialFeatures</additionalJOption>
            <additionalJOption>-J-XX:+FlightRecorder</additionalJOption>
            <additionalJOption>-J-XX:StartFlightRecording=name=test,filename=/tmp/myrecording-50.jfr,dumponexit=true</additionalJOption>
            <additionalJOption>-J-XX:FlightRecorderOptions=loglevel=debug</additionalJOption>
        </additionalJOptions>
    </configuration>
</plugin>

注意:一种解决方法是:

-Dmaven.javadoc.skip=true

我知道在Java虚拟机(JVM)中,可能需要进行预热,因为Java使用延迟加载过程加载类,因此您需要确保在启动主事务之前初始化对象.我是一名C++开发人员,不必处理类似的要求.

但是,我无法理解的部分如下:

1. 您应该预热哪些代码部分？
2. 即使我热身代码的某些部分,它仍然保持多长时间(假设这个术语只表示你的类对象保留在内存中多长时间)？
3. 如果每次收到活动时都有需要创建的对象,它会如何帮助？

考虑一个例子,期望通过套接字接收消息的应用程序,并且事务可以是新订单,修改订单和取消订单或确认的交易.

请注意,该应用程序是关于高频交易(HFT),因此性能非常重要.

在下面的示例中,如果列表中有多个类型,则编译正常,但如果我有一个元素,则会选择不再可分配的其他类型.

// compiles fine
List<Class<? extends Reference>> list = Arrays.asList(SoftReference.class, WeakReference.class);
// but take an element away and it no longer compiles.
List<Class<? extends Reference>> list2 = Arrays.asList(WeakReference.class);
// without giving the specific type desired.
List<Class<? extends Reference>> list3 = Arrays.<Class<? extends Reference>>asList(WeakReference.class);

我确信这有一个合乎逻辑的解释,但它逃脱了我.

    Error:Error:line (30)error: incompatible types
required: List<Class<? extends Reference>>
found:    List<Class<WeakReference>>

为什么有两个元素编译但一个元素没有？

顺便说一句:如果你试试,很难找到一个简单的例子

List<Class<? extends List>> list = Arrays.asList(ArrayList.class, LinkedList.class);

    Error:Error:line (28)error: incompatible types
required: List<Class<? extends List>>
found:    List<Class<? extends INT#1>>
where INT#1 is an intersection …

Enum是可比较的,这意味着你可以拥有

NavigableSet<AccessMode> modes = new TreeSet<>();
NavigableMap<AccessMode, Object> modeMap = new TreeMap<>();

它们具有O(ln N)个访问时间.

Enum集合具有O(1)访问时间,但不可导航

NavigableSet<AccessMode> modes = EnumSet.noneOf(AccessMode.class); // doesn't compile
NavigableMap<AccessMode, Object> modeMap = new EnumMap<>(AccessMode.class);  // doesn't compile

我想知道Enum集合是否不可导航(和排序)是有原因的.我错过了什么？

我想知道两者之间是否存在性能差异

检查值是否大于/小于另一个值

for(int x = 0; x < y; x++); // for y > x

和

检查某个值是否与另一个值不相等

for(int x = 0; x != y; x++); // for y > x

为什么？

另外:如果我比较零怎么办？还有什么区别吗？

如果答案还考虑了代码上的分组视图,那将是很好的.

编辑: 正如大多数人所指出的那样,性能上的差异当然可以忽略不计,但我对cpu级别的差异感兴趣.哪个操作比较复杂？

对我来说,学习/理解这项技术更具问题.

我删除了Java标签,我意外添加了标签,因为这个问题通常不仅仅基于Java,对不起.

在一个应用程序中,我有以下内容 -verbose:gc

[GC (Metadata GC Threshold)  8530310K->2065630K(31574016K), 0.3831399 secs]
[Full GC (Metadata GC Threshold)  2065630K->2053217K(31574016K), 3.5927870 secs]
[GC (Metadata GC Threshold)  8061486K->2076192K(31574016K), 0.0096316 secs]
[Full GC (Metadata GC Threshold)  2076192K->2055722K(31574016K), 0.9376524 secs]
[GC (Metadata GC Threshold)  8765230K->2100440K(31574016K), 0.0150190 secs]
[Full GC (Metadata GC Threshold)  2100440K->2077052K(31574016K), 4.1662779 secs]

什么是"元数据GC阈值"以及如何减少它.注意:虽然Full GC花了很长时间进行清理,但它实际上会清理很多,即如果不这样做会更好.

如果你看一下字节码

Consumer<String> println = System.out::println;

Java 8更新121生成的字节代码是

GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
DUP
INVOKEVIRTUAL java/lang/Object.getClass ()Ljava/lang/Class;
POP
INVOKEDYNAMIC accept(Ljava/io/PrintStream;)Ljava/util/function/Consumer; [
  // handle kind 0x6 : INVOKESTATIC
  java/lang/invoke/LambdaMetafactory.metafactory(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
  // arguments:
  (Ljava/lang/Object;)V, 
  // handle kind 0x5 : INVOKEVIRTUAL
  java/io/PrintStream.println(Ljava/lang/String;)V, 
  (Ljava/lang/String;)V
]
ASTORE 1

getClass()正在调用该方法System.out,结果被忽略.

这是间接空引用检查吗？

当然,如果你跑

PrintStream out = null;
Consumer<String> println = out::println;

这会触发NullPointerException.

在Java中,有没有办法获得参考地址,比方说

String s = "hello"

我可以获取s本身的地址,也可以获取引用引用的对象的地址吗？