观察线程子类的以下定义(为方便起见,整个可运行的Java源文件包含在问题的末尾):
final class Worker extends Thread {
Foo[] array = new Foo[1024];
int sz;
public Worker(int _sz) {
sz = _sz;
}
public void run() {
//Foo[] arr = new Foo[1024];
Foo[] arr = array;
loop(arr);
}
public void loop(Foo[] arr) {
int i = 0;
int pos = 512;
Foo v = new Foo();
while (i < sz) {
if (i % 2 == 0) {
arr[pos] = v;
pos += 1;
} else {
pos -= 1;
v …从关于C++原子类型和操作的C++ 0x提议:
29.1顺序和一致性[atomics.order]
添加一个包含以下段落的新子句.
枚举
memory_order指定详细的常规(非原子)内存同步顺序,如[由N2334或其采用的后继者添加的新部分]中定义的,并且可以提供操作排序.其列举的值及其含义如下.
memory_order_relaxed该操作不会命令内存.
memory_order_release对受影响的内存位置执行释放操作,从而使常规内存写入通过应用它的原子变量对其他线程可见.
memory_order_acquire对受影响的内存位置执行获取操作,从而在通过应用它的原子变量释放的其他线程中进行常规内存写入,对当前线程可见.
memory_order_acq_rel该操作具有获取和释放语义.
memory_order_seq_cst该操作既具有获取和释放语义,另外,具有顺序一致的操作顺序.
提案中较低:
Run Code Online (Sandbox Code Playgroud)bool A::compare_swap( C& expected, C desired, memory_order success, memory_order failure ) volatile可以指定CAS的内存顺序.
我的理解是" memory_order_acq_rel"只需要同步操作所需的那些内存位置,而其他内存位置可能保持不同步(它不会表现为内存栅栏).
现在,我的问题是 - 如果我选择" memory_order_acq_rel"并应用于compare_swap整数类型,例如整数,这通常如何转换为现代消费者处理器(如多核英特尔i7)上的机器代码？那么其他常用的架构(x64,SPARC,ppc,arm)呢？
特别是(假设一个具体的编译器,比如说gcc):
acq_rel在i7 上使用语义是否有任何性能优势？其他架构呢？感谢所有的答案.
我尝试构建(可变和不可变)集合的列表.编译器遇到麻烦,因为它无法弄清楚该列表的类型.我一直认为我可以连接任何类型的列表,并且新列表的类型是连接列表的一种超类型.在以下示例中,我定义了一些列表.您可以看到编译器给出的那些列表的类型:
val intList = List(1) //List[Int]
val stringList = List("ab") //List[java.lang.String]
val mSetList = List(mutable.Set(1, 2, 3)) //List[scala.collection.mutable.Set[Int]]
val iSetList = List(immutable.Set(1, 2, 3)) //List[scala.collection.immutable.Set[Int]]
现在我使用:::运算符连接这些列表:
val intStringList = intList:::stringList //List[Any]
val intMSetList = intList:::mSetList //List[Any]
val intISetList = intList:::iSetList //List[Any]
正如所料,编译器计算List[Any]两个列表的公共超类型().但以下不编译:
val iSetmSetList = iSetList:::mSetList //type error
但是,如果我明确地"投射"这两个列表,它的工作原理是:
val setList1 : List[scala.collection.Set[Int]] = mSetList //List[scala.collection.Set[Int]]
val setList2 : List[scala.collection.Set[Int]] = iSetList // List[scala.collection.Set[Int]]
val setList = setList1:::setList2 //List[scala.collection.Set[Int]]
为什么我必须帮助编译器获取该列表的正确类型？为什么它会产生错误而不是简单地输入List[Any]？从理论上讲,计算类型List[scala.collection.Set[Int]]是不可能的,还是编译器中的一种错误？
非常感谢你的回答 :-)
工作区,我的意思是 - 我需要保存我的开放缓冲区的状态(可能在用户指定的工作区文件中)并快速切换到另一组打开缓冲区,例如继续处理与另一个项目相关的文件.
是否有允许这样的Emacs插件？你会推荐哪一个？
我有一个可能的输入值列表
val inputValues = List(1,2,3,4,5)
我有一个非常长的计算功能,给我一个结果
def reallyLongFunction( input: Int ) : Option[String] = { ..... }
使用scala并行集合,我可以很容易地做到
inputValues.par.map( reallyLongFunction( _ ) )
为了得到所有结果,并行.问题是,我真的不想要所有的结果,我只想要FIRST的结果.一旦我的一个输入成功,我想要我的输出,并希望继续我的生活.这做了很多额外的工作.
那么我如何才能充分利用这两个世界呢？我想要
编辑 - 我解决它就像一个愚蠢的java程序员一样
@volatile var done = false;
在我的内部设置和检查reallyLongFunction.这有效,但感觉不太scala.想要一个更好的方法来做到这一点....
我知道你可以将scala对象标记为@serializable,但我不明白之后如何处理该对象.我只是将其视为Java Serializable对象吗？
我想将对象序列化为字节流.有人能告诉我将序列化对象转换为字节数组或字符串的代码吗？
(谷歌对这个问题没有帮助)
关注:谢谢.我现在明白我可以像Java Serializable对象一样使用它.有时,明显的答案让我感到安慰.
我正在寻找一个良好的功能数据结构来存储空间(点)数据.数据结构应允许对已存在的点进行简单的epsilon查询.我还需要经常修改数据.这意味着点可以移动,并且应该能够在数据结构中更新.这可以使用普通的删除/添加来处理,但真正的移动可能会更快.
现在我正在考虑使用quad/oct-trees(或更高版本),因为移动部分应该很容易.然而,就平衡而言,已知四叉树更糟糕.KD-Trees可能是另一种选择,但更新似乎非常讨厌.我能找到的大多数空间数据结构实现只是程序性的,我使用的是函数式语言.
有没有办法在不使用调试器的情况下在JVM上获取当前作用域中的局部变量的映射或其他数据结构？也就是说,获取当前堆栈帧的本地？
我知道有堆栈跟踪对象,但StackTraceElement无法访问任何状态.它只是告诉你在哪里调用了哪种方法,而不是它里面的内容.
您将如何使用嵌入式机器代码(假设,例如,x86架构)在C中编写一个执行原子比较和交换整数值的函数？如果它仅针对i7处理器编写,它可以更具体吗？
翻译是作为内存栅栏,还是仅仅确保在比较和交换中包含的内存位置上的排序关系？与记忆围栏相比,它的成本是多少？
谢谢.
我可能在文档中遗漏了一些正确的东西,但我真的无法理解它 - 我一直在通过反复试验来自学Scala.
给定一个函数f: A => C,执行以下转换的惯用方法是什么？
Either[A, B] -> Either[C, B]
Either[B, A] -> Either[B, C]
(如果我有两个这样的功能并希望转换双方,我可以一次完成所有操作还是应该按顺序应用两次成语？)
Option[A] -> Option[C]
(我觉得这应该以for (...) yield某种方式使用;我可能只是在它上面消隐,当我看到答案时会感到愚蠢)
无论如何,究竟什么是"投射" Either呢？