小编Mar*_*sco的帖子

许多人声称,GoF设计模式的最大部分只是缺少一流功能的解决方法.既然Java即将获得lambda表达式,那些模式中的哪些将受到它们的影响？哪些可以大大简化或推广？那些基本上会保持不变？欢迎任何实际的例子.

带阻塞和刷新的非阻塞并发队列

我需要一个无限制的非阻塞并发队列,基本上只有2个操作:

• offer:以原子方式将指定的项插入此队列的尾部;
• flush:获取队列中当时存在的所有项目,并按照插入顺序逐个处理它们.更具体地说,必须是原子的只是这个"takeAll"操作,这将是冲洗的第一次操作.在takeAll之后提供给队列的所有项目将被插入,然后仅由另一个后续刷新处理.

目标是消费者在takeAll上有一个CAS操作,然后可以迭代列表中的元素,而无需每次读取CAS操作.此外,我们已经拥有Node(Entry),因为这需要存储其他一些不可变状态.新节点可以将HEAD作为构造函数参数,创建单向链接列表.

文献中是否存在具有这些特征的队列？

我正在使用这个示例http://scala.sygneca.com/code/remoteactors来学习远程演员如何在Scala中工作(2.8.0).特别是我稍微修改了演员发送的消息如何定义如下:

sealed trait Event extends Serializable
case object Ping extends Event
case object Pong extends Event
case object Quit extends Event

一切都按预期工作.不幸的是,如果我将事件定义为案例类而不是案例对象,如:

sealed trait Event extends Serializable
case class Ping extends Event
case class Pong extends Event
case class Quit extends Event

我的例子停止工作.更详细地说,虽然case对象是可序列化的,但case类却不是.确实,当我尝试使用最后一次修改运行我的示例时,我得到以下异常:

scala.actors.remote.DelegateActor@148cc8c: caught java.io.NotSerializableException: scalachat.remote.Ping$
java.io.NotSerializableException: scalachat.remote.Ping$
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1156)
    at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:326)
    at scala.actors.remote.JavaSerializer.serialize(JavaSerializer.scala:46)
    at scala.actors.remote.NetKernel.namedSend(NetKernel.scala:38)
    at scala.actors.remote.NetKernel.forward(NetKernel.scala:71)
    at scala.actors.remote.DelegateActor$$anonfun$act$1$$anonfun$apply$1.apply(Proxy.scala:182)
    at scala.actors.remote.DelegateActor$$anonfun$act$1$$anonfun$apply$1.apply(Proxy.scala:123)
    at scala.actors.ReactorTask.run(ReactorTask.scala:34)
    at scala.actors.ReactorTask.compute(ReactorTask.scala:66)
    at scala.concurrent.forkjoin.RecursiveAction.exec(RecursiveAction.java:147)
    at scala.concurrent.forkjoin.ForkJoinTask.quietlyExec(ForkJoinTask.java:422)
    at scala.concurrent.forkjoin.ForkJoinWorkerThread.mainLoop(ForkJoinWorkerThread.java:340)
    at scala.concurrent.forkjoin.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:325)

是否有理由可以使case对象可序列化,而case类不能？有没有办法让我的例子使用案例类？

编辑:根据Victor的建议并由Aaron确认我将同伴对象作为消息而不是类发送.此外,使用javap检查已编译的代码,显然虽然该类是可序列化的:

public …

我有一个Scala元组列表,如下所示:

val l = List((1,2),(2,3),(3,4))

我希望将它映射到Int列表中,其中每个项目是相应元组中Ints的总和.我也不想使用x._1表示法,所以我用这样的模式匹配解决了问题

def addTuple(t: (Int, Int)) : Int = t match { 
    case (first, second) => first + second 
}
var r = l map addTuple

这样做我按预期获得了列表r:List [Int] = List(3,5,7).在这一点上,几乎是偶然的,我发现我可以使用如下的缩写形式获得相同的结果:

val r = l map {case(first, second) => first + second}

我在我的文档中找不到对此语法的任何引用.这是正常的吗？我错过了一些微不足道的事情吗？

在Scala中,当另一个(远程)actor终止时,可以通过设置trapExit标志并使用第二个actor作为参数调用link()方法来通知actor.在这种情况下,当远程actor通过调用exit()结束其作业时,通过接收Exit消息来通知第一个.

但是当远程actor以不太优雅的方式终止时(例如运行崩溃的VM)会发生什么？换句话说,本地演员如何发现远程演员不再可用？当然我更希望(如果可能的话)可以通过类似于Exit 1的消息通知本地actor,但似乎不可行.我错过了什么吗？我是否应该不断轮询远程参与者的状态(在这种情况下我不知道哪种方式最好)或者是否有更智能的解决方案？

我正在寻找替代方法以类型安全的方式获取属性名称.

例如,使用lambdaj,我可以这样做:

propertyName(on(Contract.class).getContractKey())

但这有点冗长,性能也不是很好.

我希望在构建期间生成一些东西.

Lamdbaj允许在Java语言中定义闭包,可以在这里找到各种示例

我的问题是关于使用的底层Java机制,例如,定义println闭包,使用以下代码:

Closure println = closure(); 
{ of(System.out).println(var(String.class)); }

随后可以通过以下方式执行此关闭:

println.apply("foobar");

我很好奇Java中的哪些机制允许调用of(...).println(...)与println实例本身相关联.

当然,lambdaj源代码可供阅读,但我希望有更高级别的解释,如果有人有一个.我的反思技巧可以动态地进行一些内省和执行方法.

我有一个异类List,如下所示:

val l = List(1, "One", true)

我需要通过仅提取属于给定类的对象来过滤其对象.为此我写了一个非常简单的方法:

def filterByClass[A](l: List[_], c: Class[A]) =
  l filter (_.asInstanceOf[AnyRef].getClass() == c)

请注意,我有义务将显式转换添加到AnyRef以避免此编译问题:

error: type mismatch;
found   : _$1 where type _$1
required: ?{val getClass(): ?}
Note that implicit conversions are not applicable because they are ambiguous:
both method any2stringadd in object Predef of type (x: Any)scala.runtime.StringAdd
and method any2ArrowAssoc in object Predef of type [A](x: A)ArrowAssoc[A]
are possible conversion functions from _$1 to ?{val getClass(): ?}
l filter (_.getClass() == c)

但是通过这种方式调用: …