小编St.*_*rio的帖子

我目前正在阅读Brian Goetz的Java Concurrency in Practice.在第51页.在其中一个脚注中,他说:

虽然它可能似乎在构造函数中设置字段的值写入这些字段中的第一个值,因此不存在"老"值看作为过时的值,子类的构造函数运行之前Object构造函数首先写入默认值到所有领域.因此,可以将字段的默认值视为陈旧值.

所以,最终领域的概念现在还不清楚.考虑样本类:

public class MyClass{
    private final MyImmutableClass mic;

    public MyClass(){
        mic = MyImmutableClass.empty();
    }
}

根据上面的脚注,mic字段被分配两次,一次由Object构造函数指定,一次由构造MyClass函数本身指定.现在,假设我们MyClass不安全地发布了一个对象(例如通过public字段):

public final MyClass mc;

谁保证mc一致状态下的任何线程都能始终观察到？为什么有些线程不会意外地观察到默认值？

据我所知,该final字段本身仅保证在对象构造之后不能分配引用.如果我们宣布mc挥发性,那将是明确的.读取该字段的任何线程都应该直接从内存中读取它.禁止从缓存中读取它.

UPD:出版示例:

public static void main(String[] args){
    class MyRunnable implements Runnable(){
        private SomeClass sc;
        public MyRunnable(SomeClass sc){
            this.sc = sc;
        }
        public void run(){
            //do some with sc
        }
    } …

我对 tmux 还很陌生，想知道是否可以通过像Ctrl+b, \. Ctrl+b, "我可以用then 来完成，Ctrl+b, %但这有点冗长，而且我经常使用 4 窗口屏幕（这是我最喜欢的终端视图）。我的意思是：

问题：是否可以配置这样的绑定？

我有一些方法将通过 RMI 调用远程方法，如下所示：

/**
 * Implementation is supposed to be thread safe
 */
public interface Act extends java.rmi.Remote{
    String doSome() throws RemoteException;
}

public class SomeClass {
    private static final Act stub = (Act) Naming.lookup("/server/stub")

    public static void someMethodAccessedByMultipleThreads(){
        System.out.println(stub.doSome());
    }
}

如果远程方法是线程安全的，那么someMethodAccessedByMultipleThreads多线程调用是否安全？

或者是否存在一些 RMI 线程/网络/其他问题？

我有返回单元的两个部分的功能（f1，f2）。例如，类似这样的东西：

val f1 = {
   case s: arg => //do some
   //etc... lots of cases
}

val f2 = {
   case s: anotherArg => //do some
   //lots of cases
}

是否有一种简洁的方法可以将其组合为部分功能，就像

f(x) = {f1(x); f2(x)} iff f1.isDefinedAt(x) && f2.isDefinedAt(x)
f(x) = f1(x); iff f1.isDefinedAt(x) && !f2.isDefinedAt(x) 
f(x) = f2(x); iff !f1.isDefinedAt(x) && f2.isDefinedAt(x) 

我是汇编语言的初学者,试图理解这些都是如何工作的.我的问题可能看起来很愚蠢,但无论如何,这对我来说并不十分清楚.

考虑以下简单程序:

section .text
    global _start

_start:

    mov eax, [text]
    mov [val], eax
    mov ecx, val
    mov eax, 4
    mov edx, 7
    mov ebx, 1
    int 0x80

    mov eax, 1
    int 0x80

segment .bss
    val resb 2

segment .data
    text db "Th"
    len equ $- text

在这里,我们更新寄存器中的值并使用系统调用将其打印出来.但我想知道如果OS(我正在使用Ubuntu 16.04)在同一个核心上安排一些进程.这意味着该进程以自己的方式更新CPU寄存器.OS linux如何处理它？我的意思是每个进程都有自己一致的寄存器值,而不受其他进程的影响？

我正在运行一个 Spark 计算应用程序，我经常遇到任务终止的一些问题。这是它在我的 spark 控制台中的样子：

可以看出，有些职位的描述是 ( _num_ killed: another attempt succeeded)。这不仅仅是失败，这是不同的东西。有人可以解释它是什么吗？

我阅读了一些关于页目录和页表的手册，但对这些概念仍然很困惑。例如在这里我发现只进行单级分页是在浪费内存。所以在x86架构中我们使用 2 级分页。

cr3 --> PageDirectory --> PageTable --> Page

所以考虑下面的线性地址。

01001010101 1010101101 10101110101010 
 page tbl     page      offset

使用page tbl位我们找到页目录条目的物理地址。PD = cr3 + L * (page tbl)其中包含页表物理地址PT。现在我们正在寻找我们的页面P = PT + L * page。所以在单层我们有一个 4MiB 的页表。现在我们总共有 1024 个页表 4KiB = 4MiB。不要看内存经济。

我错过了什么？

我有以下地图:

val m: mutable.Map[String, Long] = mutable.Map()

如果不存在,我想给它一些价值.如果它依次存在,我想执行一些计算:

目前我通过以下方式实现:

val key: String = //...
val value: Long = //...
m(key) = m.getOrElse(key, 0L) + value

但这对我来说感觉有点冗长(在Java中我们有putIfAbsent方法).在Scala中有更短的方法吗？

我试图了解Scala中的转换是如何工作的.这是一个例子:

object Main extends App {
    val ai: Array[Any] = Array(1, 2, 3, 4, 5, 6)
    val ar: Array[AnyRef] = ai.map(_.asInstanceOf[AnyRef])
}

它工作正常.https://ideone.com/6PerTR

现在让我们重写如下:

object Main extends App {
    val ai: AnyRef = Array(1, 2, 3, 4, 5, 6)
    val ar: Array[AnyRef] = ai.asInstanceOf[Array[Any]].map(_.asInstanceOf[AnyRef])
}

这是行不通的.它ClassCastException现在失败,现在https://ideone.com/JbOQbb.为什么？我觉得在这里添加演员阵容已经够了 为什么第一个例子有效？

如果我们先铸造AnyRef,如何使它在第二种情况下工作Array[Any]？如何在这里添加拳击？

UPD:我也尝试过:

object Main extends App {
    val ai: AnyRef = Array(1, 2, 3, 4, 5, 6)
    val aii: Array[Any] = ai.asInstanceOf[Array[Any]]
    val …

我正在设计一个带有公共接口的库，其中包含不透明的结构声明：

lib_public.h:

typedef struct lib_struct lib_struct;

void foo(lib_struct *ptr);

void bar(lib_struct *ptr);

不透明lib_struct的结构隐藏了特定于操作系统的实现细节，因此直接将其放入其中似乎是一个糟糕的设计lib_struct.h。但我仍然想为它编写使用其成员的单元测试。目前，我决定创建一个单独的私有头文件，仅包含结构定义：

lib_struct_linux.h:

struct lib_struct{
   int epoll;
   int acceptor_socket;
}

因此，实现lib_struct.c和单元测试lib_struct_test.c将包含此标头，如下所示：

lib_struct.c:

#include "lib_struct_linux.h"

//function definition

lib_struct_test.c:

#include "lib_struct_linux.h"

//unit tests

问题是这样的设计看起来很混乱，因为结构体是在一个私有头文件（lib_struct_linux.h）中定义的，而使用该结构体的函数是在另一个公共头文件（lib_public.h）中声明的。函数的定义在另一个实现文件（lib_struct.c）中。

这是常见的方法吗？如果不是，如何才能以更好的方式设计它。