小编new*_*gic的帖子

等待和通知看起来像是在线程之间传递的消息,如果这是真的,则必须有用于缓冲这些消息的队列.如果是这样,那么必须有用于向队列添加消息和从队列中删除消息的原子操作,每个侦听这些消息的Java线程也必须有一个帮助线程吗？

很高兴听到你的想法.

是否可以将保护条件与密封案例类声明中的模式匹配相结合？

我意识到可以在匹配块中包含保护条件,但我觉得在密封的案例类中预先定义这些条件是有益的.这将允许开发人员定义严格的可能输入集,编译器在模式匹配时将检查这些输入.

总而言之,我希望能够做到这样的事情:

// create a set of pattern matchable cases with guards built in

sealed abstract class Args
case class ValidArgs1(arg1:Int,arg2:Int) if arg1>1 && arg2<10 extends Args
case class ValidArgs2(arg1:Int,arg2:Int) if arg1>5 && arg2<6 extends Args
case class InvalidArgs(arg1:Int,arg2:Int) if arg1<=1 && arg2>=10 extends Args


// the aim of this is to achieve pattern matching against an exhaustive set of 
// pre-defined possibilities

def process(args:Args){
    args match 
    {
        case ValidArgs1 = > // do this
        case ValidArgs2= > // …

Java Unsafe类允许您按如下方式为对象分配内存,但是使用此方法如何释放完成时分配的内存,因为它不提供内存地址...

    Field f = Unsafe.class.getDeclaredField("theUnsafe"); //Internal reference
    f.setAccessible(true);
    Unsafe unsafe = (Unsafe) f.get(null);

    //This creates an instance of player class without any initialization
    Player p = (Player) unsafe.allocateInstance(Player.class);

有没有办法从对象引用访问内存地址,也许默认的hashCode实现返回的整数可以工作,所以你可以做...

 unsafe.freeMemory(p.hashCode());

似乎没有一些如何......

在Lua中遇到协同例程的概念后,我觉得这些似乎是编写并发软件的更好的模型,我想知道为什么Java中没有使用它？

协同例程似乎让开发人员编写在多个函数之间跳转的代码,每次执行几个步骤,提供并发执行的假象,就像CPU在Java中的多个线程之间切换时间一样,但是协同例程允许开发人员决定何时跳出一个函数并开始执行另一个函数.这允许开发人员决定步骤应该有多细粒度,即并发度,以及何时应该发生上下文切换,这可以防止在延迟关键时进行昂贵的上下文切换.

我的猜测是它存储在阵列中的每个值的32位/ 64位字(取决于CPU).所以它的数组大小为X 32位/ 64位.

在链表的情况下,存储指向下一个元素的引用将是两倍.所以它将是2*数组大小X 32位/ 64位.

这是对的吗,我错过了什么吗？

考虑证明以下 while 循环的正确性，即我想表明，给定循环条件开始时，它最终将终止并导致最终断言为真。

int x = 0;
while(x>=0 && x<10){
   x = x + 1;
}
assert x==10;

在不使用循环展开的情况下，用于检查正确性的 SMT-LIB 的正确翻译是什么？

你们认为这是一个很好的原子操作通用框架吗？您是否也认为对于Java应用程序而言,单个字节代码是原子的,因为使用单个JVM无法一次执行多个字节代码？所以,如果if else有一个单字节代码,那么这个if else指令是原子的吗？

// CAS, Compare and Swap
public abstract class CASOperation<T> {

protected T valueAtStart;

public CASOperation(){
    valueAtStart = objectToReview();
}

public void exec(){
    synchronized(this){
        while(!valueAtStartEqualsTheCurrent()){
            valueAtStart = objectToReview();
        }
        execImp();
    }
}

private boolean valueAtStartEqualsTheCurrent() {
    if (objectToReview().equals(valueAtStart)){
        return true;
    } else {
        return false;
    }
}

abstract protected T objectToReview();

abstract protected void execImp();

它本质上是一个比较和执行框架,因此在检查原始捕捉值没有改变之后,我们执行一些代码块.

Java有一个字符串池,因此在实际创建一个新字符串之前,我猜有一个检查是否已存在相同的字符串,这次调用的成本是多少？

池是基于散列或树的结构吗？

在任何一种情况下,我猜测归结为String哈希码的性能,因为搜索树使用哈希码作为密钥？

我猜它是关于log n,其中n是当前堆上的字符串数.

根据:

https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html

看起来它是可能的,但是尝试真正返回编译错误.由于我们无法使用静态方法实现接口,因此它更有意义.

public class SomeClass {

    static public boolean getB(){
        return false;
    }
}

List<SomeClass> list = new ArrayList<>();       
list.add(new SomeClass());

// below causes compile error, which I expect, however documentation indicates oherwise
list.stream().filter(SomeClass::getB).collect(Collectors.toList());

这是编译错误:

"此行的多个标记 - 应该以静态方式访问SomeClass类型的方法getB() - Stream类型中的方法过滤器(Predicate)不适用于参数(SomeClass :: getB)"

我们希望运行一些需要一定功率的构建。

默认构建实例的等效时钟速度是多少？它们有多少个虚拟内核和多少 RAM？它们可以配置为具有更高的规格吗？