小编Abi*_*idi的帖子

我有一个接口TestInterface <U,V>有很多实现,当我使用Guice进行绑定时,我收到一条消息,说TestInterface <Impl1,Impl2>没有绑定到实现.以下是我用来将接口与其实现绑定的语法.

绑定(TestInterface.class).annotatedWith(Names.named( "Impl1Test"))至(Impl1.class).

ps我测试了一个虚拟接口,但没有泛型,它工作正常,我认为泛型需要做一些特别的事情.

用户定义的注释中两个元注释(目标和保留)的确切默认值是什么？

public @interface AnnotationWithDefaultProps {
}

我理解使用构造函数注入优于setter注入的好处,但在某些情况下,我必须坚持使用基于setter的注入.我的问题是如何使用injector.injectMembers()方法注入所有基于setter的注入类的成员？

//I am calling this method in init method of my application
private static final Injector injector = Guice.createInjector(new A(), new B());

//Injecting dependencies using setters of all classes bound in modules A and B
injector.injectAllMembers()??

我一直在阅读有关mercurial标签的内容.通常,我可以看到,我们标记了一个变更集来标记一个发布点,这些标签也是由版本控制的.

但我无法理解拥有.hgtags文件的想法.这个文件的目的是什么？

我理解一个synchronized块或方法将阻塞所有线程,直到内部的一个"左".我想知道,当线程在同步块内执行时,是否可以发生上下文切换？在我的理解中,它不应该.

谢谢!

以下关系仅适用于两个(3,12)数字,当用于三个数字(3,12,10)时,它无法产生正确的答案.只是想知道它是我的理解还是只是两个数字,对我来说同样适用于Euclid算法.

LCM(a, b) = (a x b) / GCD(a,b) or GCD(a,b) = (a x b) / LCM(a, b) 

我想比较直接字节缓冲区（java.nio.ByteBuffer，堆外）和堆缓冲区（通过数组实现）的读取和写入性能。我的理解是，ByteBuffer 在堆外比堆缓冲区至少有两个好处。首先，它不会被 GC 考虑，其次（我希望我做对了）JVM 在读取和写入它时不会使用中间/临时缓冲区。这些优点可能使堆外缓冲区比堆缓冲区更快。如果这是正确的，我不应该期望我的基准显示相同吗？它总是比非堆缓冲区更快地显示堆缓冲区。

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Benchmark)
@Fork(value = 2, jvmArgs = {"-Xms2G", "-Xmx4G"})
@Warmup(iterations = 3)
@Measurement(iterations = 10)
public class BasicTest {

    @Param({"100000"})
    private int N;

    final int bufferSize = 10000;

    ByteBuffer byteBuffer = ByteBuffer.allocateDirect(8 * bufferSize);
    long buffer[] = new long[bufferSize];


    public static void main(String arep[]) throws  Exception {

        Options opt = new OptionsBuilder()
                .include(BasicTest.class.getSimpleName())
                .forks(1)
                .build();

        new Runner(opt).run();

    }


    @Benchmark
    public void offHeapBuffer(Blackhole blackhole) {

        IntStream.range(0, bufferSize).forEach(index -> {
            byteBuffer.putLong(index, 500 * index);
            blackhole.consume(byteBuffer.get(index));
        }); …

我理解JVM为每个线程创建一个Stack,并且当线程调用它们时,Stack包含对其他方法的调用.我不明白Stack什么时候会有局部变量和部分结果.我认为全局和局部变量(原语和引用)将存在于堆而不是堆栈中,任何人都可以详细说明它的意思吗？其次它表示部分结果,是否意味着当线程切换发生时,那些半执行的结果(副本)来自本地和实例变量？

谢谢

-Abidi

当我们说使用synchronized关键字锁定一个对象时,它是否意味着我们正在获取整个对象的锁定或仅获取块中存在的代码？

在以下示例中listOne.add是同步的,是否意味着如果另一个线程访问listOne.get它将被阻塞,直到第一个线程离开此块？如果第二个线程在第一个线程仍在同步块中时访问同一对象的实例变量上的listTwo.get或listTwo.add方法,该怎么办？

List<String> listONe = new ArrayList<String>();
List<String> listTwo = new ArrayList<String>();

/* ... ... ... */

synchronized(this) {
    listOne.add(something);
}

我在这里阅读了一些关于Arrays.sort的线程,使用"tuned quick-sort"作为原始类型,并使用merge-sort作为对象.我做了一个小测试只是为了证明这一点,但我发现相反是安静的.

            int a[] = new int[50000];
    //Integer a[] = new Integer[50000];

    for(int i=0; i<50000; i++) {
        //a[i] = new Integer(new Random().nextInt(5000)); 
        a[i] = new Random().nextInt(5000);
    }
    System.out.println(System.currentTimeMillis());

    Arrays.sort(a);

    System.out.println(System.currentTimeMillis());

对于原始类型数组,它需要22ms,对于带有对象的数组需要98ms.我的笔记本电脑i7配备8核和8GB内存.我运行不正确吗？

非常感谢!