小编Mar*_*o13的帖子

在写一个关于JVM字节码偏移的问题的答案时,我注意到javac的行为以及我无法解释的结果类文件:

编译这样的类时

class FarJump
{
    public static void main(String args[])
    {
        call(0, 1);
    }

    public static void call(int x, int y)
    {
        if (x < y)
        {
            y++;
            y++;

            // ... (10921 times - too much code to post here!)

            y++;
            y++;
        }
        System.out.println(y);
    }

}

然后生成的字节代码将包含以下if_icmpge指令:

public static void call(int, int);
    Code:
       0: iload_0
       1: iload_1
       2: if_icmpge     32768
       5: iinc          1, 1
       8: iinc          1, 1
       ...

根据跳转指令的文档,偏移量(在这种情况下为32768)计算如下:

如果比较成功,则使用无符号branchbyte1和branchbyte2 …

在查看了一些Java Collection类的源代码之后,我发现成员变量总是被使用修改transient.

例如,LinkedList源代码:

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    private transient Entry<E> header = new Entry<E>(null, null, null);
    private transient int size = 0;

    public LinkedList() 
    {
        header.next = header.previous = header;
    }

    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

    // ...other stuff
}

当然,不仅LinkedList使用transient,几乎每个Java集合类都使用它transient来修改其成员变量的至少一半.

所以,我的问题是:为什么在Java标准库中transient使用如此广泛？

(当然每个人都知道它的定义和用法transient,但那不是我的问题:)

对于涉及异步操作的库,我必须保持对对象的引用,直到满足某个条件.

^{(我知道,这听起来很不寻常.所以这里有一些上下文,虽然它可能并不严格相关:该对象可能被认为是在JNI操作中使用的直接 对象ByteBuffer.JNI操作将获取缓冲区的地址.这一点,这个地址只是一个"指针",不被认为是对字节缓冲区的引用.地址可以在以后的时间内异步使用.因此,必须防止缓冲区被垃圾收集,直到JNI操作完了.)}

为实现这一点,我实现了一个基本上等同于此的方法:

private static void keepReference(final Object object)
{
    Runnable runnable = new Runnable()
    {
        @SuppressWarnings("unused")
        private Object localObject = object;

        public void run()
        {
            // Do something that does NOT involve the "localObject" ...
            waitUntilCertainCondition();

            // When this is done, the localObject may be garbage collected
        }
    };
    someExecutor.execute(runnable);
}

我们的想法是创建一个Runnable将所需对象作为字段的实例,将此runnable抛入执行程序,并让runnable等待直到满足条件.执行程序将保持对可运行实例的引用,直到它被完成为止.runnable 应该保持对所需对象的引用.因此,只有在满足条件之后,执行程序才会释放runnable,因此本地对象将有资格进行垃圾回收.

该localObject字段未在run()方法体中使用.可能编译器(或更准确地说:运行时)检测到这一点,并决定删除这个未使用的引用,从而允许对象过早地进行垃圾回收？

_{(我考虑过这方面的解决方法.例如,在"虚拟语句"中使用对象logger.log(FINEST, …}

为什么我在FuzzyWuzzyContainer上收到此编译器错误？

绑定不匹配:FuzzyWuzzy类型不是FuzzyContainer类型的有界参数<T extends Fuzzy & Comparable<T>>的有效替代

实际上,FuzzyWuzzy实现了有界泛型中定义的两个接口.

public interface Fuzzy
{
    boolean isFuzzy();
}

public class FuzzyWuzzy implements Fuzzy, Comparable<Fuzzy>
{
    public boolean isFuzzy() {return true;}
    public int compare(Fuzzy o) {return 0;)
}

public abstract class FuzzyContainer<T extends Fuzzy & Comparable<T>>
{
   :
}

public class FuzzyWuzzyContainer extends Fuzzycontainer<FuzzyWuzzy> // Error is here
{
}

我正在尝试用Java制作一些形状.我创建了两个有两种不同颜色的矩形,但我想创建一个星形,我找不到有用的来源来帮助我这样做.

这是我的代码:

import java.awt.*;
import javax.swing.*;

public class shapes extends JPanel{

    @Override
    public void paintComponent(Graphics GPHCS){
        super.paintComponent(GPHCS);

        GPHCS.setColor(Color.BLUE);
        GPHCS.fillRect(25,25,100,30);

        GPHCS.setColor(Color.GRAY);
        GPHCS.fillRect(25,65,100,30);

        GPHCS.setColor(new Color(190,81,215));
        GPHCS.drawString("This is my text", 25, 120);
    }
}

问题:

给定两个Collection<?>s,检查两者是否包含相同的元素.

• 假设集合的实际实现是未知的
• 假设元素不以相同的顺序出现
• 假设在同一个集合中没有元素确实出现过两次

解决方案1:

boolean equals = c1.containsAll(c2) && c2.containsAll(c1);

解决方案2:

boolean equals = new HashSet<?>(c1).equals(new HashSet<?>(c2));

我认为解决方案2比解决方案1(O(n ^ 2))更有效(O(n )).

我纠正还是错过了什么？

假设我在应用程序中为国家/地区使用了相当多的下拉选项（也称为组合框）。\n为了避免一遍又一遍地重复相同的代码，我想为此创建一个指令。

但是：使用以下指令并不能满足我的所有期望（见下文），而复制粘贴模板确实满足我的所有期望。

app.directive(\'countrydropdown\', function($compile) {\n  return {\n    restrict: \'E\', //attribute or element\n    scope: {\n      countryUri: \'=\'\n    },\n    templateUrl: \'countrydropdown.html\',\n    controller : function($scope) {\n      $scope.listItems = [ \n        {name: \'Afghanistan\', code: \'AF\'},\n        {name: \'\xc3\x85land Islands\', code: \'AX\'},\n        {name: \'Albania\', code: \'AL\'},\n      ];      \n

我的模板在哪里：

<div>\n  model (inside directive): {{countryUri}}\n\n   <ui-select ng-model="countryUri" theme="selectize" >\n    <ui-select-match placeholder="Select or search a country in the list...">{{$select.selected.name}}</ui-select-match>\n    <ui-select-choices repeat="\'/api/countries/\'+country.code as country in listItems | filter: $select.search">\n      <span ng-bind-html="country.name | highlight: $select.search"></span>\n      <small …

我正在阅读有关Java中已检查和未检查的异常的文章，并找到此文章/链接：https : //projectlombok.org/disableCheckedExceptions.html

根据这篇文章，这只是为javac开发的一种hack。

考虑下面的代码片段：

import java.io.*;
class Example
{  
    public static void main(String args[]) throws IOException
    {
        FileInputStream fis = null;
        fis = new FileInputStream("myfile.txt"); 
        int k; 

        while(( k = fis.read() ) != -1) 
        { 
            System.out.print((char)k); 
        } 
        fis.close();    
    }
}

在这里我必须写， public static void main(String args[]) throws IOException 因为我正在尝试打开文件。在这里，“ throws”子句是必须的。没有它，我会得到一个错误。如果我确定要打开的文件的存在怎么办。提到的位置中的iemyfile.txt。在某些时候，您可能会觉得代码不需要检查异常。

Java是否提供了根据需要禁用检查异常的功能？

即使做了很多研究，我也找不到合适的答案。

我正在学习Java,并且在一个递归示例中使用了以下代码,我不知道为什么print语句开始从1而不是10开始打印j？

class Test { 
   void printtest(int j)  {
      if(j==0) 
         return;
      else 
         printtest(j-1); 
      System.out.println(j);
   } 
} 
public class RecursionTest { 
   public static void main(String args[])  {
      Test t = new Test();
      t.printtest(10); 
   }
} 

输出:

1
2
3 
4 
......10

在使用旧 PC ¹时，我发现了一些我认为是奇怪的渲染错误的东西。

当颜色深度设置为 16 位（32768 色）时会出现此问题。

特别是，当使用 绘制具有低 alpha 值的颜色时，它会出现Graphics2D。以下是重现该问题的MVCE 。它只是绘制几组线条，颜色为白色，alpha 值范围为 4 到 12。运行该程序的结果如下图所示：

人们可以看到，对于某些 alpha 值，某些颜色实际上是绿色的，尽管显然应该有50 9 种灰色。

（再次强调，只有当颜色深度设置为 16 位时才会出现！）

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class _WTFPaintTest
{
    public static void main(String[] args)
    {
        SwingUtilities.invokeLater(new Runnable()
        {
            @Override
            public void run()
            {
                createAndShowGUI();
            }
        });
    }

    private static void createAndShowGUI()
    {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        f.getContentPane().add(new JPanel() …

有几个相关的问题,关于在设置新的TreeModel时自动扩展JTree,或者关于扩展JTree的一般问题,其中一些也是针对在JTree中扩展许多路径的性能.

但是,所提出的解决方案似乎都没有涵盖人们可以考虑的"简单"应用案例:我有一棵大树(也就是说,树很深,很宽,或两者兼而有之),我想完全以编程方式扩展它.

以下是显示问题的MCVE:它创建一个具有100k节点的树模型.按下按钮会触发调用expandAll,该调用尝试使用从相关问题的答案派生的方法扩展所有节点.

问题是扩展这些100k节点需要大约13秒(在普通机器上,使用最近的JVM).

import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.util.function.Consumer;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.SwingUtilities;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeModel;


public class TreeExpansionPerformanceProblem
{
    public static void main(String[] args)
    {
        SwingUtilities.invokeLater(
            () -> createAndShowGUI());
    }

    private static void createAndShowGUI()
    {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().setLayout(new GridLayout(1,0));

        f.getContentPane().add(createTestPanel(
            TreeExpansionPerformanceProblem::expandAll));

        f.setSize(800,600);
        f.setLocationRelativeTo(null);
        f.setVisible(true);
    }

    private static JPanel createTestPanel(Consumer<JTree> …

在第 12.3.3. 节“不切实际的代码路径采样”中，Java 并发实践书说：

在某些情况下，JVM 可能会基于可能只是暂时正确的假设进行优化，如果它们变得不正确，则稍后通过使已编译的代码无效来回退它们

我无法理解上面的说法。

1. 这些 JVM 假设是什么？
2. JVM 如何知道假设是真还是假？
3. 如果假设不真实，它会影响我的数据的正确性吗？

我正在编写一个简单的多流 CUDA 应用程序。cuda-streams以下是我创建,cublas-handle和的代码部分cudnn-handle：

cudaSetDevice(0);

int num_streams = 1;

cudaStream_t streams[num_streams];
cudnnHandle_t mCudnnHandle[num_streams];
cublasHandle_t mCublasHandle[num_streams];

for (int ii = 0; ii < num_streams; ii++) {
    cudaStreamCreateWithFlags(&streams[ii], cudaStreamNonBlocking);
    cublasCreate(&mCublasHandle[ii]);
    cublasSetStream(mCublasHandle[ii], streams[ii]);
    cudnnCreate(&mCudnnHandle[ii]);
    cudnnSetStream(mCudnnHandle[ii], streams[ii]);
}

现在，我的流计数为 1。但是当我使用 Nvidia Visual Profiler 分析上述应用程序的可执行文件时，我得到以下信息：

对于我创建的每个流，它会另外创建 4 个流。我用 进行了测试num_streams = 8，它在分析器中显示了 40 个流。它在我心中提出了以下问题：

1. 内部是否cudnn创建流？如果是，那为什么？
2. 如果它隐式创建流那么使用它的方式是什么？
3. 在这种情况下，显式创建流有什么意义吗？