11

我正在用 Scala 编写一个计算机图形应用程序，它使用 RGB 类返回图像中某个点的颜色。可以想象，返回颜色 RGB 对象的函数被多次调用。

class RGB(val red: Int, val green: Int, val blue: Int) { }

有一个函数 getPixelRGB 经常使用如下

val color:RGB = getPixelRGB(image, x, y)

问题是我可能会调用这个函数一百万次，然后我相信它会生成一百万个唯一的 RGB 对象实例，这是一个非常没有吸引力的情况。对此我有一些想法：

  1. 如果 getPixelRGB 被调用无数次，它可能会创建无限数量的对象，但它不一定是无限数量的对象，因为 RGB 最多只能生成 255 * 255 * 255 种可能的组合。所以创建的对象数量“应该”是有限的。可以调整此函数以使用对象池，如果它要返回与某个时间相同的颜色，则它可以返回该颜色的相同池对象实例。

  2. 我可以将此 RGB 编码为 Int。Int 的内存开销比普通的 Scala/Java 对象少，Java 对象有额外的内存开销。由于 Scala Int 类型是 4 个字节宽，前 3 个字节可以存储 RGB 值。我假设只从 getPixelRGB 方法返回 Int 而不是 RGB 会减少内存开销。但是，如何在仍然具有 RGB 类的说服力的同时做到这一点？

  3. 据说，它们是短命的对象，我已经读过垃圾收集器应该迅速回收它们。不过我还是很担心。GC 怎么知道我很快就把它扔掉了？如此混乱。

所以总的来说，我的问题是如何让这个 getPixelRGB 对内存更友好？我也应该担心吗？

4

5 回答 5

13

您可以使用单个 long或int对 RGB 进行编码。此外，在 scala 2.10 中，您可以为原始值定义值类，例如

class RGB private(val underlying: Long) extends AnyVal {
  def toTriple = /*decoding to (red, green, blue)*/
} 
object RGB {
  def apply(red: Int, green: Int, blue: Int) = /* encode and create class with new RGB(longvalue)*/
}

使用值类，您仍然可以拥有类型信息并享受 JVM 中的无类内存布局。

于 2012-11-30T13:48:11.380 回答
5

您的问题 #3 尚未解决，所以我会试一试。

GC 是如何知道我正在快速扔掉 [short living objects] 的？

现代 GC 的工作是基于对不同生命周期的对象的行为非常不同的观察。所以它在所谓的几代人中管理它们。刚刚创建的对象存储在eden空间中。当它填满时，其中仍然被引用的所有对象（即它们是活动的）都被复制到所谓的年轻代空间。因此，所有死物都被留下，它们占据的空间几乎是零努力地回收。这就是使短期对象对 JVM 来说如此便宜的原因。并且大多数由普通程序创建的对象都是临时变量或局部变量，它们很快就会超出范围。

在第一轮 GC 之后，以类似的方式管理年轻代空间，只是它们可能更多。GC 可以配置为让对象在年轻代空间中花费一轮或多轮。然后最终，最后的幸存者被迁移到幸存者（又名老一代）空间，他们将在那里度过余生。这个空间是通过定期应用经典标记和扫描的一些变体来管理的技术：遍历所有活动引用的图表并标记活动对象，然后通过将幸存者压缩成一个连续的内存块来清除所有未标记（死）的对象，从而对空闲内存进行碎片整理。这是一项昂贵的操作，会阻塞程序的执行，并且很难正确实现，尤其是在现代多线程 VM 中。这就是发明分代 GC 的原因，以确保创建的所有对象中只有一小部分能够到达这个阶段。

于 2012-11-30T14:11:57.110 回答
4

就内存友好性而言，最有效的解决方案是将完整的颜色信息存储在一个 Int 中。正如您正确提到的，颜色信息只需要三个字节，所以四个字节的 Int 就足够了。您可以使用位操作对来自一个 Int 的 RGB 信息进行编码和解码：

def toColorCode(r: Int, g: Int, b: Int) = r << 16 | g << 8 | b

def toRGB(code: Int): (Int, Int, Int) = (
  (code & 0xFF0000) >> 16, 
  (code & 0x00FF00) >> 8, 
  (code & 0x0000FF)
)
于 2012-11-30T13:47:48.010 回答
3

据说，它们是短命的对象，我已经读过垃圾收集器应该迅速回收它们。不过我还是很担心。GC 怎么知道我很快就把它扔掉了？如此混乱。

它不知道。它假设它。这被称为构建所有世代垃圾收集器的世代假设：

  • 几乎所有的物体都会英年早逝
  • 几乎没有旧对象包含对新对象的引用

满足这个假设的对象非常便宜（实际上甚至比Cmalloc等free语言更便宜），只有违反一个或两个假设的对象才是昂贵的。

于 2012-11-30T14:08:38.197 回答
1

您可以有一个返回简单Int. 然后，您可以在需要时使用隐式转换将 aInt视为RGB对象。

case class RBGInt(red: Int, green: Int, blue: Int) {
   // ...
}

object Conversions { 

  implicit def toRGBInt(p: Int) = {
    val (r, g, b) = /* some bitmanipulation to turn p into 3 ints */
    RGBInt(r, g, b)
  }

}

然后，您可以将 anyInt视为RGBInt您认为有意义的地方：

type RGB = Int // useful in documenting interfaces that consume
               // or returns Ints which represent RGBs

def getPixelRGB(img: Image, x: Int, y: Int): RGB = {
  // returns an Int
}

def someMethod(..) = {
  import Conversions._
  val px: RGB = getPixelRGB(...) // px is actually an Int
  px.red // px, an Int is lifted to an RGBInt
}
于 2012-11-30T13:39:29.377 回答