[抽象工厂模式与具体工厂类关联性]的搜索结果

...现，其原理是使用装饰模式，对源类实例的操作和包装，其实际相当于我们在 Java中定义的工具类方法，并且该工具类方法是使用调用者为第一个参数的，然后在工具方法中操作该调用者 如： fun String?.toInt():  反编译为对应的Java代码： public  扩展属性 类的扩展属性原理其实与扩展方法是一样的，只是定义的形式不同，扩展属性必须定义get和set方法 为MutableList扩展一个firstElement属性: var  反编译后的java代码如下： public static final Object getFirstElement(@NotNull List $this$firstElement) { 内部类 kotlin的内部类与java的内部类有点不同java的内部类可以直接访问外部类的成员，kotlin的内部类不能直接访问外部类的成员，必须用inner标记之后才能访问外部类的成员 没有使用inner标记的内部类 class A{ 反编译后的java代码 public  用inner标记的内部类 class A{ 反编译后的java代码 public  从上面可以看出，没有使用inner标记的内部类最后生成的是静态内部类，而使用inner标记的生成的是非静态内部类 匿名内部类 匿名内部类主要是针对那些获取抽象类或者接口对象而来的。最常见的匿名内部类View点击事件： //java,匿名内部类的写法 上面这个是java匿名内部类的写法，kotlin没有new关键字，那么kotlin的匿名内部类该怎么写呢？ object : View.OnClickListener{ 方法的参数是一个匿名内部类，先写object:，然后写你的参数类型View.OnClickListener{} kotlin还有一个写法lambda 表达式，非常之方便： print( 数据类 在Java中没有专门的数据类，常常是通过JavaBean来作为数据类，但在Kotlin中提供了专门的数据类。 Java public  从上面的例子中可以看到，如果要使用数据类，需要手动写相应的setter/getter方法(尽管IDE也可以批量生成)，但是从代码阅读的角度来说，在属性较多的情况下，诸多的seeter/getter方法还是不利于代码的阅读和维护。 Kotlin 在Kotlin中，可以通过关键字data来生成数据类： data  即在class关键字之前添加data关键字即可。编译器会根据主构造函数中的参数生成相应的数据类。自动生成setter/getter、toString、hashCode等方法 要声明一个数据类，需要满足： 主构造函数中至少有一个参数 主构造函数中所有参数需要标记为val或var 数据类不能是抽象、开发、密封和内部的 枚举类 枚举类是一种特殊的类，kotlin可以通过enum class关键字定义枚举类。 枚举类可以实现0~N个接口； 枚举类默认继承于kotlin.Enum类(其他类最终父类都是Any)，因此kotlin枚举类不能继承类； 非抽象枚举类不能用open修饰符修饰，因此非抽象枚举类不能派生子类； 抽象枚举类不能使用abstract关键字修饰enum class，抽象方法和抽象属性需要使用； 枚举类构造器只能使用private修饰符修饰，若不指定，则默认为private； 枚举类所有实例在第一行显式列出，每个实例之间用逗号隔开，整个声明以分号结尾； 枚举类是特殊的类，也可以定义属性、方法、构造器； 枚举类应该设置成不可变类，即属性值不允许改变，这样更安全； 枚举属性设置成只读属性后，最好在构造器中为枚举类指定初始值，如果在声明时为枚举指定初始值，会导致所有枚举值(或者说枚举对象)的该属性都一样。 定义枚举类 /   定义一个枚举类  / 枚举类实现接口 枚举值分别实现接口的抽象成员 enum  枚举类统一实现接口的抽象成员 enum  分别实现抽象枚举类抽象成员 enum  委托 委托模式 是软件设计模式中的一项基本技巧。在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。委托模式是一项基本技巧，许多其他的模式，如状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式。委托模式使得我们可以用聚合来替代继承。 Java中委托： interface Printer { Kotlin： interface Printer { by表示 p 将会在 PrintImpl 中内部存储， 并且编译器将自动生成转发给 p 的所有 Printer 的方法。 委托属性 有一些常见的属性类型，虽然我们可以在每次需要的时候手动实现它们， 但是如果能够为大家把他们只实现一次并放入一个库会更好。例如包括： 延迟属性(lazy properties): 其值只在首次访问时计算； 可观察属性(observable properties): 监听器会收到有关此属性变更的通知； 把多个属性储存在一个映射(map)中，而不是每个存在单独的字段中。 为了涵盖这些(以及其他)情况，Kotlin 支持 委托属性 。 委托属性的语法是： var :  在 by 后面的表达式是该 委托， 因为属性对应的 get()(和 set())会被委托给它的 getValue() 和 setValue() 方法。 标准委托： Kotlin 标准库为几种有用的委托提供了工厂方法。 延迟属性 Lazy lazy() 接受一个 lambda 并返回一个 Lazy 实例的函数，返回的实例可以作为实现延迟属性的委托：第一次调用 get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果， 后续调用 get() 只是返回记录的结果。例如： val lazyValue: String  可观察属性 Observable Delegates.observable() 接受两个参数：初始值和修改时处理程序(handler)。每当我们给属性赋值时会调用该处理程序(在赋值后执行)。它有三个参数：被赋值的属性、旧值和新值： class User { 如果想拦截赋的新值，并根据你是不是想要这个值来决定是否给属性赋新值，可以使用 vetoable() 取代 observable()，接收的参数和 observable 一样，不过处理程序 返回值是 Boolean 来决定是否采用新值，即在属性被赋新值生效之前 会调用传递给 vetoable 的处理程序。例如： class User { 把属性存在map 中 一个常见的用例是在一个映射(map)里存储属性的值。这经常出现在像解析 JSON 或者做其他“动态”事情的应用中。在这种情况下，你可以使用映射实例自身作为委托来实现委托属性。 例如： class User(map: Map 在上例中，委托属性会从构造函数传入的map中取值(通过字符串键——属性的名称)，如果遇到声明的属性名在map 中找不到对应的key 名，或者key 对应的value 值的类型与声明的属性的类型不一致，会抛出异常。 内联函数 当一个函数被声明为inline时，它的函数体是内联的，也就是说，函数体会被直接替换到函数被调用地方 inline函数(内联函数)从概念上讲是编译器使用函数实现的真实代码来替换每一次的函数调用，带来的最直接的好处就是节省了函数调用的开销，而缺点就是增加了所生成字节码的尺寸。基于此，在代码量不是很大的情况下，我们是否有必要将所有的函数定义为内联？让我们分两种情况进行说明： 将普通函数定义为内联：众所周知，JVM内部已经实现了内联优化，它会在任何可以通过内联来提升性能的地方将函数调用内联化，并且相对于手动将普通函数定义为内联，通过JVM内联优化所生成的字节码，每个函数的实现只会出现一次，这样在保证减少运行时开销的同时，也没有增加字节码的尺寸；所以我们可以得出结论，对于普通函数，我们没有必要将其声明为内联函数，而是交给JVM自行优化。 将带有lambda参数的函数定义为内联：是的，这种情况下确实可以提高性能；但在使用的过程中，我们会发现它是有诸多限制的，让我们从下面的例子开始展开说明： inline  假如我们这样调用doSomething: fun main(args: Array<String>) { 上面的调用会被编译成： fun main(args: Array<String>) { 从上面编译的结果可以看出，无论doSomething函数还是action参数都被内联了，很棒，那让我们换一种调用方式： fun main(args: Array<String>) { 上面的调用会被编译成： fun main(args: Array<String>) { doSomething函数被内联，而action参数没有被内联，这是因为以函数型变量的形式传递给doSomething的lambda在函数的调用点是不可用的，只有等到doSomething被内联后，该lambda才可以正常使用。 通过上面的例子，我们对lambda表达式何时被内联做一下简单的总结： 当lambda表达式以参数的形式直接传递给内联函数，那么lambda表达式的代码会被直接替换到最终生成的代码中。 当lambda表达式在某个地方被保存起来，然后以变量形式传递给内联函数，那么此时的lambda表达式的代码将不会被内联。 上面对lambda的内联时机进行了讨论，消化片刻后让我们再看最后一个例子： inline  上面的例子是否有问题？是的，编译器会抛出“Illegal usage of inline-parameter”的错误，这是因为Kotlin规定内联函数中的lambda参数只能被直接调用或者传递给另外一个内联函数，除此之外不能作为他用；那我们如果确实想要将某一个lambda传递给一个非内联函数怎么办？我们只需将上述代码这样改造即可： inline  很简单，在不需要内联的lambda参数前加上noinline修饰符就可以了。 以上便是我对内联函数的全部理解，通过掌握该特性的运行机制，相信大家可以做到在正确的时机使用该特性，而非滥用或因恐惧弃而不用。 Kotlin下单例模式 饿汉式实现 //Java实现 懒汉式 //Java实现 上述代码中，我们可以发现在Kotlin实现中，我们让其主构造函数私有化并自定义了其属性访问器，其余内容大同小异。 如果有小伙伴不清楚Kotlin构造函数的使用方式。请点击 - - - 构造函数 不清楚Kotlin的属性与访问器，请点击 - - -属性和字段 线程安全的懒汉式 //Java实现 大家都知道在使用懒汉式会出现线程安全的问题，需要使用使用同步锁，在Kotlin中，如果你需要将方法声明为同步，需要添加@Synchronized注解。 双重校验锁式 //Java实现 哇！小伙伴们惊喜不，感不感动啊。我们居然几行代码就实现了多行的Java代码。其中我们运用到了Kotlin的延迟属性 Lazy。 Lazy内部实现 public  观察上述代码，因为我们传入的mode = LazyThreadSafetyMode.SYNCHRONIZED， 那么会直接走 SynchronizedLazyImpl，我们继续观察SynchronizedLazyImpl。 Lazy接口 SynchronizedLazyImpl实现了Lazy接口，Lazy具体接口如下： public  继续查看SynchronizedLazyImpl，具体实现如下： SynchronizedLazyImpl内部实现 private  通过上述代码，我们发现 SynchronizedLazyImpl 覆盖了Lazy接口的value属性，并且重新了其属性访问器。其具体逻辑与Java的双重检验是类似的。 到里这里其实大家还是肯定有疑问，我这里只是实例化了SynchronizedLazyImpl对象，并没有进行值的获取，它是怎么拿到高阶函数的返回值呢？。这里又涉及到了委托属性。 委托属性语法是：val/var : by 。在 by 后面的表达式是该 委托， 因为属性对应的 get()(和 set())会被委托给它的 getValue() 和 setValue() 方法。属性的委托不必实现任何的接口，但是需要提供一个 getValue() 函数(和 setValue()——对于 var 属性)。 而Lazy.kt文件中，声明了Lazy接口的getValue扩展函数。故在最终赋值的时候会调用该方法。 internal.InlineOnly 静态内部类式 //Java实现 静态内部类的实现方式，也没有什么好说的。Kotlin与Java实现基本雷同。 补充 在该篇文章结束后，有很多小伙伴咨询，如何在Kotlin版的Double Check，给单例添加一个属性，这里我给大家提供了一个实现的方式。(不好意思，最近才抽出时间来解决这个问题) class SingletonDemo private constructor( 其中关于?:操作符，如果 ?: 左侧表达式非空，就返回其左侧表达式，否则返回右侧表达式。请注意，当且仅当左侧为空时，才会对右侧表达式求值。 Kotlin 智能类型转换 对于子父类之间的类型转换 先看这样一段 Java 代码 public  尽管在 main 函数中，对 person 这个对象进行了类型判断，但是在使用的时候还是需要强制转换成 Student 类型，这样是不是很不智能？ 同样的情况在 Kotlin 中就变得简单多了 fun main(args: Array<String>) { 在 Kotlin 中，只要对类型进行了判断，就可以直接通过父类的对象去调用子类的函数了 安全的类型转换 还是上面的那个例子，如果我们没有进行类型判断，并且直接进行强转，会怎么样呢？ public static void main(String[] args) { 结果就只能是 Exception in thread "main" java.lang.ClassCastException 那么在 Kotlin 中是不是会有更好的解决方法呢？ val person: Person = Person() 在转换操作符后面添加一个 ?，就不会把程序 crash 掉了，当转化失败的时候，就会返回一个 null 在空类型中的智能转换 需要提前了解 Kotlin 类型安全的相关知识(Kotlin 中的类型安全(对空指针的优化处理)) String? =  aString 在定义的时候定义成了有可能为 null，按照之前的写法，我们需要这样写 String? =  但是已经进行了是否为 String 类型的判断，所以就一定 不是 空类型了，也就可以直接输出它的长度了 T.()->Unit 、 ()->Unit 在做kotlin开发中，经常看到一些系统函数里，用函数作为参数 public  .()-Unit与()->Unit的区别是我们调用时，在代码块里面写this，的时候，两个this代表的含义不一样，T.()->Unit里的this代表的是自身实例，而()->Unit里，this代表的是外部类的实例。 推荐阅读 对 Kotlin 与 Java 编程语言的思考 使用 Kotlin 做开发一个月后的感想 扫一扫 关注我的公众号如果你想要跟大家分享你的文章，欢迎投稿~ 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_39611037/article/details/109984124。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...项目中更好地应用设计模式，如工厂模式、策略模式等，结合泛型实现更高程度的解耦和复用。在这些场景下，泛型T扮演的角色不仅仅是类型安全的保证，更是提高程序设计抽象层次的关键工具。 另一方面，尽管Object类作为所有Java类的基类在处理多态问题时展现出强大的灵活性，但在大型项目或框架设计中，过度依赖Object可能导致类型混乱，影响代码质量。因此，一些现代框架（如Spring Framework）在设计之初就充分考虑了类型安全性，巧妙地融合了泛型与特定类型转换机制，从而在保持灵活性的同时，也兼顾了编译时期的类型检查。 综上所述，随着Java语言的发展和社区实践的积累，泛型T与Object类的关系及其在不同类型安全策略中的运用愈发值得我们关注和深思。开发者应当根据具体业务需求，适时选择并合理搭配使用这两种机制，以提升代码质量和开发效率。

...相应内容。 使用简单工厂模式设计一个可以创建不同几何图形（Shape），如Circle，Rectangle，Triangle等绘图工具类，每个几何图形均具有绘制Draw()和擦除Erase()两个方法；要求在绘制不支持的几何图形时，抛出一个UnsuppShapeException异常，绘制类图并使用Java语言实现。 / Description: 抽象产品角色 / public abstract class Shape { public abstract void draw(); public abstract void erase(); }/ Description: 具体产品角色 /public class Round extends Shape { @Override public void draw() { System.out.println("绘制圆形"); } @Override public void erase() { System.out.println("擦除圆形"); } } public class Square extends Shape { @Override public void draw() { System.out.println("绘制方形"); } @Override public void erase() { System.out.println("擦除方形"); } } public class Triangle extends Shape { @Override public void draw() { System.out.println("绘制三角形"); } @Override public void erase() { System.out.println("擦除三角形"); } }/ Description: 工厂角色 / public class ShapeFactory { // 声明创建形状的静态工厂方法 public static Shape createShape(String type) throws UnSupportedShapeException { Shape shape; if ("圆形".equals(type)) { shape = new Round(); } else if ("方形".equals(type)) {shape = new Square(); } else if ("三角形".equals(type)) { shape = new Triangle(); } else { throw new UnSupportedShapeException("UnSupportedShapeException"); } return shape;} } / Description: 自定义异常 / public class UnSupportedShapeException extends Exception { public UnSupportedShapeException(String message) { super(message); } }/ Description: 客户端 / public class DrawingTool { public static void main(String[] args) { Shape s1, s2, s3, s4; try { s1 = ShapeFactory.createShape("圆形"); s2 = ShapeFactory.createShape("方形"); s3 = ShapeFactory.createShape("三角形"); s1.draw(); s1.erase(); s2.draw(); s2.erase(); s3.draw(); s3.erase(); // s4.draw(); // s4.erase(); } catch (Exception e) { System.out.println(e.getMessage()); } } } 本篇文章为转载内容。原文链接：https://blog.csdn.net/Luoxiaobaia/article/details/120300797。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...L标准定义的一个虚拟模式，它提供关于数据库中所有表的信息，包括其结构、约束等元数据。其中的columns表存储了各个表的具体列信息，如列名、数据类型等。在本文中，通过查询information_schema.columns可以检查指定表中某个字段的实际数据类型是否符合预期，进而避免或解决InvalidColumnTypeCastError错误。 数据模型 , 在数据库设计领域，数据模型是对现实世界数据的抽象表达，用于描述数据的结构、属性以及数据间的关系。文中提到，在处理InvalidColumnTypeCastError问题时，有时需要修改数据模型，这意味着可能需要重新审视和调整数据库表的设计、字段的数据类型设定以及它们之间的关联关系，以适应业务逻辑的需求并防止类型转换错误的发生。

...ory和配置相关的工厂类协同工作，共同实现了插件化工具窗口的功能展现与交互逻辑。 ToolWindow , 在IntelliJ IDEA或其他集成开发环境（IDE）中，ToolWindow是一种特殊的窗口类型，通常位于主编辑区的侧面或底部，用以提供辅助功能或工具集。例如，在本文提到的场景下，ScrcpyController界面就是通过ScrcpyToolWindowFactory整合到IDEA的ToolWindow区域进行展示，方便开发者在编写代码的同时操作相关工具。 工厂类（Factory Class） , 在面向对象编程中，工厂类是一种设计模式，它封装了对象的创建过程，使得系统中的其他部分无需了解对象的具体创建细节。在本文所描述的Java GUI开发过程中，ScrcpyToolWindowFactory和ScrcpyControllerConfigurable都是工厂类的例子，它们分别负责将界面组件加载至ToolWindow中以及设置界面与实际业务逻辑的绑定，隐藏了具体的创建步骤，提高了代码的可维护性和复用性。

...类型和特性等方式，将抽象的业务逻辑转化为具体的数据模型，以支持更高效、精准的数据分析和报表生成。

...样。"auto"这个模式就比较智能了，它让系统自动判断并决定滚动条啥时候该出现、啥时候该滚动，一切都交给系统自己做主。而"momentum"这个设定就更有意思啦，就像是滚动条有了自己的“冲劲儿”，一旦滚动起来就会保持一定的速度滑动下去，有点像物理中的惯性滚动效果~ 所以，如果我们想要在iOS设备上正常显示overflow-x:auto的滚动条，就需要同时满足两个条件： 1. 设置overflow-x:auto 2. 使用-webkit-overflow-scrolling:touch样式属性 三、代码示例 接下来，我们就来看几个具体的例子，分别演示如何在不同的情况下使用这两个属性。 首先是不设置-webkit-overflow-scrolling:touch的情况： html 1 2 3 4 5 6 7 8 9 10 11 12 这段代码会在一个200px宽的div中创建一个表格，表格的每列都有四个单元格，这样当表格内容超出宽度时，就会出现滚动条。 然后是只设置了-webkit-overflow-scrolling:touch的情况： html 1 2 3 4 5 6 7 8 9 10 11 12 这段代码与上面的例子基本相同，只是多了一个-webkit-overflow-scrolling:touch样式属性。 最后是同时设置了overflow-x:auto和-webkit-overflow-scrolling:touch的情况： html 1 2 3 4 5

...定类型，但我并不关心具体是什么类型”的方式。这就像是我们平时做事，甭管具体的“家伙”是个啥类型，只要它能按照约定的方式工作，或是满足我们设定的条件，我们就能轻松对付。就拿生活中来说吧，你不需要知道手里的遥控器是什么牌子什么型号，只要你明白它是用来控制电视的，按对了按钮就能达到目的，这就是所谓的“只关注实现的接口或满足的条件”，而不是纠结于它的具体身份。 想象一下，你是一个动物园管理员，你知道每种动物都有一个eat的行为，但并不需要确切知道它们是狮子、老虎还是熊猫。在Scala的世界里，这就对应于存在类型的概念。 scala trait Eater { def eat(food: String): Unit } val animal: Eater forSome { type T } = new Animal() { def eat(food: String) = println(s"Animal is eating $food") } 上述代码中，Eater forSome { type T }就是一个存在类型，我们只知道animal实现了Eater特质，而无需关心其具体的类型信息。 2. 存在类型的语法与理解 在Scala中，存在类型的语法形式通常表现为Type forSome { TypeBounds }。这里的TypeBounds是对未知类型的一种约束或定义，可以是特质、类或其他类型参数。 例如： scala val list: List[T] forSome { type T <: AnyRef } = List("Apple", "Banana") list.foreach(println) 在这个例子中，我们声明了一个列表list，它的元素类型T满足AnyRef（所有引用类型的超类）的下界约束，但我们并不知道T具体是什么类型，只知道它可以安全地传递给println函数。 3. 存在类型的实用场景 存在类型在实际编程中主要用于泛型容器的返回和匿名类型表达。特别是在捣鼓API设计的时候，当你想把那些复杂的实现细节藏起来，只亮出真正需要的接口给大伙儿用，这时候类型的作用就凸显出来了，简直不能更实用了。 例如，假设我们有一个工厂方法，它根据配置创建并返回不同类型的数据库连接： scala trait DatabaseConnection { def connect(): Unit def disconnect(): Unit } def createDatabaseConnection(config: Config): DatabaseConnection forSome { type T <: DatabaseConnection } = { // 根据config创建并返回一个具体的DatabaseConnection实现 // ... val connection: T = ... // 假设这里已经创建了某个具体类型的数据库连接 connection } val connection = createDatabaseConnection(myConfig) connection.connect() connection.disconnect() 在这里，使用者只需要知道createDatabaseConnection返回的是某种实现了DatabaseConnection接口的对象，而不必关心具体的实现类。 4. 对存在类型的思考与探讨 存在类型虽然强大，但使用时也需要谨慎。要是老这么使劲儿用，可能会把一些类型信息给整没了，这样一来，编译器就像个近视眼没戴眼镜，查不出代码里所有的类型毛病。这下可好，代码不仅读起来费劲多了，安全性也大打折扣，就像你走在满是坑洼的路上，一不小心就可能摔跟头。同时，对于过于复杂的类型系统，理解和调试也可能变得困难。 总的来说，Scala的存在类型就像是编程世界里的“薛定谔的猫”，它的具体类型取决于运行时的状态，这为我们提供了更加灵活的设计空间，但同时也要求我们具备更深厚的类型系统理解和良好的抽象思维能力。所以在实际动手开发的时候，咱们得看情况灵活应变，像聪明的狐狸一样权衡这个高级特性的优缺点，找准时机恰到好处地用起来。

... 如何在C中实现工厂模式的变体，如抽象工厂？ 在软件开发领域，设计模式是解决特定问题时的一套标准化解决方案。其中，工厂模式是一种常用的创建型设计模式，用于提供创建一组相关或相互依赖对象的接口，而无需指定它们具体的类。本文将深入探讨如何在C中实现一种工厂模式的变体——抽象工厂模式，并通过实例代码来展示其应用。 1. 理解工厂模式与抽象工厂模式 - 工厂模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。该模式使一个类的实例化延迟到其子类。 - 抽象工厂模式：是一种更高级的工厂模式，它提供一个接口来创建一系列相关或相互依赖的对象，而无需指定它们具体的类。哎呀，抽象工厂模式这东西，就像是做蛋糕的魔法配方。你先设定一个大框架，比如你想做一个蛋糕，但具体是巧克力口味的、草莓口味的还是抹茶口味的，这些细节就留给你的烘焙师去发挥吧。他们按照你的大框架，创造出你想要的美味蛋糕。这样，你就不用每次做蛋糕都从头开始设计每一步，而是把重点放在整体的规划上，剩下的交给专业的人去做。这样不仅高效，还能保证品质！ 2. 设计抽象工厂模式的基本结构 在C中实现抽象工厂模式的第一步是定义一个抽象工厂类和一系列具体工厂类。抽象工厂类会声明一系列方法，这些方法用于创建不同类族的对象，而具体工厂类则实现这些方法，根据需求创建特定的类族对象。 csharp // 抽象工厂接口 public interface IProductFactory { IPerson CreatePerson(); ICar CreateCar(); } // 具体产品接口（这里只是示意，实际项目中可能涉及复杂的接口） public interface IPerson { void Drive(ICar car); } public interface ICar { void Start(); } // 具体工厂类 public class PersonFactory : IProductFactory { public IPerson CreatePerson() { return new Person(); } public ICar CreateCar() { return new Car(); } } // 具体产品实现 public class Person : IPerson { public void Drive(ICar car) { Console.WriteLine("Driving with " + car); } } public class Car : ICar { public void Start() { Console.WriteLine("Starting the engine"); } } 3. 应用抽象工厂模式的场景 抽象工厂模式在需要创建多个相关产品的场景中特别有用，例如构建一个汽车生产线系统，系统需要根据不同的需求（如客户偏好、市场趋势）生成不同的车型组合，同时确保所有组件之间的兼容性和一致性。 csharp public class MainProgram { static void Main(string[] args) { var factory = new PersonFactory(); var person = factory.CreatePerson(); var car = factory.CreateCar(); person.Drive(car); // 如果需要，可以引入更多的工厂和产品来扩展功能 // 比如：ElectricCarFactory, SportsCarFactory等 } } 4. 总结与思考 抽象工厂模式提供了强大的灵活性和可扩展性，允许开发者在不修改现有代码的情况下，轻松地添加新的产品家族或改变现有产品的实现方式。这种模式特别适合于构建大型软件系统，尤其是那些需要高度定制化和复杂交互的产品线。 通过以上示例，我们不仅展示了如何在C中实现抽象工厂模式，还探讨了其在实际开发中的应用场景。哎呀，你懂的，抽象工厂模式这招儿啊，它就像个魔法师一样，让代码变得超好用，还特别容易改，而且呢，咱们想加点新功能进去，也不用担心会乱成一锅粥。就像是在做蛋糕，你有现成的配方，换上不同的配料，就能做出各种口味的蛋糕来，既方便又高效。所以，用上这个模式，咱的程序不仅更灵活，还省心多了！在未来的开发中，考虑使用抽象工厂模式可以帮助我们构建更加灵活和健壮的软件架构。

...服务架构和云原生开发模式的普及，Spring Boot与Hibernate的整合使用也成为了热门话题。Spring Data JPA作为Spring Boot生态中的重要组件，基于Hibernate实现了更加便捷的对象关系映射操作，并通过其Repository模式简化了数据访问层的设计与实现，大大提高了开发效率。 此外，在实际项目中如何合理运用Hibernate进行数据库设计和性能调优，也是值得深入研究的内容。例如，结合具体的业务场景，灵活调整缓存策略，或者利用Hibernate的批处理功能来提升大批量数据插入或更新时的性能，都是极具价值的实战技巧。 总之， Hibernate ORM不仅仅是一个基础工具，更是现代软件工程中解决对象-关系映射问题的关键技术手段。持续跟踪该领域的最新研究成果和技术实践，将有助于我们构建更为高效、稳定且易于维护的应用系统。

...其Service资源抽象和kube-proxy组件实现对集群中运行的Pod服务的寻址和访问。 Pod , 在Kubernetes环境中，Pod是最小的可部署计算单元，它是容器的载体，可以包含一个或多个紧密相关的容器应用实例，共享网络命名空间、存储卷以及其他资源。文中提到Pod作为Kubernetes世界里的最小服务单位，代表着执行特定任务的应用实例。 Service资源 , 在Kubernetes中，Service是一种抽象资源对象，它定义了一种访问一组具有相同功能Pod的方式。通过标签选择器将后端的一组Pod绑定到Service，并为这些Pod提供一个稳定的网络入口点（ClusterIP）。当客户端向这个ClusterIP发起请求时，kube-proxy会根据配置将流量负载均衡地转发到各个关联的Pod。 kube-proxy , kube-proxy是Kubernetes集群中的核心组件之一，它负责实现集群内部的服务代理和负载均衡功能。kube-proxy可以根据配置的不同模式（如iptables、IPVS等），动态更新网络规则，确保请求能够正确地从Service的ClusterIP地址路由至对应Pod的实际端口上。 DNS服务发现 , 在Kubernetes集群中，DNS服务发现是指系统集成了DNS服务器，使得服务可以通过域名而不是直接的IP地址进行寻址。每个创建的Service都会自动获得一个DNS记录，格式为service-name.svc.cluster.local。应用程序只需知道服务名，就可以利用内建的DNS系统解析出服务的具体访问地址，简化了服务间的调用过程并提高了易用性。

...用了声明式路由和中介模式这种聪明的办法，轻轻松松就把不同系统间的沟通难题给简化了，让它们能无缝对接、愉快交流。当ActiveMQ和Camel联手的时候，咱们就能打造出既牛叉又方便维护的消息驱动应用，那可真是如虎添翼，让程序猿们省心不少。本文将深入探讨如何在Camel中集成并充分利用ActiveMQ。 2. ActiveMQ简介 ActiveMQ是一款全面支持JMS（Java Message Service）规范的消息中间件，可实现跨平台、异步、可靠的消息传递。它的最大亮点就是超级稳定、能够巧妙地分配任务负荷，还有对多种通讯协议的全面支持，像是AMQP、STOMP、MQTT这些，样样精通。 java // 创建ActiveMQ连接工厂 ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616"); // 从连接工厂创建连接 Connection connection = factory.createConnection(); connection.start(); // 创建会话 Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); // 创建目标队列 Destination destination = session.createQueue("MyQueue"); // 创建生产者 MessageProducer producer = session.createProducer(destination); // 创建并发送消息 TextMessage message = session.createTextMessage("Hello from ActiveMQ!"); producer.send(message); 上述代码展示了如何使用Java API创建一个简单的ActiveMQ生产者，向名为"MyQueue"的队列发送一条消息。 3. Camel与ActiveMQ的集成 Apache Camel通过提供丰富的组件库来简化集成任务，其中当然也包含了对ActiveMQ的出色支持。使用Camel-ActiveMQ这个小玩意儿，我们就能轻轻松松地在Camel的路由规则里头，用ActiveMQ来发送和接收消息，就像玩儿一样简单！ java from("timer:tick?period=5000") // 每5秒触发一次 .setBody(constant("Hello Camel with ActiveMQ!")) .to("activemq:queue:MyQueue"); // 将消息发送到ActiveMQ队列 from("activemq:queue:MyQueue") // 从ActiveMQ队列消费消息 .log("Received message: ${body}") .to("mock:result"); // 将消息转发至Mock endpoint用于测试 这段Camel路由配置清晰地展现了如何通过Camel定时器触发消息产生，并将其发送至ActiveMQ队列，同时又设置了一个消费者从该队列中拉取消息并打印处理。 4. Camel集成ActiveMQ的优势及应用场景 通过Camel与ActiveMQ的集成，开发者可以利用Camel的强大路由能力，实现复杂的消息流转逻辑，如内容过滤、转换、分发等。此外，Camel还提供了健壮的错误处理机制，使得整个消息流更具鲁棒性。 例如，在微服务架构下，多个服务间的数据同步、事件通知等问题可以通过ActiveMQ与Camel的结合得到优雅解决。当某个服务干完活儿，处理完了业务，它只需要轻轻松松地把结果信息发布到特定的那个“消息主题”或者“队列”里头。这样一来，其他那些有关联的服务就能像订报纸一样，实时获取到这些新鲜出炉的信息。这就像是大家各忙各的，但又能及时知道彼此的工作进展，既解耦了服务之间的紧密依赖，又实现了异步通信，让整个系统运行得更加灵活、高效。 5. 结语 总的来说，Apache Camel与ActiveMQ的集成极大地扩展了消息驱动系统的可能性，赋予开发者以更高层次的抽象去设计和实现复杂的集成场景。这种联手合作的方式，就像两个超级英雄组队，让整个系统变得身手更加矫健、灵活多变，而且还能够随需应变地扩展升级。这样一来，咱们每天的开发工作简直像是坐上了火箭，效率嗖嗖往上升，维护成本也像滑梯一样唰唰降低，真是省时省力又省心呐！当我们面对大规模、多组件的分布式系统时，不妨尝试借助于Camel和ActiveMQ的力量，让消息传递变得更简单、更强大。

...个逻辑分区。 LBA模式 , LBA（Logical Block Addressing）模式是一种磁盘寻址方式，它允许操作系统以连续的逻辑区块号访问硬盘，而非传统的CHS地址模式（柱面-磁头-扇区）。在文章中提到的Win95 FAT32(LBA)格式就是采用LBA模式来支持大容量硬盘的分区格式。 mount命令 , mount命令在Linux系统中用于挂载文件系统，即将某个分区或存储设备与Linux目录结构中的某个挂载点关联起来，使得用户能够通过该挂载点访问该分区或设备上的文件。 vfat文件系统 , vfat是Windows系统下FAT32文件系统的Linux内核实现，它支持长文件名等功能，并且能够在Linux系统中兼容读写Windows格式化的FAT32分区。在文章中，/dev/hda1分区被识别为vfat类型，因此可以使用mount命令将其挂载至Linux的一个目录中。

...进行，而非直接绑定到具体的Pod实例，这就确保了当Pod发生故障或滚动更新时，上层服务无需关心具体实现细节，只需对接口进行调用，真正体现了“抽象不应该依赖细节，细节应该依赖抽象”的原则。 同时，业界对于设计模式的研究也在不断深入，如策略模式、工厂方法模式等都充分运用了面向接口编程的理念，通过阅读相关的设计模式书籍如《设计模式：可复用面向对象软件的基础》等，可以帮助我们更深入地理解和掌握这一编程范式，并将其灵活运用于解决实际问题中。 总之，面向接口编程不仅是一种编程技术，更是现代软件工程领域的重要理念。随着技术的发展和需求的变化，它将继续在提高代码质量、降低系统复杂性和增强扩展性等方面发挥关键作用。紧跟行业动态，结合经典理论与实战经验，将有助于我们在日常开发中更好地运用面向接口编程的原则和技术。

...，并在恰当时候恢复。具体在何时恢复，由 yield 的返回值决定。 启动协程，必须使用 MonoBehaviour 的 StartCoroutine 方法。 停止协程，可以使用 MonoBehaviour 的 StopCoroutine 方法 或 StopAllCoroutine 方法。 注意：以下情况也可能使协程停止： 1)、销毁启动协程的组件（GameObject.Destory(component);） ==> 协程停止 2)、禁用启动协程的组件（component.enabled = false;）==> 协程不停止 3)、销毁启动协程的组件所在的物体（GameObject.Destory(gameobject);） ==> 协程停止 4)、隐藏启动协程的组件所在的物体（gameobject.SetActive(false);） ==> 协程停止 2、MonoBehaviour.StartCoroutine StartCoroutine 方法总是立刻返回一个 Coroutine 对象（同步返回）。 无法保证协同程序按其启动顺序结束，即使他们在同一帧中完成也是如此（异步无序完成）。 可以在一个协程中启动另一个协程（支持协程嵌套）。 二、Unity中的 yield 语句类型 1、yield break; //打断协程运行 2、yield return null; //挂起协程，并从下一帧继续 3、yield return + “任意数字”; //挂起协程，并从下一帧继续 4、yield return + “bool值”; //挂起协程，并从下一帧继续 5、yield return + “任意字符串”; //挂起协程，并从下一帧继续 6、yield return + “普通Object”; //挂起协程，并从下一帧继续 7、yield return + “任意实现了 IEnumerator 接口的对象”。重要！（可嵌套） Unity 中，常见的、直接或间接实现了 IEnumerator 接口的类有： ------------------------------------------------------------------------------------------------ CustomYieldInstruction (abstarct) ——|> IEnumerator (interface) ------------------------------------------------------------------------------------------------ WaitUnitil (sealed) ——|> CustomYieldInstruction WaitWhile (sealed) ——|> CustomYieldInstruction WaitForSecondsRealtime (非sealed，但未发现子类) ——|> CustomYieldInstruction WWW (非sealed，但未发现子类) ——|> CustomYieldInstruction ------------------------------------------------------------------------------------------------ 随着Unity更新或在一些可选的Package中，可能有更多。。。 ------------------------------------------------------------------------------------------------ 8、yield return + “任意继承了 YieldInstruction 类 ([UsedByNativeCode]，源码C层中无具体实现) 的对象”。重要！（可嵌套） Unity 中，常见的、直接或间接继承了 YieldInstruction 类的类有： ------------------------------------------------------------------------------------------------ WaitForSeconds (sealed) ——|> YieldInstruction Coroutine (sealed) ——|> YieldInstruction (Coroutine 是 StartCoroutine方法的返回值，意味着协程中可嵌套协程) WaitForEndOfFrame (sealed) ——|> YieldInstruction WaitForFixedUpdate (sealed) ——|> YieldInstruction AsyncOperation ——|> YieldInstruction ------------------------------------------------------------------------------------------------ AssetBundleCreateRequest (非sealed，但未发现子类) ——|> AsyncOperation AssetBundleRecompressOperation (非sealed，但未发现子类) ——|> AsyncOperation AssetBundleRequest (非sealed，但未发现子类) ——|> AsyncOperation ResourceRequest (非sealed，但未发现子类) ——|> AsyncOperation UnityEngine.Networking.UnityWebRequestAsyncOperation (非sealed，但未发现子类) ——|> AsyncOperation UnityEngine.iOS.OnDemandResourcesRequest (sealed) ——|> AsyncOperation ------------------------------------------------------------------------------------------------ 随着Unity更新或在一些可选的Package中，可能有更多。。。 ------------------------------------------------------------------------------------------------ 测试验证 第2、3、4、5、6条 如下： using System.Collections;using UnityEngine;public class Test : MonoBehaviour{void Start(){StartCoroutine(Func1());}IEnumerator Func1(){Debug.Log("Time.frameCount: " + Time.frameCount);yield return null;Debug.Log("Time.frameCount: " + Time.frameCount);yield return 0;Debug.Log("Time.frameCount: " + Time.frameCount);yield return 1;Debug.Log("Time.frameCount: " + Time.frameCount);yield return 99; //其他整数Debug.Log("Time.frameCount: " + Time.frameCount);yield return 0.5f; //浮点数值Debug.Log("Time.frameCount: " + Time.frameCount);yield return false; //bool值Debug.Log("Time.frameCount: " + Time.frameCount);yield return "Hi NRatel!"; //字符串Debug.Log("Time.frameCount: " + Time.frameCount);yield return new Object(); //任意对象Debug.Log("Time.frameCount: " + Time.frameCount);} } 测试验证 第7条 如下： using System.Collections;using UnityEngine;public class Test : MonoBehaviour{void Start(){StartCoroutine(Func1());}IEnumerator Func1(){Debug.Log("Func1");yield return Func2();}IEnumerator Func2(){Debug.Log("Func2");yield return Func3();}IEnumerator Func3(){Debug.Log("Func3");yield return null;} } 三、Unity协程实现原理 1、C 的迭代器。 现在已经知道：协程肯定与IEnumerator有关，因为启动协程时需要一个 IEnumerator 对象。 而 IEnumerator 是C实现的 迭代器模式 中的 枚举器（用于迭代的游标）。 迭代器相关接口定义如下： namespace System.Collections{//可枚举（可迭代）对象接口public interface IEnumerable{IEnumerator GetEnumerator();}//迭代游标接口public interface IEnumerator{object Current { get; }bool MoveNext();void Reset();} } 参考 MSDN C文档中对于 IEnumerator、IEnumerable、迭代器 的描述。 利用 IEnumerator 对象，可以对与之关联的 IEnumerable 集合 进行迭代： 1)、通过 IEnumerator 的 Current 方法，可以获取集合中位于枚举数当前位置的元素。 2)、通过 IEnumerator 的 MoveNext 方法，可以将枚举数推进到集合的下一个元素。如果 MoveNext 越过集合的末尾, 则枚举器将定位在集合中最后一个元素之后, 同时 MoveNext 返回 false。 当枚举器位于此位置时, 对 MoveNext 的后续调用也将返回 false 。如果最后一次调用 MoveNext 时返回 false，则 Current 未定义（结果为null）。 3)、通过 IEnumerator 的 Reset 方法，可以将“迭代游标” 设置为其初始位置，该位置位于集合中第一个元素之前。 2、C 的 yield 关键字。 C编译器在生成IL代码时，会将一个返回值类型为 IEnumerator 的方法（其中包含一系列的 yield return 语句），构建为一个实现了 IEnumerator 接口的对象。 注意，yield 是C的关键字，而非Unity定义！IEnumerator 对象 也可以直接用于迭代，并非只能被Unity的 StartCoroutine 使用！ using System.Collections;using UnityEngine;public class Test : MonoBehaviour{void Start(){IEnumerator e = Func();while (e.MoveNext()){Debug.Log(e.Current);} }IEnumerator Func(){yield return 1;yield return "Hi NRatel!";yield return 3;} } 对上边C代码生成的Dll进行反编译，查看IL代码： 3、Unity 的协程。 Unity 协程是在逐帧迭代的，这点可以从 Unity 脚本生命周期 中看出。 可以大胆猜测一下，实现出自己的协程（功能相似，能够说明逐帧迭代的原理，不是Unity源码）： using System;using System.Collections;using System.Collections.Generic;using UnityEngine;public class Test : MonoBehaviour{private Dictionary<IEnumerator, IEnumerator> recoverDict; //key:当前迭代器 value:子迭代器完成后需要恢复的父迭代器private IEnumerator enumerator;private void Start(){//Unity自身的协程//StartCoroutine(Func1());//自己实现的协程StarMyCoroutine(Func1());}private void StarMyCoroutine(IEnumerator e){recoverDict = new Dictionary<IEnumerator, IEnumerator>();enumerator = e;recoverDict.Add(enumerator, null); //完成后不需要恢复任何迭代器}private void LateUpdate(){if (enumerator != null){DoEnumerate(enumerator);} }private void DoEnumerate(IEnumerator e){object current;if (e.MoveNext()){current = e.Current;}else{//迭代结束IEnumerator recoverE = recoverDict[e];if (recoverE != null){recoverDict.Remove(e);}//恢复至父迭代器, 若没有则会至为nullenumerator = recoverE;return;}//null，什么也不做，下一帧继续if (current == null) { return; }Type type = current.GetType();//基础类型，什么也不做，下一帧继续if (current is System.Int32) { return; }if (current is System.Boolean) { return; }if (current is System.String) { return; }//IEnumerator 类型, 等待内部嵌套的IEnumerator迭代完成再继续if (current is IEnumerator){//切换至子迭代器enumerator = current as IEnumerator;recoverDict.Add(enumerator, e);return;}//YieldInstruction 类型, 猜测也是类似IEnumerator的实现if (current is YieldInstruction){//省略实现return;} }IEnumerator Func1(){Debug.Log("Time.frameCount: " + Time.frameCount);yield return null;Debug.Log("Time.frameCount: " + Time.frameCount);yield return "Hi NRatel!";Debug.Log("Time.frameCount: " + Time.frameCount);yield return 3;Debug.Log("Time.frameCount: " + Time.frameCount);yield return new WaitUntil(() =>{return Time.frameCount == 20;});Debug.Log("Time.frameCount: " + Time.frameCount);yield return Func2();Debug.Log("Time.frameCount: " + Time.frameCount);}IEnumerator Func2(){Debug.Log("XXXXXXXXX");yield return null;Debug.Log("YYYYYYYYY");yield return Func3(); //嵌套 IEnumerator}IEnumerator Func3(){Debug.Log("AAAAAAAA");yield return null;Debug.Log("BBBBBBBB");yield return null;} } 对比结果，基本可以达成协程作用，包括 IEnumerator 嵌套。 但是 Time.frameCount 的结果不同，想来实现细节必然是有差别的。 四、部分Unity源码分析 1、CustomYieldInstruction 类 可以继承该类，并实现自己的、需要异步等待的类。 原理： 当协程中 yield return “一个CustomYieldInstruction的子类”; 其实就相当于在原来的 迭代器A 中，插入了一个 新的迭代器B。 当迭代程序进入 B ，如果 keepWaiting 为 true，MoveNext() 就总是返回 true。 上面已经说过，迭代器在迭代时，MoveNext() 返回false 才标志着迭代完成！ 那么，B 就总是完不成，直到 keepWaiting 变为 false。 这样 A 运行至 B处就 处于了 等待B完成的状态，相当于A挂起了。 猜测 YieldInstruction 也是类似的实现。 // Unity C reference source// Copyright (c) Unity Technologies. For terms of use, see// https://unity3d.com/legal/licenses/Unity_Reference_Only_Licenseusing System.Collections;namespace UnityEngine{public abstract class CustomYieldInstruction : IEnumerator{public abstract bool keepWaiting{get;}public object Current{get{return null;} }public bool MoveNext() { return keepWaiting; } public void Reset() {} }} 2、WaitUntil 类 语义为 “等待...直到满足...” 继承自 CustomYieldInstruction，需要等待时让 m_Predicate 返回 false (keepWating为true)。 // Unity C reference source// Copyright (c) Unity Technologies. For terms of use, see// https://unity3d.com/legal/licenses/Unity_Reference_Only_Licenseusing System;namespace UnityEngine{public sealed class WaitUntil : CustomYieldInstruction{Func<bool> m_Predicate;public override bool keepWaiting { get { return !m_Predicate(); } }public WaitUntil(Func<bool> predicate) { m_Predicate = predicate; } }} 3、WaitWhile 类 语义为 “等待...如果满足...” 继承自 CustomYieldInstruction，需要等待时让 m_Predicate 返回 true (keepWating为true)。 与 WaitUntil 的实现恰好相反。 // Unity C reference source// Copyright (c) Unity Technologies. For terms of use, see// https://unity3d.com/legal/licenses/Unity_Reference_Only_Licenseusing System;namespace UnityEngine{public sealed class WaitWhile : CustomYieldInstruction{Func<bool> m_Predicate;public override bool keepWaiting { get { return m_Predicate(); } }public WaitWhile(Func<bool> predicate) { m_Predicate = predicate; } }} 本篇文章为转载内容。原文链接：https://blog.csdn.net/NRatel/article/details/102870744。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...的方法都可以与该委托关联，从而实现方法作为参数传递、事件处理等功能。在本文的具体示例中，GreetingDelegate就是一个委托类型，它定义了一个接受string类型参数且无返回值的方法模板，因此EnglishGreeting和ChineseGreeting方法都能够赋值给GreetingDelegate类型的变量。 事件（Event） , 在C中，事件是基于委托机制的一种特殊形式的消息通知机制，允许对象在特定条件下触发（或“发布”）事件，并允许其他对象订阅并响应这些事件。虽然文章主要讨论了委托，但事件实际上是委托的一个重要应用领域，通常用于实现观察者模式，使得类能够提供一种向外部世界宣告状态变化的方式，而无需暴露内部实现细节。在.NET框架中，事件使用关键字event配合委托类型来声明，当事件被触发时，会调用已注册到该事件上的所有委托实例所关联的方法。 方法签名（Method Signature） , 在编程语言中，方法签名是指一个方法的固定描述，包括其名称、参数列表（包括参数的数量、顺序以及每个参数的数据类型）以及返回类型。在C中，委托类型就依据某个方法的签名进行定义，只有那些签名相匹配的方法才能赋值给相应委托类型的变量。在文中提到的GreetingDelegate委托，其方法签名就是“接受一个string类型的参数且无返回值”，所以符合这一签名的所有方法都能与之兼容。

...对象。 对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围进行第二次回收。 如果这次回收还没有足够的内存，才会抛出内存溢出异常。 -Xmx20M/import java.lang.ref.SoftReference;public class T02_SoftReference {public static void main(String[] args) {SoftReference<byte[]> m = new SoftReference<>(new byte[1024102410]);//创建软引用，分配10M//m = null;System.out.println(m.get());//获取System.gc();//垃圾回收try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(m.get());//再分配一个数组，heap将装不下，这时候系统会垃圾回收，先回收一次，如果不够，会把软引用干掉byte[] b = new byte[1024102415];System.out.println(m.get());} }//软引用非常适合缓存使用 2、弱引用 public class M {@Overrideprotected void finalize() throws Throwable {System.out.println("finalize");} } 上图中，tl对象强引用指向ThreadLocal，map中key弱引用指向ThreadLocal，当tl=null时，强引用消失，此时弱引用也将自动被回收，但是此时key=null，value指向10M这个就永远访问不到，既内存泄露 下图中，18行到20行为解决内存泄露问题的，那就是通过remove()将它消除了 / 弱引用遭到gc就会回收/import java.lang.ref.WeakReference;public class T03_WeakReference {public static void main(String[] args) {WeakReference<M> m = new WeakReference<>(new M());System.out.println(m.get());System.gc();System.out.println(m.get());ThreadLocal<M> tl = new ThreadLocal<>();tl.set(new M());tl.remove();} } 3、虚引用 虚引用 虚引用不是给开发人员用的，一般是给写JVM（java虚拟机，没有它java程序运行不了），Netty等技术大牛用的 虚引用，对象当被回收时，会将其放在队列中，此时我们监听到队列中有新值了，就知道有虚引用被回收了 此时我们要做相应的处理，虚引用指向的值，是无法直接get()获取的 虚引用使用场景 一般情况（其它情况暂时没什么用），虚引用指向堆外内存(直接被操作系统管理的内存)，JVM无法对其回收 当虚引用对象被回收时，JVM的垃圾回收无法自动回收堆外内存， 但是此时，虚引用对象被回收，会将其放在队列中 操作人员，看到队列中有对象被回收，就进行相应操作，回收堆内存 如何回收堆外内存 C和C++有函数可以用 java现在也提供了Unsafe类可以操作堆外内存，具体请参考上一篇博客，总之，JDK1.8只能通过反射来用，JDK1.9以上可以通过new Unsafe对象来用 Unsafe类的方法有： copyMemory():直接访问内存 allocateMemory():直接分配内存，这就必须手动回收内存了 freeMemory():回收内存 下面是一个虚引用例子，自己看吧，懂得自然懂，现在看不懂的，先收藏或者保存上，以后回来看 / 一个对象是否有虚引用的存在，完全不会对其生存时间构成影响， 也无法通过虚引用来获取一个对象的实例。 为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。 虚引用和弱引用对关联对象的回收都不会产生影响，如果只有虚引用活着弱引用关联着对象， 那么这个对象就会被回收。它们的不同之处在于弱引用的get方法，虚引用的get方法始终返回null, 弱引用可以使用ReferenceQueue,虚引用必须配合ReferenceQueue使用。 jdk中直接内存的回收就用到虚引用，由于jvm自动内存管理的范围是堆内存， 而直接内存是在堆内存之外（其实是内存映射文件，自行去理解虚拟内存空间的相关概念）， 所以直接内存的分配和回收都是有Unsafe类去操作，java在申请一块直接内存之后， 会在堆内存分配一个对象保存这个堆外内存的引用， 这个对象被垃圾收集器管理，一旦这个对象被回收， 相应的用户线程会收到通知并对直接内存进行清理工作。 事实上，虚引用有一个很重要的用途就是用来做堆外内存的释放， DirectByteBuffer就是通过虚引用来实现堆外内存的释放的。/import java.lang.ref.PhantomReference;import java.lang.ref.Reference;import java.lang.ref.ReferenceQueue;import java.util.LinkedList;import java.util.List;public class T04_PhantomReference {private static final List<Object> LIST = new LinkedList<>();private static final ReferenceQueue<M> QUEUE = new ReferenceQueue<>();public static void main(String[] args) {PhantomReference<M> phantomReference = new PhantomReference<>(new M(), QUEUE);new Thread(() -> {while (true) {LIST.add(new byte[1024 1024]);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();Thread.currentThread().interrupt();}System.out.println(phantomReference.get());} }).start();new Thread(() -> {while (true) {Reference<? extends M> poll = QUEUE.poll();if (poll != null) {System.out.println("--- 虚引用对象被jvm回收了 ---- " + poll);} }}).start();try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();} }} 2、容器 1、发展历史(一定要了解) map容器你需要了解的历史 JDK早期，java提供了Vector和Hashtable两个容器，这两个容器，很多操作都加了锁Synchronized，对于某些不需要用锁的情况下，就显得十分影响性能，所以现在基本没人用这两个容器，但是面试经常问这两个容器里面的数据结构等内容 后来，出现了HashMap，此容器完全不加锁，是用的最多的容器 但是完全不加锁未免不完善，所以java提供了如下方式，将HashMap变为加锁的 //通过Collections.synchronizedMap(HashMap)方法，将其变为加锁Map集合，其中泛型随意，UUID只是举例。static Map<UUID, UUID> m = Collections.synchronizedMap(new HashMap<UUID, UUID>()); 通过阅读源码发现，上面方法将HashMap变为加锁，也是使用Synchronized，只是锁的内容更细，但并不比HashTable效率高多少 所以衍生除了新的容器ConcurrentHashMap ConcurrentHashMap 此容器，插入效率不如上面的，因为它做了各种判断和CAS，但是差距不是特别大 读取效率很高，100个线程同时访问，每个线程读取一百万次实测 Hashtable 39s ，SynchronizedHashMap 38s ，ConcurrentHashMap 1.7s 前两个将近40秒，ConcurrentHashMap只需要不到2s，由此可见此容器读取效率极高 2、为什么推荐使用Queue来做高并发 为什么推荐Queue（队列） Queue接口提供了很多针对多线程非常友好的API（offer ，peek和poll，其中BlockingQueue还添加了put和take可以阻塞），可以说专门为多线程高并发而创造的接口，所以一般我们使用Queue而不用List 以下代码分别使用链表LinkList和ConcurrentQueue，对比一下速度 LinkList用了5s多，ConcurrentQueue几乎瞬间完成 Concurrent接口就是专为多线程设计，多线程设计要多考虑Queue(高并发用)的使用，少使用List / 有N张火车票，每张票都有一个编号 同时有10个窗口对外售票 请写一个模拟程序 分析下面的程序可能会产生哪些问题？ 重复销售？超量销售？ 使用Vector或者Collections.synchronizedXXX 分析一下，这样能解决问题吗？ 就算操作A和B都是同步的，但A和B组成的复合操作也未必是同步的，仍然需要自己进行同步 就像这个程序，判断size和进行remove必须是一整个的原子操作 @author 马士兵/import java.util.LinkedList;import java.util.List;import java.util.concurrent.TimeUnit;public class TicketSeller3 {static List<String> tickets = new LinkedList<>();static {for(int i=0; i<1000; i++) tickets.add("票 编号：" + i);}public static void main(String[] args) {for(int i=0; i<10; i++) {new Thread(()->{while(true) {synchronized(tickets) {if(tickets.size() <= 0) break;try {TimeUnit.MILLISECONDS.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("销售了--" + tickets.remove(0));} }}).start();} }} 队列 import java.util.Queue;import java.util.concurrent.ConcurrentLinkedQueue;public class TicketSeller4 {static Queue<String> tickets = new ConcurrentLinkedQueue<>();static {for(int i=0; i<1000; i++) tickets.add("票 编号：" + i);}public static void main(String[] args) {for(int i=0; i<10; i++) {new Thread(()->{while(true) {String s = tickets.poll();if(s == null) break;else System.out.println("销售了--" + s);} }).start();} }} 3、多线程常用容器 1、ConcurrentHashMap(无序)和ConcurrentSkipListMap(有序，链表，使用跳表数据结构，让查询更快) 跳表：http://blog.csdn.net/sunxianghuang/article/details/52221913 import java.util.;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ConcurrentSkipListMap;import java.util.concurrent.CountDownLatch;public class T01_ConcurrentMap {public static void main(String[] args) {Map<String, String> map = new ConcurrentHashMap<>();//Map<String, String> map = new ConcurrentSkipListMap<>(); //高并发并且排序//Map<String, String> map = new Hashtable<>();//Map<String, String> map = new HashMap<>(); //Collections.synchronizedXXX//TreeMapRandom r = new Random();Thread[] ths = new Thread[100];CountDownLatch latch = new CountDownLatch(ths.length);long start = System.currentTimeMillis();for(int i=0; i<ths.length; i++) {ths[i] = new Thread(()->{for(int j=0; j<10000; j++) map.put("a" + r.nextInt(100000), "a" + r.nextInt(100000));latch.countDown();});}Arrays.asList(ths).forEach(t->t.start());try {latch.await();} catch (InterruptedException e) {e.printStackTrace();}long end = System.currentTimeMillis();System.out.println(end - start);System.out.println(map.size());} } 2、CopyOnWriteList（写时复制）和CopyOnWriteSet 适用于，高并发是，读的多，写的少的情况 当我们写的时候，将容器复制，让写线程去复制的线程写（写的时候加锁） 而读线程依旧去读旧的(读的时候不加锁) 当写完，将对象指向复制后的已经写完的容器，原来容器销毁 大大提高读的效率 / 写时复制容器 copy on write 多线程环境下，写时效率低，读时效率高 适合写少读多的环境 @author 马士兵/import java.util.ArrayList;import java.util.Arrays;import java.util.List;import java.util.Random;import java.util.Vector;import java.util.concurrent.CopyOnWriteArrayList;public class T02_CopyOnWriteList {public static void main(String[] args) {List<String> lists = //new ArrayList<>(); //这个会出并发问题！//new Vector();new CopyOnWriteArrayList<>();Random r = new Random();Thread[] ths = new Thread[100];for(int i=0; i<ths.length; i++) {Runnable task = new Runnable() {@Overridepublic void run() {for(int i=0; i<1000; i++) lists.add("a" + r.nextInt(10000));} };ths[i] = new Thread(task);}runAndComputeTime(ths);System.out.println(lists.size());}static void runAndComputeTime(Thread[] ths) {long s1 = System.currentTimeMillis();Arrays.asList(ths).forEach(t->t.start());Arrays.asList(ths).forEach(t->{try {t.join();} catch (InterruptedException e) {e.printStackTrace();} });long s2 = System.currentTimeMillis();System.out.println(s2 - s1);} } 3、synchronizedList和ConcurrentLinkedQueue package com.mashibing.juc.c_025;import java.util.ArrayList;import java.util.Collections;import java.util.List;import java.util.Queue;import java.util.concurrent.ConcurrentLinkedQueue;public class T04_ConcurrentQueue {public static void main(String[] args) {List<String> strsList = new ArrayList<>();List<String> strsSync = Collections.synchronizedList(strsList);//加锁ListQueue<String> strs = new ConcurrentLinkedQueue<>();//Concurrent链表队列，就是读快for(int i=0; i<10; i++) {strs.offer("a" + i); //add添加，但是不同点是，此方法会返回一个布尔值}System.out.println(strs);System.out.println(strs.size());System.out.println(strs.poll());//取出，取完后将元素去除System.out.println(strs.size());System.out.println(strs.peek());//取出，但是不会将元素从队列删除System.out.println(strs.size());//双端队列Deque} } 4、LinkedBlockingQueue 链表阻塞队列（无界链表，可以一直装东西，直到内存满（其实，也不是无限，其长度Integer.MaxValue就是上限，毕竟最大就这么大）） 主要体现在put和take方法，put添加的时候，如果队列满了，就阻塞当前线程，直到队列有空位，继续插入。take方法取的时候，如果没有值，就阻塞，等有值了，立马去取 import java.util.Random;import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.TimeUnit;public class T05_LinkedBlockingQueue {static BlockingQueue<String> strs = new LinkedBlockingQueue<>();static Random r = new Random();public static void main(String[] args) {new Thread(() -> {for (int i = 0; i < 100; i++) {try {strs.put("a" + i); //如果满了，当前线程就会等待（实现阻塞），等多会有空位，将值插入TimeUnit.MILLISECONDS.sleep(r.nextInt(1000));} catch (InterruptedException e) {e.printStackTrace();} }}, "p1").start();for (int i = 0; i < 5; i++) {new Thread(() -> {for (;;) {try {System.out.println(Thread.currentThread().getName() + " take -" + strs.take()); //取内容，如果空了，当前线程就会等待（实现阻塞）} catch (InterruptedException e) {e.printStackTrace();} }}, "c" + i).start();} }} 5、ArrayBlockingQueue 有界阻塞队列（因为Array需要指定长度） import java.util.Random;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.BlockingQueue;import java.util.concurrent.TimeUnit;public class T06_ArrayBlockingQueue {static BlockingQueue<String> strs = new ArrayBlockingQueue<>(10);static Random r = new Random();public static void main(String[] args) throws InterruptedException {for (int i = 0; i < 10; i++) {strs.put("a" + i);}//strs.put("aaa"); //满了就会等待，程序阻塞//strs.add("aaa");//strs.offer("aaa");strs.offer("aaa", 1, TimeUnit.SECONDS);System.out.println(strs);} } 6、特殊的阻塞队列1：DelayQueue 延时队列（按时间进行调度，就是隔多长时间运行，谁隔的少，谁先） 以下例子中，我们添加线程到队列顺序为t12345，正常情况下，会按照顺序运行，但是这里有了延时时间，也就是时间越短，越先执行 步骤很简单，拿到延时队列 指定构造方法 继承 implements Delayed 重写 compareTo和getDelay import java.util.Calendar;import java.util.Random;import java.util.concurrent.BlockingQueue;import java.util.concurrent.DelayQueue;import java.util.concurrent.Delayed;import java.util.concurrent.TimeUnit;public class T07_DelayQueue {static BlockingQueue<MyTask> tasks = new DelayQueue<>();static Random r = new Random();static class MyTask implements Delayed {String name;long runningTime;MyTask(String name, long rt) {this.name = name;this.runningTime = rt;}@Overridepublic int compareTo(Delayed o) {if(this.getDelay(TimeUnit.MILLISECONDS) < o.getDelay(TimeUnit.MILLISECONDS))return -1;else if(this.getDelay(TimeUnit.MILLISECONDS) > o.getDelay(TimeUnit.MILLISECONDS)) return 1;else return 0;}@Overridepublic long getDelay(TimeUnit unit) {return unit.convert(runningTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);}@Overridepublic String toString() {return name + " " + runningTime;} }public static void main(String[] args) throws InterruptedException {long now = System.currentTimeMillis();MyTask t1 = new MyTask("t1", now + 1000);MyTask t2 = new MyTask("t2", now + 2000);MyTask t3 = new MyTask("t3", now + 1500);MyTask t4 = new MyTask("t4", now + 2500);MyTask t5 = new MyTask("t5", now + 500);tasks.put(t1);tasks.put(t2);tasks.put(t3);tasks.put(t4);tasks.put(t5);System.out.println(tasks);for(int i=0; i<5; i++) {System.out.println(tasks.take());//获取的是toString方法返回值} }} 7、特殊的阻塞队列2：PriorityQueque 优先队列（二叉树算法，就是排序） import java.util.PriorityQueue;public class T07_01_PriorityQueque {public static void main(String[] args) {PriorityQueue<String> q = new PriorityQueue<>();q.add("c");q.add("e");q.add("a");q.add("d");q.add("z");for (int i = 0; i < 5; i++) {System.out.println(q.poll());} }} 8、特殊的阻塞队列3：SynchronusQueue 同步队列(线程池用处非常大) 此队列容量为0，当插入元素时，必须同时有个线程往外取 就是说，当你往这个队列里面插入一个元素，它就拿着这个元素站着(阻塞)，直到有个取元素的线程来，它就把元素交给它 就是用来同步数据的，也就是线程间交互数据用的一个特殊队列 package com.mashibing.juc.c_025;import java.util.concurrent.BlockingQueue;import java.util.concurrent.SynchronousQueue;public class T08_SynchronusQueue { //容量为0public static void main(String[] args) throws InterruptedException {BlockingQueue<String> strs = new SynchronousQueue<>();new Thread(()->{//这个线程就是消费者，来取值try {System.out.println(strs.take());//和同步队列要值} catch (InterruptedException e) {e.printStackTrace();} }).start();strs.put("aaa"); //阻塞等待消费者消费，就拿着aaa站着，等线程来取//strs.put("bbb");//strs.add("aaa");System.out.println(strs.size());} } 9、特殊的阻塞队列4：TransferQueue 传递队列 此队列加入了一个方法transfer()用来向队列添加元素 但是和put()方法不同的是，put添加完元素就走了 而这个方法，添加完自己就阻塞了，直到有人将这个元素取走，它才继续工作(省去我们手动阻塞) import java.util.concurrent.LinkedTransferQueue;public class T09_TransferQueue {public static void main(String[] args) throws InterruptedException {LinkedTransferQueue<String> strs = new LinkedTransferQueue<>();new Thread(() -> {try {System.out.println(strs.take());} catch (InterruptedException e) {e.printStackTrace();} }).start();strs.transfer("aaa");//放东西到队列，同时阻塞等待消费者线程，取走元素//strs.put("aaa");//如果用put就和普通队列一样，放完东西就走了/new Thread(() -> {try {System.out.println(strs.take());} catch (InterruptedException e) {e.printStackTrace();} }).start();/} } 3、线程池 线程池 由于单独创建线程，十分影响效率，而且无法对线程集中管理，一旦疏落，可能线程无限执行，浪费资源 线程池就是一个存储线程的游泳池，而每个线程就是池子里面的赛道 池子里的线程不执行任何任务，只是提供一个资源 而谁提交了任务，比如我想来游泳，那么池子就给你一个赛道，让你游泳 比如它想练憋气，那么给它一个赛道练憋气 当他们用完，走了，那么后面其它人再过来继续用 这就是线程池，始终只有这几个线程，不做实现，而是借用这几个线程的用户，自己掌控用这些线程资源做什么（提交任务给线程,线程空闲就帮他们完成任务） 线程池的两种类型（两类，不是两个） ThreadPoolExecutor（简称TPE） ForkJoinPool（分解汇总任务(将任务细化，最后汇总结果)，少量线程执行多个任务（子任务，TPE做不到先执行子任务），CPU密集型） Executors（注意这后面有s） 它可以说是线程池工厂类，我们一般通过它创建线程池，并且它为我们封装了线程 1、常用类 Executor ExecutorService 扩展了execute方法，具有一个返回值 规定了异步执行机制，提供了一些执行器方法，比如shutdown()关闭等 但是它不知道执行器中的线程何时执行完 Callable 对Runnable进行了扩展,实现Callable的调用，可以有返回值，表示线程的状态 但是无法返回线程执行结果 Future 获得未来线程执行结果 由此，我们可以得知线程池基本的一个使用步骤 其中service.submit（）:为异步提交，也就是说，主线程该干嘛干嘛，我是异步执行的，和同步不一样（当前线程执行完，主线程才能继续执行，叫同步） futuer.get():获取结果集结果，此时因为异步，主线程执行到这里，结果集可能还没封装好，所以此时如果没有值，就阻塞，直到结果集出来 public static void main(String[] args) throws ExecutionException, InterruptedException {Callable<String> c = new Callable() {@Overridepublic String call() throws Exception {return "Hello Callable";} };ExecutorService service = Executors.newCachedThreadPool();Future<String> future = service.submit(c); //异步System.out.println(future.get());//阻塞service.shutdown();} 2、FutureTask 可充当任务的结果集 上面我们介绍Future是用来得到任务的执行结果的 而FutureTask，可以当做一个任务用，并且返回任务的结果，也就是可以跑线程，然后还可以得到线程结果 public static void main(String[] args) throws InterruptedException, ExecutionException {FutureTask<Integer> task = new FutureTask<>(()->{TimeUnit.MILLISECONDS.sleep(500);return 1000;}); //new Callable () { Integer call();}new Thread(task).start();System.out.println(task.get()); //阻塞} 3、CompletableFuture 非常灵活的任务结果集 一个非常灵活的结果集 他可以将很多执行不同任务的线程的结果进行汇总 比如一个网站，它可以启动多个线程去各大电商网站，比如淘宝，京东，收集某些或某一个商品的价格 最后，将获取的数据进行整合封装 最终，客户就可以通过此网站，获取某类商品在各网站的价格信息 / 假设你能够提供一个服务 这个服务查询各大电商网站同一类产品的价格并汇总展示 @author 马士兵 http://mashibing.com/import java.io.IOException;import java.util.Random;import java.util.concurrent.CompletableFuture;import java.util.concurrent.ExecutionException;import java.util.concurrent.TimeUnit;public class T06_01_CompletableFuture {public static void main(String[] args) throws ExecutionException, InterruptedException {long start, end;/start = System.currentTimeMillis();priceOfTM();priceOfTB();priceOfJD();end = System.currentTimeMillis();System.out.println("use serial method call! " + (end - start));/start = System.currentTimeMillis();CompletableFuture<Double> futureTM = CompletableFuture.supplyAsync(()->priceOfTM());CompletableFuture<Double> futureTB = CompletableFuture.supplyAsync(()->priceOfTB());CompletableFuture<Double> futureJD = CompletableFuture.supplyAsync(()->priceOfJD());CompletableFuture.allOf(futureTM, futureTB, futureJD).join();//当所有结果集都获取到，才汇总阻塞CompletableFuture.supplyAsync(()->priceOfTM()).thenApply(String::valueOf).thenApply(str-> "price " + str).thenAccept(System.out::println);end = System.currentTimeMillis();System.out.println("use completable future! " + (end - start));try {System.in.read();} catch (IOException e) {e.printStackTrace();} }private static double priceOfTM() {delay();return 1.00;}private static double priceOfTB() {delay();return 2.00;}private static double priceOfJD() {delay();return 3.00;}/private static double priceOfAmazon() {delay();throw new RuntimeException("product not exist!");}/private static void delay() {int time = new Random().nextInt(500);try {TimeUnit.MILLISECONDS.sleep(time);} catch (InterruptedException e) {e.printStackTrace();}System.out.printf("After %s sleep!\n", time);} } 4、TPE型线程池1：ThreadPoolExecutor 原理及其参数 线程池由两个集合组成，一个集合存储线程，一个集合存储任务 存储线程：可以规定大小，最多可以有多少个，以及指定核心线程数量（不会被回收） 任务队列：存储任务 细节：初始线程池没有线程，当有一个任务来，线程池起一个线程，又有一个任务来，再起一个线程，直到达到核心线程数量 核心线程数量达到时，新来的任务将存储到任务队列中等待核心线程处理完成，直到任务队列也满了 当任务队列满了，此时再次启动一个线程（非核心线程，一旦空闲，达到指定时间将会消失），直到达到线程最大数量 当线程容器和任务容器都满了，又来了线程，将会执行拒绝策略 上面的细节涉及的所有步骤内容，均由创建线程池的参数执行 下面是ThreadPoolExecutor构造方法参数的源码注释 / 用给定的初始值，创建一个新的线程池 @param corePoolSize 核心线程数量 @param maximumPoolSize 最大线程数量 @param keepAliveTime 当线程数大于核心线程数量时，空闲的线程可生存的时间 @param unit 时间单位 @param workQueue 任务队列，只能包含由execute提交的Runnable任务 @param threadFactory 工厂，用于创建线程给线程池调度的工厂，可以自定义 @param handler 拒绝策略(可以自定义，JDK默认提供4种)，当线程边界和队列容量已经满了，新来线程被阻塞时使用的处理程序/public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) JDK提供的4种拒绝策略，不常用，一般都是自己定义拒绝策略 Abort：抛异常 Discard：扔掉，不抛异常 DiscardOldest：扔掉排队时间最久的（将队列中排队时间最久的扔掉，然后让新来的进来） CallerRuns：调用者处理任务（谁通过execute方法提交任务，谁处理） ThreadPoolExecutor继承关系 继承关系：ThreadPoolExecutor->AbstractExectorService类->ExectorService接口->Exector接口 Executors（注意这后面有s） 它可以说是线程池工厂类，我们一般通过它创建线程池，并且它为我们封装了线程 看看下面创建线程池，哪里用到了它 使用实例 import java.io.IOException;import java.util.concurrent.;public class T05_00_HelloThreadPool {static class Task implements Runnable {private int i;public Task(int i) {this.i = i;}@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + " Task " + i);try {System.in.read();} catch (IOException e) {e.printStackTrace();} }@Overridepublic String toString() {return "Task{" +"i=" + i +'}';} }public static void main(String[] args) {ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 4,60, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.CallerRunsPolicy());//创建线程池，核心2个，最大4个，空闲线程存活时间60s，任务队列容量4，使用默认线程工程，创建线程。拒绝策略是JDK提供的for (int i = 0; i < 8; i++) {tpe.execute(new Task(i));//供提交8次任务}System.out.println(tpe.getQueue());//查看任务队列tpe.execute(new Task(100));//提交新的任务System.out.println(tpe.getQueue());tpe.shutdown();//关闭线程池} } 5、TPE型线程池2：SingleThreadPool 单例线程池(只有一个线程) 为什么有单例线程池 有任务队列，有线程池管理机制 Executors（注意这后面有s） 它可以说是线程池工厂类，我们一般通过它创建线程池，并且它为我们封装了线程 看看下面哪里用到了它 /创建单例线程池，扔5个任务进去，查看输出结果，看看有几个线程执行任务/import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class T07_SingleThreadPool {public static void main(String[] args) {ExecutorService service = Executors.newSingleThreadExecutor();for(int i=0; i<5; i++) {final int j = i;service.execute(()->{System.out.println(j + " " + Thread.currentThread().getName());});} }} 6、TPE型线程池3：CachedPool 缓存，存储线程池 此线程池没有核心线程，来一个任务启动一个线程（最多Integer.MaxValue，不会放在任务队列，因为任务队列容量为0），每个线程空闲后，只能活60s 实例 import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class T07_SingleThreadPool {public static void main(String[] args) {ExecutorService service = Executors.newSingleThreadExecutor();//通过Executors获取池子for(int i=0; i<5; i++) {final int j = i;service.execute(()->{//提交任务System.out.println(j + " " + Thread.currentThread().getName());});}service.shutdown();} } 7、TPE型线程池4：FixedThreadPool 固定线程池 此线次池，用于创建一个固定线程数量的线程池，不会回收 实例 import java.util.ArrayList;import java.util.List;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;public class T09_FixedThreadPool {public static void main(String[] args) throws InterruptedException, ExecutionException {//并发执行long start = System.currentTimeMillis();getPrime(1, 200000); long end = System.currentTimeMillis();System.out.println(end - start);//输出并发执行耗费时间final int cpuCoreNum = 4;//并行执行ExecutorService service = Executors.newFixedThreadPool(cpuCoreNum);MyTask t1 = new MyTask(1, 80000); //1-5 5-10 10-15 15-20MyTask t2 = new MyTask(80001, 130000);MyTask t3 = new MyTask(130001, 170000);MyTask t4 = new MyTask(170001, 200000);Future<List<Integer>> f1 = service.submit(t1);Future<List<Integer>> f2 = service.submit(t2);Future<List<Integer>> f3 = service.submit(t3);Future<List<Integer>> f4 = service.submit(t4);start = System.currentTimeMillis();f1.get();f2.get();f3.get();f4.get();end = System.currentTimeMillis();System.out.println(end - start);//输出并行耗费时间}static class MyTask implements Callable<List<Integer>> {int startPos, endPos;MyTask(int s, int e) {this.startPos = s;this.endPos = e;}@Overridepublic List<Integer> call() throws Exception {List<Integer> r = getPrime(startPos, endPos);return r;} }static boolean isPrime(int num) {for(int i=2; i<=num/2; i++) {if(num % i == 0) return false;}return true;}static List<Integer> getPrime(int start, int end) {List<Integer> results = new ArrayList<>();for(int i=start; i<=end; i++) {if(isPrime(i)) results.add(i);}return results;} } 8、TPE型线程池5：ScheduledPool 预定，延时线程池 根据延时时间（隔多长时间后运行），排序，哪个线程先执行,用户只需要指定核心线程数量 此线程池返回的池对象，和提交任务方法都不一样，比较涉及到时间 import java.util.Random;import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;public class T10_ScheduledPool {public static void main(String[] args) {ScheduledExecutorService service = Executors.newScheduledThreadPool(4);service.scheduleAtFixedRate(()->{//提交延时任务try {TimeUnit.MILLISECONDS.sleep(new Random().nextInt(1000));} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName());}, 0, 500, TimeUnit.MILLISECONDS);//指定延时时间和单位，第一个任务延时0毫秒，之后的任务，延时500毫秒} } 9、手写拒绝策略小例子 import java.util.concurrent.;public class T14_MyRejectedHandler {public static void main(String[] args) {ExecutorService service = new ThreadPoolExecutor(4, 4,0, TimeUnit.SECONDS, new ArrayBlockingQueue<>(6),Executors.defaultThreadFactory(),new MyHandler());//将手写拒绝策略传入}static class MyHandler implements RejectedExecutionHandler {//1、继承RejectedExecutionHandler@Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {//2、重写方法//log("r rejected")//伪代码，表示通过log4j.log()报一下日志，拒绝的时间，线程名//save r kafka mysql redis//可以尝试保存队列//try 3 times //可以尝试几次，比如3次，重新去抢队列，3次还不行就丢弃if(executor.getQueue().size() < 10000) {//尝试条件，如果size>10000了,就执行拒绝策略//try put again();//如果小于10000，尝试将其放到队列中} }} } 10、ForkJoinPool线程池1：ForkJoinPool 前面我们讲过线程分为两大类，TPE和FJP ForkJoinPool（分解汇总任务(将任务细化，最后汇总结果)，少量线程执行多个任务（子任务，TPE做不到先执行子任务），CPU密集型） 适合将大任务切分成多个小任务运行 两个方法，fork()：分子任务，将子任务分配到线程池中 join()：当前任务的计算结果，如果有子任务，等子任务结果返回后再汇总 下面实例实现，一百万个随机数求和，由两种方法实现，一种ForkJoinPool分任务并行，一种使用单线程做 import java.io.IOException;import java.util.Arrays;import java.util.Random;import java.util.concurrent.ForkJoinPool;import java.util.concurrent.RecursiveAction;import java.util.concurrent.RecursiveTask;public class T12_ForkJoinPool {//1000000个随机数求和static int[] nums = new int[1000000];//一堆数static final int MAX_NUM = 50000;//分任务时，每个任务的操作量不能多于50000个，否则就继续细分static Random r = new Random();//使用随机数将数组初始化static {for(int i=0; i<nums.length; i++) {nums[i] = r.nextInt(100);}System.out.println("---" + Arrays.stream(nums).sum()); //stream api 单线程就这么做，一个一个加}//分任务，需要继承，可以继承RecursiveAction(不需要返回值，一般用在不需要返回值的场景)或//RecursiveTask(需要返回值，我们用这个，因为我们需要最后获取求和结果)两个更好实现的类，//他俩继承与ForkJoinTaskstatic class AddTaskRet extends RecursiveTask<Long> {private static final long serialVersionUID = 1L;int start, end;AddTaskRet(int s, int e) {start = s;end = e;}@Overrideprotected Long compute() {if(end-start <= MAX_NUM) {//如果任务操作数小于规定的最大操作数，就进行运算，long sum = 0L;for(int i=start; i<end; i++) sum += nums[i];return sum;//返回结果} //如果分配的操作数大于规定，就继续细分（简单的重中点分，两半）int middle = start + (end-start)/2;//获取中间值AddTaskRet subTask1 = new AddTaskRet(start, middle);//传入起始值和中间值，表示一个子任务AddTaskRet subTask2 = new AddTaskRet(middle, end);//中间值和结尾值，表示一个子任务subTask1.fork();//分任务subTask2.fork();//分任务return subTask1.join() + subTask2.join();//最后返回结果汇总} }public static void main(String[] args) throws IOException {/ForkJoinPool fjp = new ForkJoinPool();AddTask task = new AddTask(0, nums.length);fjp.execute(task);/ForkJoinPool fjp = new ForkJoinPool();//创建线程池AddTaskRet task = new AddTaskRet(0, nums.length);//创建任务fjp.execute(task);//传入任务long result = task.join();//返回汇总结果System.out.println(result);//System.in.read();} } 11、ForkJoinPool线程池2：WorkStealingPool 任务偷取线程池 原来的线程池，都是有一个任务队列，而这个不同，它给每个线程都分配了一个任务队列 当某一个线程的任务队列没有任务，并且自己空闲，它就去其它线程的任务队列中偷任务，所以叫任务偷取线程池 细节：当线程自己从自己的任务队列拿任务时，不需要加锁，但是偷任务时，因为有两个线程，可能发生同步问题，需要加锁 此线程继承FJP 实例 import java.io.IOException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;public class T11_WorkStealingPool {public static void main(String[] args) throws IOException {ExecutorService service = Executors.newWorkStealingPool();System.out.println(Runtime.getRuntime().availableProcessors());service.execute(new R(1000));service.execute(new R(2000));service.execute(new R(2000));service.execute(new R(2000)); //daemonservice.execute(new R(2000));//由于产生的是精灵线程（守护线程、后台线程），主线程不阻塞的话，看不到输出System.in.read(); }static class R implements Runnable {int time;R(int t) {this.time = t;}@Overridepublic void run() {try {TimeUnit.MILLISECONDS.sleep(time);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(time + " " + Thread.currentThread().getName());} }} 12、流式API：ParallelStreamAPI 不懂的请参考：https://blog.csdn.net/grd_java/article/details/110265219 实例 import java.util.ArrayList;import java.util.List;import java.util.Random;public class T13_ParallelStreamAPI {public static void main(String[] args) {List<Integer> nums = new ArrayList<>();Random r = new Random();for(int i=0; i<10000; i++) nums.add(1000000 + r.nextInt(1000000));//System.out.println(nums);long start = System.currentTimeMillis();nums.forEach(v->isPrime(v));long end = System.currentTimeMillis();System.out.println(end - start);//使用parallel stream apistart = System.currentTimeMillis();nums.parallelStream().forEach(T13_ParallelStreamAPI::isPrime);//并行流，将任务切分成子任务执行end = System.currentTimeMillis();System.out.println(end - start);}static boolean isPrime(int num) {for(int i=2; i<=num/2; i++) {if(num % i == 0) return false;}return true;} } 13、总结 总结 Callable相当于一Runnable但是它有返回值 Future：存储执行完产生的结果 FutureTask 相当于Future+Runnable，既可以执行任务，又能获取任务执行的Future结果 CompletableFuture 可以多任务异步，并对多任务控制，整合任务结果，细化完美，比如可以一个任务完成就可以整合结果，也可以所有任务完成才整合结果 4、ThreadPoolExecutor源码解析 依然只讲重点，实际还需要大家按照上篇博客中看源码的方式来看 1、常用变量的解释 // 1. ctl，可以看做一个int类型的数字，高3位表示线程池状态，低29位表示worker数量private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));// 2. COUNT_BITS，Integer.SIZE为32，所以COUNT_BITS为29private static final int COUNT_BITS = Integer.SIZE - 3;// 3. CAPACITY，线程池允许的最大线程数。1左移29位，然后减1，即为 2^29 - 1private static final int CAPACITY = (1 << COUNT_BITS) - 1;// runState is stored in the high-order bits// 4. 线程池有5种状态，按大小排序如下：RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATEDprivate static final int RUNNING = -1 << COUNT_BITS;private static final int SHUTDOWN = 0 << COUNT_BITS;private static final int STOP = 1 << COUNT_BITS;private static final int TIDYING = 2 << COUNT_BITS;private static final int TERMINATED = 3 << COUNT_BITS;// Packing and unpacking ctl// 5. runStateOf()，获取线程池状态，通过按位与操作，低29位将全部变成0private static int runStateOf(int c) { return c & ~CAPACITY; }// 6. workerCountOf()，获取线程池worker数量，通过按位与操作，高3位将全部变成0private static int workerCountOf(int c) { return c & CAPACITY; }// 7. ctlOf()，根据线程池状态和线程池worker数量，生成ctl值private static int ctlOf(int rs, int wc) { return rs | wc; }/ Bit field accessors that don't require unpacking ctl. These depend on the bit layout and on workerCount being never negative./// 8. runStateLessThan()，线程池状态小于xxprivate static boolean runStateLessThan(int c, int s) {return c < s;}// 9. runStateAtLeast()，线程池状态大于等于xxprivate static boolean runStateAtLeast(int c, int s) {return c >= s;} 2、构造方法 public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) {// 基本类型参数校验if (corePoolSize < 0 ||maximumPoolSize <= 0 ||maximumPoolSize < corePoolSize ||keepAliveTime < 0)throw new IllegalArgumentException();// 空指针校验if (workQueue == null || threadFactory == null || handler == null)throw new NullPointerException();this.corePoolSize = corePoolSize;this.maximumPoolSize = maximumPoolSize;this.workQueue = workQueue;// 根据传入参数unit和keepAliveTime，将存活时间转换为纳秒存到变量keepAliveTime 中this.keepAliveTime = unit.toNanos(keepAliveTime);this.threadFactory = threadFactory;this.handler = handler;} 3、提交执行task的过程 public void execute(Runnable command) {if (command == null)throw new NullPointerException();/ Proceed in 3 steps: 1. If fewer than corePoolSize threads are running, try to start a new thread with the given command as its first task. The call to addWorker atomically checks runState and workerCount, and so prevents false alarms that would add threads when it shouldn't, by returning false. 2. If a task can be successfully queued, then we still need to double-check whether we should have added a thread (because existing ones died since last checking) or that the pool shut down since entry into this method. So we recheck state and if necessary roll back the enqueuing if stopped, or start a new thread if there are none. 3. If we cannot queue task, then we try to add a new thread. If it fails, we know we are shut down or saturated and so reject the task./int c = ctl.get();// worker数量比核心线程数小，直接创建worker执行任务if (workerCountOf(c) < corePoolSize) {if (addWorker(command, true))return;c = ctl.get();}// worker数量超过核心线程数，任务直接进入队列if (isRunning(c) && workQueue.offer(command)) {int recheck = ctl.get();// 线程池状态不是RUNNING状态，说明执行过shutdown命令，需要对新加入的任务执行reject()操作。// 这儿为什么需要recheck，是因为任务入队列前后，线程池的状态可能会发生变化。if (! isRunning(recheck) && remove(command))reject(command);// 这儿为什么需要判断0值，主要是在线程池构造方法中，核心线程数允许为0else if (workerCountOf(recheck) == 0)addWorker(null, false);}// 如果线程池不是运行状态，或者任务进入队列失败，则尝试创建worker执行任务。// 这儿有3点需要注意：// 1. 线程池不是运行状态时，addWorker内部会判断线程池状态// 2. addWorker第2个参数表示是否创建核心线程// 3. addWorker返回false，则说明任务执行失败，需要执行reject操作else if (!addWorker(command, false))reject(command);} 4、addworker源码解析 private boolean addWorker(Runnable firstTask, boolean core) {retry:// 外层自旋for (;;) {int c = ctl.get();int rs = runStateOf(c);// 这个条件写得比较难懂，我对其进行了调整，和下面的条件等价// (rs > SHUTDOWN) || // (rs == SHUTDOWN && firstTask != null) || // (rs == SHUTDOWN && workQueue.isEmpty())// 1. 线程池状态大于SHUTDOWN时，直接返回false// 2. 线程池状态等于SHUTDOWN，且firstTask不为null，直接返回false// 3. 线程池状态等于SHUTDOWN，且队列为空，直接返回false// Check if queue empty only if necessary.if (rs >= SHUTDOWN &&! (rs == SHUTDOWN &&firstTask == null &&! workQueue.isEmpty()))return false;// 内层自旋for (;;) {int wc = workerCountOf(c);// worker数量超过容量，直接返回falseif (wc >= CAPACITY ||wc >= (core ? corePoolSize : maximumPoolSize))return false;// 使用CAS的方式增加worker数量。// 若增加成功，则直接跳出外层循环进入到第二部分if (compareAndIncrementWorkerCount(c))break retry;c = ctl.get(); // Re-read ctl// 线程池状态发生变化，对外层循环进行自旋if (runStateOf(c) != rs)continue retry;// 其他情况，直接内层循环进行自旋即可// else CAS failed due to workerCount change; retry inner loop} }boolean workerStarted = false;boolean workerAdded = false;Worker w = null;try {w = new Worker(firstTask);final Thread t = w.thread;if (t != null) {final ReentrantLock mainLock = this.mainLock;// worker的添加必须是串行的，因此需要加锁mainLock.lock();try {// Recheck while holding lock.// Back out on ThreadFactory failure or if// shut down before lock acquired.// 这儿需要重新检查线程池状态int rs = runStateOf(ctl.get());if (rs < SHUTDOWN ||(rs == SHUTDOWN && firstTask == null)) {// worker已经调用过了start()方法，则不再创建workerif (t.isAlive()) // precheck that t is startablethrow new IllegalThreadStateException();// worker创建并添加到workers成功workers.add(w);// 更新largestPoolSize变量int s = workers.size();if (s > largestPoolSize)largestPoolSize = s;workerAdded = true;} } finally {mainLock.unlock();}// 启动worker线程if (workerAdded) {t.start();workerStarted = true;} }} finally {// worker线程启动失败，说明线程池状态发生了变化（关闭操作被执行），需要进行shutdown相关操作if (! workerStarted)addWorkerFailed(w);}return workerStarted;} 5、线程池worker任务单元 private final class Workerextends AbstractQueuedSynchronizerimplements Runnable{/ This class will never be serialized, but we provide a serialVersionUID to suppress a javac warning./private static final long serialVersionUID = 6138294804551838833L;/ Thread this worker is running in. Null if factory fails. /final Thread thread;/ Initial task to run. Possibly null. /Runnable firstTask;/ Per-thread task counter /volatile long completedTasks;/ Creates with given first task and thread from ThreadFactory. @param firstTask the first task (null if none)/Worker(Runnable firstTask) {setState(-1); // inhibit interrupts until runWorkerthis.firstTask = firstTask;// 这儿是Worker的关键所在，使用了线程工厂创建了一个线程。传入的参数为当前workerthis.thread = getThreadFactory().newThread(this);}/ Delegates main run loop to outer runWorker /public void run() {runWorker(this);}// 省略代码...} 6、核心线程执行逻辑-runworker final void runWorker(Worker w) {Thread wt = Thread.currentThread();Runnable task = w.firstTask;w.firstTask = null;// 调用unlock()是为了让外部可以中断w.unlock(); // allow interrupts// 这个变量用于判断是否进入过自旋（while循环）boolean completedAbruptly = true;try {// 这儿是自旋// 1. 如果firstTask不为null，则执行firstTask；// 2. 如果firstTask为null，则调用getTask()从队列获取任务。// 3. 阻塞队列的特性就是：当队列为空时，当前线程会被阻塞等待while (task != null || (task = getTask()) != null) {// 这儿对worker进行加锁，是为了达到下面的目的// 1. 降低锁范围，提升性能// 2. 保证每个worker执行的任务是串行的w.lock();// If pool is stopping, ensure thread is interrupted;// if not, ensure thread is not interrupted. This// requires a recheck in second case to deal with// shutdownNow race while clearing interrupt// 如果线程池正在停止，则对当前线程进行中断操作if ((runStateAtLeast(ctl.get(), STOP) ||(Thread.interrupted() &&runStateAtLeast(ctl.get(), STOP))) &&!wt.isInterrupted())wt.interrupt();// 执行任务，且在执行前后通过beforeExecute()和afterExecute()来扩展其功能。// 这两个方法在当前类里面为空实现。try {beforeExecute(wt, task);Throwable thrown = null;try {task.run();} catch (RuntimeException x) {thrown = x; throw x;} catch (Error x) {thrown = x; throw x;} catch (Throwable x) {thrown = x; throw new Error(x);} finally {afterExecute(task, thrown);} } finally {// 帮助gctask = null;// 已完成任务数加一 w.completedTasks++;w.unlock();} }completedAbruptly = false;} finally {// 自旋操作被退出，说明线程池正在结束processWorkerExit(w, completedAbruptly);} } 本篇文章为转载内容。原文链接：https://blog.csdn.net/grd_java/article/details/113116244。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...tVNC使用，问题的模式不约而同。Pavel测试发现在Ubuntu最新版本TightVNC套件（1.3.10版本）中同样存在该问题，上报给当前软件所有者GlavSoft公司，但对方声称目前精力放在不受GPL限制的TightVNC 2.x版本开发中，对开源的1.x版本漏洞代码“可能会进行修复”。看起来，这个问题被踢给了各大Linux发行版社区来焦虑了——如果他们愿意接锅。 问题思考 在披露邮件中，Pavel认为，这些代码bug“如此明显，让人无法相信之前没被人发现过……也许是因为某些特殊理由才始终没得到修复”。 事实上，我们都知道目前存在一些对开源基础软件进行安全扫描的大型项目，例如Google的OSS；同时，仍然存活的开源项目也越来越注重自身代码发布前的安全扫描，Fortify、Coverity的扫描也成为很多项目和平台的标配。在这样一些眼睛注视下，为什么还有这样的问题？我认为就这个具体事例来说，可能有如下两个因素： ·上游已死。仍然在被维护的代码，存在版本更迭，也存在外界的持续关注、漏洞报告和修复、开发的迭代，对于负责人的开发者，持续跟进、评估、同步代码的改动是可能的。但是一旦一份代码走完了生命周期，就像一段史实一样会很少再被改动。 ·对第三方上游代码的无条件信任。我们很多人都有过基础组件、中间件的开发经历，不乏有人使用Coverity开启全部规则进行代码扫描、严格修复所有提示的问题甚至编程规范warning；报告往往很长，其中也包括有源码形式包含的第三方代码中的问题。但是，我们一方面倾向于认为这些被广泛使用的代码不应存在问题（不然早就被人挖过了），一方面考虑这些引用的代码往往是组件或库的形式被使用，应该有其上下文才能认定是否确实有可被利用的漏洞条件，现在单独扫描这部分代码一般出来的都是误报。所以这些代码的问题都容易被忽视。 但是透过这个具体例子，再延伸思考相关的实践，这里最根本的问题可以总结为一个模式： 复制粘贴风险。复制粘贴并不简单意味着剽窃，实际是当前软件领域、互联网行业发展的基础模式，但其中有一些没人能尝试解决的问题： ·在传统代码领域，如C代码中，对第三方代码功能的复用依赖，往往通过直接进行库的引入实现，第三方代码独立而完整，也较容易进行整体更新；这是最简单的情况，只需要所有下游使用者保证仅使用官方版本，跟进官方更新即可；但在实践中很难如此贯彻，这是下节讨论的问题。 ·有些第三方发布的代码，模式就是需要被源码形式包含到其他项目中进行统一编译使用（例如腾讯的开源Json解析库RapidJSON，就是纯C++头文件形式）。在开源领域有如GPL等规约对此进行规范，下游开发者遵循协议，引用代码，强制或可选地显式保留其GPL声明，可以进行使用和更改。这样的源码依赖关系，结合规范化的changelog声明代码改动，侧面也是为开发过程中跟进考虑。但是一个成型的产品，比如企业自有的服务端底层产品、中间件，新版本的发版更新是复杂的过程，开发者在旧版本仍然“功能正常”的情况下往往倾向于不跟进新版本；而上游代码如果进行安全漏洞修复，通常也都只在其最新版本代码中改动，安全修复与功能迭代并存，如果没有类似Linux发行版社区的努力，旧版本代码完全没有干净的安全更新patch可用。 ·在特定场景下，有些开发实践可能不严格遵循开源代码协议限定，引入了GPL等协议保护的代码而不做声明（以规避相关责任），丢失了引入和版本的信息跟踪；在另一些场景下，可能存在对开源代码进行大刀阔斧的修改、剪裁、定制，以符合自身业务的极端需求，但是过多的修改、人员的迭代造成与官方代码严重的失同步，丧失可维护性。 ·更一般的情况是，在开发中，开发者个体往往心照不宣的存在对网上代码文件、代码片段的复制-粘贴操作。被参考的代码，可能有上述的开源代码，也可能有各种Github作者练手项目、技术博客分享的代码片段、正式开源项目仅用来说明用法的不完备示例代码。这些代码的引入完全无迹可寻，即便是作者自己也很难解释用了什么。这种情况下，上面两条认定的那些与官方安全更新失同步的问题同样存在，且引入了独特的风险：被借鉴的代码可能只是原作者随手写的、仅仅是功能成立的片段，甚至可能是恶意作者随意散布的有安全问题的代码。由此，问题进入了最大的发散空间。 在Synopsys下BLACKDUCK软件之前发布的《2018 Open Source Security and Risk Analysis Report》中分析，96%的应用中包含有开源组件和代码，开源代码在应用全部代码中的占比约为57%，78%的应用中在引用的三方开源代码中存在历史漏洞。也就是说，现在互联网上所有厂商开发的软件、应用，其开发人员自己写的代码都是一少部分，多数都是借鉴来的。而这还只是可统计、可追溯的；至于上面提到的非规范的代码引用，如果也纳入进来考虑，三方代码占应用中的比例会上升到多少？曾经有分析认为至少占80%，我们只期望不会更高。 Ⅱ. 从碎片到乱刃：OpenSSH在野后门一览 在进行基础软件梳理时，回忆到反病毒安全软件提供商ESET在2018年十月发布的一份白皮书《THE DARK SIDE OF THE FORSSHE: A landscape of OpenSSH backdoors》。其站在一个具有广泛用户基础的软件提供商角度，给出了一份分析报告，数据和结论超出我们对于当前基础软件使用全景的估量。以下以我的角度对其中一方面进行解读。 一些必要背景 SSH的作用和重要性无需赘言；虽然我们站在传统互联网公司角度，可以认为SSH是通往生产服务器的生命通道，但当前多样化的产业环境已经不止于此（如之前libssh事件中，不幸被我言中的，SSH在网络设备、IoT设备上（如f5）的广泛使用）。 OpenSSH是目前绝大多数SSH服务端的基础软件，有完备的开发团队、发布规范、维护机制，本身是靠谱的。如同绝大多数基础软件开源项目的做法，OpenSSH对漏洞有及时的响应，针对最新版本代码发出安全补丁，但是各大Linux发行版使用的有各种版本的OpenSSH，这些社区自行负责将官方开发者的安全补丁移植到自己系统搭载的低版本代码上。天空彩 白皮书披露的现状 如果你是一个企业的运维管理人员，需要向企业生产服务器安装OpenSSH或者其它基础软件，最简单的方式当然是使用系统的软件管理安装即可。但是有时候，出于迁移成本考虑，可能企业需要在一个旧版本系统上，使用较新版本的OpenSSL、OpenSSH等基础软件，这些系统不提供，需要自行安装；或者需要一个某有种特殊特性的定制版本。这时，可能会选择从某些rpm包集中站下载某些不具名第三方提供的现成的安装包，或者下载非官方的定制化源码本地编译后安装，总之从这里引入了不确定性。 这种不确定性有多大？我们粗估一下，似乎不应成为问题。但这份白皮书给我们看到了鲜活的数据。 ESET研究人员从OpenSSH的一次历史大规模Linux服务端恶意软件Windigo中获得启示，采用某种巧妙的方式，面向在野的服务器进行数据采集，主要是系统与版本、安装的OpenSSH版本信息以及服务端程序文件的一个特殊签名。整理一个签名白名单，包含有所有能搜索到的官方发布二进制版本、各大Linux发行版本各个版本所带的程序文件版本，将这些标定为正常样本进行去除。最终结论是： ·共发现了几百个非白名单版本的OpenSSH服务端程序文件ssh和sshd； ·分析这些样本，将代码部分完全相同，仅仅是数据和配置不同的合并为一类，且分析判定确认有恶意代码的，共归纳为 21个各异的恶意OpenSSH家族； ·在21个恶意家族中，有12个家族在10月份时完全没有被公开发现分析过；而剩余的有一部分使用了历史上披露的恶意代码样本，甚至有源代码； ·所有恶意样本的实现，从实现复杂度、代码混淆和自我保护程度到代码特征有很大跨度的不同，但整体看，目的以偷取用户凭证等敏感信息、回连外传到攻击者为主，其中有的攻击者回连地址已经存在并活跃数年之久； ·这些后门的操控者，既有传统恶意软件黑产人员，也有APT组织； ·所有恶意软件或多或少都在被害主机上有未抹除的痕迹。ESET研究者尝试使用蜜罐引诱出攻击者，但仍有许多未解之谜。这场对抗，仍未取胜。 白皮书用了大篇幅做技术分析报告，此处供细节分析，不展开分析，以下为根据恶意程序复杂度描绘的21个家族图谱： 问题思考 问题引入的可能渠道，我在开头进行了一点推测，主要是由人的原因切入的，除此以外，最可能的是恶意攻击者在利用各种方法入侵目标主机后，主动替换了目标OpenSSH为恶意版本，从而达成攻击持久化操作。但是这些都是止血的安全运维人员该考虑的事情；关键问题是，透过表象，这显露了什么威胁形式？ 这个问题很好回答，之前也曾经反复说过：基础软件碎片化。 如上一章节简单提到，在开发过程中有各种可能的渠道引入开发者不完全了解和信任的代码；在运维过程中也是如此。二者互相作用，造成了软件碎片化的庞杂现状。在企业内部，同一份基础软件库，可能不同的业务线各自定制一份，放到企业私有软件仓库源中，有些会有人持续更新供自己产品使用，有些由系统软件基础设施维护人员单独维护，有些则可能是开发人员临时想起来上传的，他们自己都不记得；后续用到的这个基础软件的开发和团队，在这个源上搜索到已有的库，很大概率会倾向于直接使用，不管来源、是否有质量背书等。长此以往问题会持续发酵。而我们开最坏的脑洞，是否可能有黑产人员入职到内部，提交个恶意基础库之后就走人的可能？现行企业安全开发流程中审核机制的普遍缺失给这留下了空位。 将源码来源碎片化与二进制使用碎片化并起来考虑，我们不难看到一个远远超过OpenSSH事件威胁程度的图景。但这个问题不是仅仅靠开发阶段规约、运维阶段规范、企业内部管控、行业自查、政府监管就可以根除的，最大的问题归根结底两句话： 不可能用一场战役对抗持续威胁；不可能用有限分析对抗无限未知。 Ⅲ. 从自信到自省：RHEL、CentOS backport版本BIND漏洞 2018年12月20日凌晨，在备战冬至的软件供应链安全大赛决赛时，我注意到漏洞预警平台捕获的一封邮件。但这不是一个漏洞初始披露邮件，而是对一个稍早已披露的BIND在RedHat、CentOS发行版上特定版本的1day漏洞CVE-2018-5742，由BIND的官方开发者进行额外信息澄(shuǎi)清(guō)的邮件。 一些必要背景 关于BIND 互联网的一个古老而基础的设施是DNS，这个概念在读者不应陌生。而BIND“是现今互联网上最常使用的DNS软件，使用BIND作为服务器软件的DNS服务器约占所有DNS服务器的九成。BIND现在由互联网系统协会负责开发与维护参考。”所以BIND的基础地位即是如此，因此也一向被大量白帽黑帽反复测试、挖掘漏洞，其开发者大概也一直处在紧绷着应对的处境。 关于ISC和RedHat 说到开发者，上面提到BIND的官方开发者是互联网系统协会（ISC）。ISC是一个老牌非营利组织，目前主要就是BIND和DHCP基础设施的维护者。而BIND本身如同大多数历史悠久的互联网基础开源软件，是4个UCB在校生在DARPA资助下于1984年的实验室产物，直到2012年由ISC接管。 那么RedHat在此中是什么角色呢？这又要提到我之前提到的Linux发行版和自带软件维护策略。Red Hat Enterprise Linux（RHEL）及其社区版CentOS秉持着稳健的软件策略，每个大的发行版本的软件仓库，都只选用最必要且质量久经时间考验的软件版本，哪怕那些版本实在是老掉牙。这不是一种过分的保守，事实证明这种策略往往给RedHat用户在最新漏洞面前提供了保障——代码总是跑得越少，潜在漏洞越多。 但是这有两个关键问题。一方面，如果开源基础软件被发现一例有历史沿革的代码漏洞，那么官方开发者基本都只为其最新代码负责，在当前代码上推出修复补丁。另一方面，互联网基础设施虽然不像其上的应用那样爆发性迭代，但依然持续有一些新特性涌现，其中一些是必不可少的，但同样只在最新代码中提供。两个刚需推动下，各Linux发行版对长期支持版本系统的软件都采用一致的策略，即保持其基础软件在一个固定的版本，但对于这些版本软件的最新漏洞、必要的最新软件特性，由发行版维护者将官方开发者最新代码改动“向后移植”到旧版本代码中，即backport。这就是基础软件的“官宣”碎片化的源头。 讲道理，Linux发行版维护者与社区具有比较靠谱的开发能力和监督机制，backport又基本就是一些复制粘贴工作，应当是很稳当的……但真是如此吗？ CVE-2018-5742漏洞概况 CVE-2018-5742是一个简单的缓冲区溢出类型漏洞，官方评定其漏洞等级moderate，认为危害不大，漏洞修复不积极，披露信息不多，也没有积极给出代码修复patch和新版本rpm包。因为该漏洞仅在设置DEBUG_LEVEL为10以上才会触发，由远程攻击者构造畸形请求造成BIND服务崩溃，在正常的生产环境几乎不可能具有危害，RedHat官方也只是给出了用户自查建议。 这个漏洞只出现在RHEL和CentOS版本7中搭载的BIND 9.9.4-65及之后版本。RedHat同ISC的声明中都证实，这个漏洞的引入原因，是RedHat在尝试将BIND 9.11版本2016年新增的NTA机制向后移植到RedHat 7系中固定搭载的BIND 9.9版本代码时，偶然的代码错误。NTA是DNS安全扩展（DNSSEC）中，用于在特定域关闭DNSSEC校验以避免不必要的校验失败的机制；但这个漏洞不需要对NTA本身有进一步了解。 漏洞具体分析 官方没有给出具体分析，但根据CentOS社区里先前有用户反馈的bug，我得以很容易还原漏洞链路并定位到根本原因。 若干用户共同反馈，其使用的BIND 9.9.4-RedHat-9.9.4-72.el7发生崩溃（coredump），并给出如下的崩溃时调用栈backtrace： 这个调用过程的逻辑为，在9 dns_message_logfmtpacket函数判断当前软件设置是否DEBUG_LEVEL大于10，若是，对用户请求数据包做日志记录，先后调用8 dns_message_totext、7 dns_message_sectiontotext、6 dns_master_rdatasettotext、5 rdataset_totext将请求进行按协议分解分段后写出。 由以上关键调用环节，联动RedHat在9.9.4版本BIND源码包中关于引入NTA特性的源码patch，进行代码分析，很快定位到问题产生的位置，在上述backtrace中的5，masterdump.c文件rdataset_totext函数。漏洞相关代码片段中，RedHat进行backport后，这里引入的代码为： 这里判断对于请求中的注释类型数据，直接通过isc_buffer_putstr宏对缓存进行操作，在BIND工程中自定义维护的缓冲区结构对象target上，附加一字节字符串（一个分号）。而漏洞就是由此产生：isc_buffer_putstr中不做缓冲区边界检查保证，这里在缓冲区已满情况下将造成off-by-one溢出，并触发了缓冲区实现代码中的assertion。 而ISC上游官方版本的代码在这里是怎么写的呢？找到ISC版本BIND 9.11代码，这里是这样的： 这里可以看到，官方代码在做同样的“附加一个分号”这个操作时，审慎的使用了做缓冲区剩余空间校验的str_totext函数，并额外做返回值成功校验。而上述提到的str_totext函数与RETERR宏，在移植版本的masterdump.c中，RedHat开发者也都做了保留。但是，查看代码上下文发现，在RedHat开发者进行代码移植过程中，对官方代码进行了功能上的若干剪裁，包括一些细分数据类型记录的支持；而这里对缓冲区写入一字节，也许开发者完全没想到溢出的可能，所以自作主张地简化了代码调用过程。 问题思考 这个漏洞本身几乎没什么危害，但是背后足以引起思考。 没有人在“借”别人代码时能不出错 不同于之前章节提到的那种场景——将代码文件或片段复制到自己类似的代码上下文借用——backport作为一种官方且成熟的做法，借用的代码来源、粘贴到的代码上下文，是具有同源属性的，而且开发者一般是追求稳定性优先的社区开发人员，似乎质量应该有足够保障。但是这里的关键问题是：代码总要有一手、充分的语义理解，才能有可信的使用保障；因此，只要是处理他人的代码，因为不够理解而错误使用的风险，只可能减小，没办法消除。 如上分析，本次漏洞的产生看似只是做代码移植的开发者“自作主张”之下“改错了”。但是更广泛且可能的情况是，原始开发者在版本迭代中引入或更新大量基础数据结构、API的定义，并用在新的特性实现代码中；而后向移植开发人员仅需要最小规模的功能代码，所以会对增量代码进行一定规模的修改、剪裁、还原，以此适应旧版本基本代码。这些过程同样伴随着第三方开发人员不可避免的“望文生义”，以及随之而来的风险。后向移植操作也同样助长了软件碎片化过程，其中每一个碎片都存在这样的问题；每一个碎片在自身生命周期也将有持续性影响。 多级复制粘贴无异于雪上加霜 这里简单探讨的是企业通行的系统和基础软件建设实践。一些国内外厂商和社区发布的定制化Linux发行版，本身是有其它发行版，如CentOS特定版本渊源的，在基础软件上即便同其上游发行版最新版本间也存在断层滞后。RedHat相对于基础软件开发者之间已经隔了一层backport，而我们则人为制造了二级风险。 在很多基础而关键的软件上，企业系统基础设施的维护者出于与RedHat类似的初衷，往往会决定自行backport一份拷贝；通过早年心脏滴血事件的洗礼，即暴露出来OpenSSL一个例子。无论是需要RHEL还没来得及移植的新版本功能特性，还是出于对特殊使用上下文场景中更高执行效率的追求，企业都可能自行对RHEL上基础软件源码包进行修改定制重打包。这个过程除了将风险幂次放大外，也进一步加深了代码的不可解释性（包括基础软件开发人员流动性带来的不可解释）。 Ⅳ. 从武功到死穴：从systemd-journald信息泄露一窥API误用 1月10日凌晨两点，漏洞预警平台爬收取一封漏洞披露邮件。披露者是Qualys，那就铁定是重型发布了。最后看披露漏洞的目标，systemd？这就非常有意思了。 一些必要背景 systemd是什么，不好简单回答。Linux上面软件命名，习惯以某软件名后带个‘d’表示后台守护管理程序；所以systemd就可以说是整个系统的看守吧。而即便现在描述了systemd是什么，可能也很快会落伍，因为其初始及核心开发者Lennart Poettering（供职于Red Hat）描述它是“永无开发完结完整、始终跟进技术进展的、统一所有发行版无止境的差异”的一种底层软件。笼统讲有三个作用：中央化系统及设置管理；其它软件开发的基础框架；应用程序和系统内核之间的胶水。如今几乎所有Linux发行版已经默认提供systemd，包括RHEL/CentOS 7及后续版本。总之很基础、很底层、很重要就对了。systemd本体是个主要实现init系统的框架，但还有若干关键组件完成其它工作；这次被爆漏洞的是其journald组件，是负责系统事件日志记录的看守程序。 额外地还想简单提一句Qualys这个公司。该公司创立于1999年，官方介绍为信息安全与云安全解决方案企业，to B的安全业务非常全面，有些也是国内企业很少有布局的方面；例如上面提到的涉及碎片化和代码移植过程的历史漏洞移动，也在其漏洞管理解决方案中有所体现。但是我们对这家公司粗浅的了解来源于其安全研究团队近几年的发声，这两年间发布过的，包括有『stack clash』、『sudo get_tty_name提权』、『OpenSSH信息泄露与堆溢出』、『GHOST：glibc gethostbyname缓冲区溢出』等大新闻（仅截至2017年年中）。从中可见，这个研究团队专门啃硬骨头，而且还总能开拓出来新的啃食方式，往往爆出来一些别人没想到的新漏洞类型。从这个角度，再联想之前刷爆朋友圈的《安全研究者的自我修养》所倡导的“通过看历史漏洞、看别人的最新成果去举一反三”的理念，可见差距。 CVE-2018-16866漏洞详情 这次漏洞披露，打包了三个漏洞： ·16864和16865是内存破坏类型 ·16866是信息泄露 ·而16865和16866两个漏洞组和利用可以拿到root shell。 漏洞分析已经在披露中写的很详细了，这里不复述；而针对16866的漏洞成因来龙去脉，Qualys跟踪的结果留下了一点想象和反思空间，我们来看一下。 漏洞相关代码片段是这样的（漏洞修复前）： 读者可以先肉眼过一遍这段代码有什么问题。实际上我一开始也没看出来，向下读才恍然大悟。 这段代码中，外部信息输入通过buf传入做记录处理。输入数据一般包含有空白字符间隔，需要分隔开逐个记录，有效的分隔符包括空格、制表符、回车、换行，代码中将其写入常量字符串；在逐字符扫描输入数据字符串时，将当前字符使用strchr在上述间隔符字符串中检索是否匹配，以此判断是否为间隔符；在240行，通过这样的判断，跳过记录单元字符串的头部连续空白字符。 但是问题在于，strchr这个极其基础的字符串处理函数，对于C字符串终止字符'\0'的处理上有个坑：'\0'也被认为是被检索字符串当中的一个有效字符。所以在240行，当当前扫描到的字符为字符串末尾的NULL时，strchr返回的是WHITESPACE常量字符串的终止位置而非NULL，这导致了越界。 看起来，这是一个典型的问题：API误用（API mis-use），只不过这个被误用的库函数有点太基础，让我忍不住想是不是还会有大量的类似漏洞……当然也反思我自己写的代码是不是也有同样情况，然而略一思考就释然了——我那么笨的代码都用for循环加if判断了:) 漏洞引入和消除历史 有意思的是，Qualys研究人员很贴心地替我做了一步漏洞成因溯源，这才是单独提这个漏洞的原因。漏洞的引入是在2015年的一个commit中： 在GitHub中，定位到上述2015年的commit信息，这里commit的备注信息为： journald: do not strip leading whitespace from messages. Keep leading whitespace for compatibility with older syslog implementations. Also useful when piping formatted output to the logger command. Keep removing trailing whitespace. OK，看起来是一个兼容性调整，对记录信息不再跳过开头所有连续空白字符，只不过用strchr的简洁写法比较突出开发者精炼的开发风格（并不），说得过去。 之后在2018年八月的一个当时尚未推正式版的另一次commit中被修复了，先是还原成了ec5ff4那次commit之前的写法，然后改成了加校验的方式： 虽然Qualys研究者认为上述的修改是“无心插柳”的改动，但是在GitHub可以看到，a6aadf这次commit是因为有外部用户反馈了输入数据为单个冒号情况下journald堆溢出崩溃的issue，才由开发者有目的性地修复的；而之后在859510这个commit再次改动回来，理由是待记录的消息都是使用单个空格作为间隔符的，而上一个commit粗暴地去掉了这种协议兼容性特性。 如果没有以上纠结的修改和改回历史，也许我会倾向于怀疑，在最开始漏洞引入的那个commit，既然改动代码没有新增功能特性、没有解决什么问题（毕竟其后三年，这个改动的代码也没有被反映issue），也并非出于代码规范等考虑，那么这么轻描淡写的一次提交，难免有人为蓄意引入漏洞的嫌疑。当然，看到几次修复的原因，这种可能性就不大了，虽然大家仍可以保留意见。但是抛开是否人为这个因素，单纯从代码的漏洞成因看，一个传统但躲不开的问题仍值得探讨：API误用。 API误用：程序员何苦为难程序员 如果之前的章节给读者留下了我反对代码模块化和复用的印象，那么这里需要正名一下，我们认可这是当下开发实践不可避免的趋势，也增进了社会开发速度。而API的设计决定了写代码和用代码的双方“舒适度”的问题，由此而来的API误用问题，也是一直被当做单纯的软件工程课题讨论。在此方面个人并没有什么研究，自然也没办法系统地给出分类和学术方案，只是谈一下自己的经验和想法。 一篇比较新的学术文章总结了API误用的研究，其中一个独立章节专门分析Java密码学组件API误用的实际，当中引述之前论文认为，密码学API是非常容易被误用的，比如对期望输入数据（数据类型，数据来源，编码形式）要求的混淆，API的必需调用次序和依赖缺失（比如缺少或冗余多次调用了初始化函数、主动资源回收函数）等。凑巧在此方面我有一点体会：曾经因为业务方需要，需要使用C++对一个Java的密码基础中间件做移植。Java对密码学组件支持，有原生的JDK模块和权威的BouncyCastle包可用；而C/C++只能使用第三方库，考虑到系统平台最大兼容和最小代码量，使用Linux平台默认自带的OpenSSL的密码套件。但在开发过程中感受到了OpenSSL满满的恶意：其中的API设计不可谓不反人类，很多参数没有明确的说明（比如同样是表示长度的函数参数，可能在不同地方分别以字节/比特/分组数为计数单位）；函数的线程安全没有任何解释标注，需要自行试验；不清楚函数执行之后，是其自行做了资源释放还是需要有另外API做gc，不知道资源释放操作时是否规规矩矩地先擦除后释放……此类问题不一而足，导致经过了漫长的测试之后，这份中间件才提供出来供使用。而在业务场景中，还会存在比如其它语言调用的情形，这些又暴露出来OpenSSL API误用的一些完全无从参考的问题。这一切都成为了噩梦；当然这无法为我自己开解是个不称职开发的指责，但仅就OpenSSL而言其API设计之恶劣也是始终被人诟病的问题，也是之后其他替代者宣称改进的地方。 当然，问题是上下游都脱不了干系的。我们自己作为高速迭代中的开发人员，对于二方、三方提供的中间件、API，又有多少人能自信地说自己仔细、认真地阅读过开发指南和API、规范说明呢？做过通用产品技术运营的朋友可能很容易理解，自己产品的直接用户日常抛出不看文档的愚蠢问题带来的困扰。对于密码学套件，这个问题还好办一些，毕竟如果在没有背景知识的情况下对API望文生义地一通调用，绝大多数情况下都会以抛异常形式告终；但还是有很多情况，API误用埋下的是长期隐患。 不是所有API误用情形最终都有机会发展成为可利用的安全漏洞，但作为一个由人的因素引入的风险，这将长期存在并困扰软件供应链（虽然对安全研究者、黑客与白帽子是很欣慰的事情）。可惜，传统的白盒代码扫描能力，基于对代码语义的理解和构建，但是涉及到API则需要预先的抽象，这一点目前似乎仍然是需要人工干预的事情；或者轻量级一点的方案，可以case by case地分析，为所有可能被误用的API建模并单独扫描，这自然也有很强局限性。在一个很底层可信的开发者还对C标准库API存在误用的现实内，我们需要更多的思考才能说接下来的解法。 Ⅴ. 从规则到陷阱：NASA JIRA误配置致信息泄露血案 软件的定义包括了代码组成的程序，以及相关的配置、文档等。当我们说软件的漏洞、风险时，往往只聚焦在其中的代码中；关于软件供应链安全风险，我们的比赛、前面分析的例子也都聚焦在了代码的问题；但是真正的威胁都来源于不可思议之处，那么代码之外有没有可能存在来源于上游的威胁呢？这里就借助实例来探讨一下，在“配置”当中可能栽倒的坑。 引子：发不到500英里以外的邮件？ 让我们先从一个轻松愉快的小例子引入。这个例子初见于Linux中国的一篇译文。 简单说，作者描述了这么一个让人啼笑皆非的问题：单位的邮件服务器发送邮件，发送目标距离本地500英里范围之外的一律失败，邮件就像悠悠球一样只能飞出一定距离。这个问题本身让描述者感到尴尬，就像一个技术人员被老板问到“为什么从家里笔记本上Ctrl-C后不能在公司台式机上Ctrl-V”一样。 经过令人窒息的分析操作后，笔者定位到了问题原因：笔者作为负责的系统管理员，把SunOS默认安装的Senmail从老旧的版本5升级到了成熟的版本8，且对应于新版本诸多的新特性进行了对应配置，写入配置文件sendmail.cf；但第三方服务顾问在对单位系统进行打补丁升级维护时，将系统软件“升级”到了系统提供的最新版本，因此将Sendmail实际回退到了版本5，却为了软件行为一致性，原样保留了高版本使用的配置文件。但Sendmail并没有在大版本间保证配置文件兼容性，这导致很多版本5所需的配置项不存在于保留下来的sendmail.cf文件中，程序按默认值0处理；最终引起问题的就是，邮件服务器与接收端通信的超时时间配置项，当取默认配置值0时，邮件服务器在1个单位时间（约3毫秒）内没有收到网络回包即认为超时，而这3毫秒仅够电信号打来回飞出500英里。 这个“故事”可能会给技术人员一点警醒，错误的配置会导致预期之外的软件行为，但是配置如何会引入软件供应链方向的安全风险呢？这就引出了下一个重磅实例。 JIRA配置错误致NASA敏感信息泄露案例 我们都听过一个事情，马云在带队考察美国公司期间问Google CEO Larry Page自视谁为竞争对手，Larry的回答是NASA，因为最优秀的工程师都被NASA的梦想吸引过去了。由此我们显然能窥见NASA的技术水位之高，这样的人才团队大概至少是不会犯什么低级错误的。 但也许需要重新定义“低级错误”……1月11日一篇技术文章披露，NASA某官网部署使用的缺陷跟踪管理系统JIRA存在错误的配置，可分别泄漏内部员工（JIRA系统用户）的全部用户名和邮件地址，以及内部项目和团队名称到公众，如下： 问题的原因解释起来也非常简单：JIRA系统的过滤器和配置面板中，对于数据可见性的配置选项分别选定为All users和Everyone时，系统管理人员想当然地认为这意味着将数据对所有“系统用户”开放查看，但是JIRA的这两个选项的真实效果逆天，是面向“任意人”开放，即不限于系统登录用户，而是任何查看页面的人员。看到这里，我不厚道地笑了……“All users”并不意味着“All ‘users’”，意不意外，惊不惊喜？ 但是这种字面上把戏，为什么没有引起NASA工程师的注意呢，难道这样逆天的配置项没有在产品手册文档中加粗标红提示吗？本着为JIRA产品设计找回尊严的态度，我深入挖掘了一下官方说明，果然在Atlassian官方的一份confluence文档（看起来更像是一份增补的FAQ）中找到了相关说明： 所有未登录访客访问时，系统默认认定他们是匿名anonymous用户，所以各种权限配置中的all users或anyone显然应该将匿名用户包括在内。在7.2及之后版本中，则提供了“所有登录用户”的选项。 可以说是非常严谨且贴心了。比较讽刺的是，在我们的软件供应链安全大赛·C源代码赛季期间，我们设计圈定的恶意代码攻击目标还包括JIRA相关的敏感信息的窃取，但是却想不到有这么简单方便的方式，不动一行代码就可以从JIRA中偷走数据。 软件的使用，你“配”吗？ 无论是开放的代码还是成型的产品，我们在使用外部软件的时候，都是处于软件供应链下游的消费者角色，为了要充分理解上游开发和产品的真实细节意图，需要我们付出多大的努力才够“资格”？ 上一章节我们讨论过源码使用中必要细节信息缺失造成的“API误用”问题，而软件配置上的“误用”问题则复杂多样得多。从可控程度上讨论，至少有这几种因素定义了这个问题： ·软件用户对必要配置的现有文档缺少了解。这是最简单的场景，但又是完全不可避免的，这一点上我们所有有开发、产品或运营角色经验的应该都曾经体会过向不管不顾用户答疑的痛苦，而所有软件使用者也可以反省一下对所有软件的使用是否都以完整细致的文档阅读作为上手的准备工作，所以不必多说。 ·软件拥有者对配置条目缺少必要明确说明文档。就JIRA的例子而言，将NASA工程师归为上一条错误有些冤枉，而将JIRA归为这条更加合适。在边角但重要问题上的说明通过社区而非官方文档形式发布是一种不负责任的做法，但未引发安全事件的情况下还有多少这样的问题被默默隐藏呢？我们没办法要求在使用软件之前所有用户将软件相关所有文档、社区问答实现全部覆盖。这个问题范围内一个代表性例子是对配置项的默认值以及对应效果的说明缺失。 ·配置文件版本兼容性带来的误配置和安全问题。实际上，上面的SunOS Sendmail案例足以点出这个问题的存在性，但是在真实场景下，很可能不会以这么戏剧性形式出现。在企业的系统运维中，系统的版本迭代常见，但为软件行为一致性，配置的跨版本迁移是不可避免的操作；而且软件的更新迭代也不只会由系统更新推动，还有大量出于业务性能要求而主动进行的定制化升级，对于中小企业基础设施建设似乎是一个没怎么被提及过的问题。 ·配置项组合冲突问题。尽管对于单个配置项可能明确行为与影响，但是特定的配置项搭配可能造成不可预知的效果。这完全有可能是由于开发者与用户在信息不对等的情况下产生：开发者认为用户应该具有必需的背景知识，做了用户应当具备规避配置冲突能力的假设。一个例子是，对称密码算法在使用ECB、CBC分组工作模式时，从密码算法上要求输入数据长度必须是分组大小的整倍数，但如果用户搭配配置了秘钥对数据不做补齐（nopadding），则引入了非确定性行为：如果密码算法库对这种组合配置按某种默认补齐方式操作数据则会引起歧义，但如果在算法库代码层面对这种组合抛出错误则直接影响业务。 ·程序对配置项处理过程的潜在暗箱操作。这区别于简单的未文档化配置项行为，仅特指可能存在的蓄意、恶意行为。从某种意义上，上述“All users”也可以认为是这样的一种陷阱，通过浅层次暗示，引导用户做出错误且可能引起问题的配置。另一种情况是特定配置组合情况下触发恶意代码的行为，这种触发条件将使恶意代码具有规避检测的能力，且在用户基数上具有一定概率的用户命中率。当然这种情况由官方开发者直接引入的可能性很低，但是在众包开发的情况下如果存在，那么扫描方案是很难检测的。 Ⅵ. 从逆流到暗流：恶意代码溯源后的挑战 如果说前面所说的种种威胁都是面向关键目标和核心系统应该思考的问题，那么最后要抛出一个会把所有人拉进赛场的理由。除了前面所有那些在软件供应链下游被动污染受害的情况，还有一种情形：你有迹可循的代码，也许在不经意间会“反哺”到黑色产业链甚至特殊武器中；而现在研究用于对程序进行分析和溯源的技术，则会让你陷入百口莫辩的境地。 案例：黑产代码模块溯源疑云 1月29日，猎豹安全团队发布技术分析通报文章《电信、百度客户端源码疑遭泄漏，驱魔家族窃取隐私再起波澜》，矛头直指黑产上游的恶意信息窃取代码模块，认定其代码与两方产品存在微妙的关联：中国电信旗下“桌面3D动态天气”等多款软件，以及百度旗下“百度杀毒”等软件（已不可访问）。 文章中举证有三个关键点。 首先最直观的，是三者使用了相同的特征字符串、私有文件路径、自定义内部数据字段格式； 其次，在关键代码位置，三者在二进制程序汇编代码层面具有高度相似性； 最终，在一定范围的非通用程序逻辑上，三者在经过反汇编后的代码语义上显示出明显的雷同，并提供了如下两图佐证（图片来源）： 文章指出的涉事相关软件已经下线，对于上述样本文件的相似度试验暂不做复现，且无法求证存在相似、疑似同源的代码在三者中占比数据。对于上述指出的代码雷同现象，猎豹安全团队认为： 我们怀疑该病毒模块的作者通过某种渠道(比如“曾经就职”)，掌握有中国电信旗下部分客户端/服务端源码，并加以改造用于制作窃取用户隐私的病毒，另外在该病毒模块的代码中，我们还发现“百度”旗下部分客户端的基础调试日志函数库代码痕迹，整个“驱魔”病毒家族疑点重重，其制作传播背景愈发扑朔迷离。 这样的推断，固然有过于直接的依据（例如三款代码中均使用含有“baidu”字样的特征注册表项）；但更进一步地，需要注意到，三个样本在所指出的代码位置，具有直观可见的二进制汇编代码结构的相同，考虑到如果仅仅是恶意代码开发者先逆向另外两份代码后借鉴了代码逻辑，那么在面临反编译、代码上下文适配重构、跨编译器和选项的编译结果差异等诸多不确定环节，仍能保持二进制代码的雷同，似乎确实是只有从根本上的源代码泄漏（抄袭）且保持相同的开发编译环境才能成立。 但是我们却又无法做出更明确的推断。这一方面当然是出于严谨避免过度解读；而从另一方面考虑，黑产代码的一个关键出发点就是“隐藏自己”，而这里居然如此堂而皇之地照搬了代码，不但没有进行任何代码混淆、变形，甚至没有抹除疑似来源的关键字符串，如果将黑产视为智商在线的对手，那这里背后是否有其它考量，就值得琢磨了。 代码的比对、分析、溯源技术水准 上文中的安全团队基于大量样本和粗粒度比对方法，给出了一个初步的判断和疑点。那么是否有可能获得更确凿的分析结果，来证实或证伪同源猜想呢？ 无论是源代码还是二进制，代码比对技术作为一种基础手段，在软件供应链安全分析上都注定仍然有效。在我们的软件供应链安全大赛期间，针对PE二进制程序类型的题目，参赛队伍就纷纷采用了相关技术手段用于目标分析，包括：同源性分析，用于判定与目标软件相似度最高的同软件官方版本；细粒度的差异分析，用于尝试在忽略编译差异和特意引入的混淆之外，定位特意引入的恶意代码位置。当然，作为比赛中针对性的应对方案，受目标和环境引导约束，这些方法证明了可行性，却难以保证集成有最新技术方案。那么做一下预言，在不计入情报辅助条件下，下一代的代码比对将能够到达什么水准？ 这里结合近一年和今年内，已发表和未发表的学术领域顶级会议的相关文章来简单展望： ·针对海量甚至全量已知源码，将可以实现准确精细化的“作者归属”判定。在ACM CCS‘18会议上曾发表的一篇文章《Large-Scale and Language-Oblivious Code Authorship Identification》，描述了使用RNN进行大规模代码识别的方案，在圈定目标开发者，并预先提供每个开发者的5-7份已知的代码文件后，该技术方案可以很有效地识别大规模匿名代码仓库中隶属于每个开发者的代码：针对1600个Google Code Jam开发者8年间的所有代码可以实现96%的成功识别率，而针对745个C代码开发者于1987年之后在GitHub上面的全部公开代码仓库，识别率也高达94.38%。这样的结果在当下的场景中，已经足以实现对特定人的代码识别和跟踪（例如，考虑到特定开发人员可能由于编码习惯和规范意识，在时间和项目跨度上犯同样的错误）；可以预见，在该技术方向上，完全可以期望摆脱特定已知目标人的现有数据集学习的过程，并实现更细粒度的归属分析，例如代码段、代码行、提交历史。 ·针对二进制代码，更准确、更大规模、更快速的代码主程序分析和同源性匹配。近年来作为一项程序分析基础技术研究，二进制代码相似性分析又重新获得了学术界和工业界的关注。在2018年和2019（已录用）的安全领域四大顶级会议上，每次都会有该方向最新成果的展示，如S&P‘2019上录用的《Asm2Vec: Boosting Static Representation Robustness for Binary Clone Search against Code Obfuscation and Compiler Optimization》，实现无先验知识的条件下的最优汇编代码级别克隆检测，针对漏洞库的漏洞代码检测可实现0误报、100%召回。而2018年北京HITB会议上，Google Project Zero成员、二进制比对工具BinDiff原始作者Thomas Dullien，探讨了他借用改造Google自家SimHash算法思想，用于针对二进制代码控制流图做相似性检测的尝试和阶段结果；这种引入规模数据处理的思路，也可期望能够在目前其他技术方案大多精细化而低效的情况下，为高效、快速、大规模甚至全量代码克隆检测勾出未来方案。 ·代码比对方案对编辑、优化、变形、混淆的对抗。近年所有技术方案都以对代码“变种”的检测有效性作为关键衡量标准，并一定程度上予以保证。上文CCS‘18论文工作，针对典型源代码混淆（如Tigress）处理后的代码，大规模数据集上可有93.42%的准确识别率；S&P‘19论文针对跨编译器和编译选项、业界常用的OLLVM编译时混淆方案进行试验，在全部可用的混淆方案保护之下的代码仍然可以完成81%以上的克隆检测。值得注意的是以上方案都并非针对特定混淆方案单独优化的，方法具有通用价值；而除此以外还有很多针对性的的反混淆研究成果可用；因此，可以认为在采用常规商用代码混淆方案下，即便存在隐藏内部业务逻辑不被逆向的能力，但仍然可以被有效定位代码复用和开发者自然人。 代码溯源技术面前的“挑战” 作为软件供应链安全的独立分析方，健壮的代码比对技术是决定性的基石；而当脑洞大开，考虑到行业的发展，也许以下两种假设的情景，将把每一个“正当”的产品、开发者置于尴尬的境地。 代码仿制 在本章节引述的“驱魔家族”代码疑云案例中，黑产方面通过某种方式获得了正常代码中，功能逻辑可以被自身复用的片段，并以某种方法将其在保持原样的情况下拼接形成了恶意程序。即便在此例中并非如此，但这却暴露了隐忧：将来是不是有这种可能，我的正常代码被泄漏或逆向后出现在恶意软件中，被溯源后扣上黑锅？ 这种担忧可能以多种渠道和形式成为现实。 从上游看，内部源码被人为泄漏是最简单的形式（实际上，考虑到代码的完整生命周期似乎并没有作为企业核心数据资产得到保护，目前实质上有没有这样的代码在野泄漏还是个未知数），而通过程序逆向还原代码逻辑也在一定程度上可获取原始代码关键特征。 从下游看，则可能有多种方式将恶意代码伪造得像正常代码并实现“碰瓷”。最简单地，可以大量复用关键代码特征（如字符串，自定义数据结构，关键分支条件，数据记录和交换私有格式等）。考虑到在进行溯源时，分析者实际上不需要100%的匹配度才会怀疑，因此仅仅是仿造原始程序对于第三方公开库代码的特殊定制改动，也足以将公众的疑点转移。而近年来类似自动补丁代码搜索生成的方案也可能被用来在一份最终代码中包含有二方甚至多方原始代码的特征和片段。 基于开发者溯源的定点渗透 既然在未来可能存在准确将代码与自然人对应的技术，那么这种技术也完全可能被黑色产业利用。可能的忧患包括强针对性的社会工程，结合特定开发者历史代码缺陷的漏洞挖掘利用，联动第三方泄漏人员信息的深层渗透，等等。这方面暂不做联想展开。 〇. 没有总结 作为一场旨在定义“软件供应链安全”威胁的宣言，阿里安全“功守道”大赛将在后续给出详细的分解和总结，其意义价值也许会在一段时间之后才能被挖掘。 但是威胁的现状不容乐观，威胁的发展不会静待；这一篇随笔仅仅挑选六个侧面做摘录分析，可即将到来的趋势一定只会进入更加发散的境地，因此这里，没有总结。 本篇文章为转载内容。原文链接：https://blog.csdn.net/systemino/article/details/90114743。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...解各种引擎在处理每个具体问题时的方案是相当重要的。而每种方案又各有利弊，即使不做引擎开发工作而是在某一特定游戏引擎上做游戏开发，从中也可以理解引擎的局限性以及可能的改进方法。尤其是第14章介绍的对游戏性相关系统的设计，各个开发人员几乎都是凭经验设计，很少见有书籍对这些做总结。对于基于渲染引擎做开发的游戏程序员，这是必须面对的工作，这一章会有很大的借鉴意义。 本书作者是业内资深的游戏引擎开发人，他所参于的《神秘海域》和《最后生还者》都是我的个人最爱。在玩游戏的过程中，作为游戏程序员的天性，自然会不断地猜想各个技术点是如何实现的，背后需要怎样的工具支持。能在书中一一得到印证是件特别开心的事情。作者反复强调代码实践的重要性，在书中遍布着C++代码。我不认为这些代码有直接取来使用的价值，但它们极大地帮助了读者理解书中的技术点。书中列出的顽皮狗工作室用lisp方言作为游戏配置脚本的范例也给我很大的启发，有了这些具体的代码示例以及作者本身的一线工程师背景，也让我确信书中那些关于主机游戏开发相关等，我所没有接触过的内容都也绝非泛泛而谈。 国内的游戏开发社区的壮大，主要是随最近十年的MMO风潮而生。而就在大型网络游戏在中国有些畸形发展，让这类游戏偏离电子游戏游戏性的趋势时，我们有幸迎来了为移动设备开发游戏的大潮。游戏开发的重心重新回到游戏性本身。我们更需要去借鉴单机游戏是如何为玩家带来更纯粹的游戏体验，我相信书中记录的各种技术点会变的更有帮助。 资深游戏开发及创业者 云风 @简悦云风 推荐序2 在我认识的许多游戏业开发同仁中，只有少数香港同胞，Milo Yip（叶劲峰）却正是这样一位给我印象非常深刻的优秀香港游戏开发者。我俩认识，是在Milo加入腾讯互动娱乐研发部引擎技术中心后，说来到现在也只是两年多时间。其间，他为人的谦逊务实，对待技术问题的严谨求真态度，对算法设计和性能优化的娴熟技术，都为人所称道。Milo一丝不苟的工作风格，甚至表现在对待技术文档排版这类事情上（Milo常执著地用LaTeX将技术文档排到完美），我想这一定是他在香港读大学、硕士及在香港理工大学的多媒体创新中心从事研究员，一贯沿袭至今的好作风。 我很高兴腾讯游戏有实力吸引到这样优秀的技术专家；即使在其已从上海迁回香港家中，依然选择到深圳腾讯互动娱乐总部工作。叶兄从此工作日每天早晚过关，来往香港和深圳两地，虽有舟车劳顿，但是兼顾了对家庭的照顾和在游戏引擎方面的专业研究，希望这样的状况是令他满意的。 认识叶兄当时，我便知道他在进行Jason Gregory所著《游戏引擎架构》一书的中译工作。因为自己从前也有业余翻译游戏开发有关书籍的经历，所以我能理解其中的辛苦和责任重大，对叶兄也更多一分钦佩。我以为，本书以及本书的中文读者最大的幸运便是，遇到叶兄这位对游戏有着如同对家对国般强烈责任感，犹如“游戏科学工作者”般的专业译者！ 现在（2013年年末）无疑是游戏史上对独立游戏制作者最友好的年代。开发设备方便获得（相对过往仅由主机厂商授权才能获得专利开发设备，现在有一台智能手机和一台个人电脑就可以开发）、技术工具友好、调试过程简单方便，且互联网上有丰富的例程和开源代码参考，也有网上社区便于交流。很多爱好者能够很快地制作出可运行的游戏原型，其中一些也能发布到应用商店。 但是不全面掌握各方面知识，尤其是游戏引擎架构知识，往往只能停留在勉强修改、凑合重用别人提供的资源的应用程度上，难以做极限的性能改进，更妄谈革命式的架构创新。这样的程度是很难在成千上万的游戏中脱颖而出的。我们所认可的真正的游戏大作，必定是在某方面大幅超越用户期待的产品。为了打造这样的产品，游戏内容创作者（策划、美术等）需要“戴着镣铐跳舞”（在当前的机能下争取更多的创作自由度），而引擎架构合理的游戏可以经得起──也值得进行──反复优化，最终可以提供更多的自由度，这是大作出现的技术前提。 书的作者、译者、出版社的编者，加上读者，大家是因书而结缘的有缘人。因叶兄这本《游戏引擎架构》译著而在线上线下相识的读者们，你们是不是因“了解游戏引擎架构，从而制作/优化好游戏”这样的理想而结了缘呢？ 亲爱的读者，愿你的游戏有一天因谜题巧妙绝伦、趣味超凡、虚拟世界气势磅礴、视觉效果逼真精美等专业因素取得业界褒奖，并得到玩家真诚的赞美。希望届时曾读叶兄这本《游戏引擎架构》译作的你，也可以回馈社会，回馈游戏开发的学习社区，帮助新人。希望你也可以建立微信公众号、博客等，或翻译游戏开发书籍，造福外语不好的读者，所以如果你的外语（英语、日语、韩语之于游戏行业比较重要）水平仍需精进，现在也可以同步加油了！ 腾讯《天天爱消除》游戏团队Leader 沙鹰 @也是沙鹰 译序 数千年以来，艺术家们通过文学、绘画、雕塑、建筑、音乐、舞蹈、戏剧等传统艺术形式充实人类的精神层面。自20世纪中叶，计算机的普及派生出另一种艺术形式──电子游戏。游戏结合了上述传统艺术以及近代科技派生的其他艺术（如摄影、电影、动画），并且完全脱离了艺术欣赏这种单向传递的方式──游戏必然是互动的，“玩家”并不是“读者”、“观众”或“听众”，而是进入游戏世界、感知并对世界做出反应的参与者。 基于游戏的互动本质，游戏的制作通常比其他大众艺术复杂。商业游戏的制作通常需要各种人才的参与，而他们则需要依赖各种工具及科技。游戏引擎便是专门为游戏而设计的工具及科技集成。之所以称为引擎，如同交通工具中的引擎，提供了最核心的技术部分。因为复杂，研发成本高，人们不希望制作每款游戏（或车款）时都重新设计引擎，重用性是游戏引擎的一个重要设计目标。 然而，各游戏本身的性质以及平台的差异，使研发完全通用的游戏引擎变得极困难，甚至不可能。市面上出售的游戏引擎，有一些虽然已经达到很高的技术水平，但在商业应用中，很多时候还是需要因应个别游戏项目对引擎改造、整合、扩展及优化。因此，即使能使用市面上最好的商用引擎或自研引擎，我们仍需要理解当中的架构、各种机制和技术，并且分析及解决在制作中遇到的问题。这些也是译者曾任于上海两家工作室时的主要工作范畴。 选择翻译此著作，主要原因是在阅读中得到共鸣，并且能知悉一些知名游戏作品实际上所采用的方案。有感坊间大部分游戏开发书籍并不是由业内人士执笔，内容只足够应付一些最简单的游戏开发，欠缺宏观比较各种方案，技术与当今实际情况也有很大差距。而一些Gems类丛书虽然偶有好文章，但受形式所限欠缺系统性、全面性。难得本书原作者身为世界一流游戏工作室的资深游戏开发者（注1），在繁重的游戏开发工作外，还在大学教授游戏开发课程以至编写本著作。此外，从与内地同事的交流中，了解到许多从业者不愿意阅读外文书籍。为了普及知识及反馈业界社会，希望能尽绵力。 或许有些人以为本著作是针对单机／游戏机游戏的，并不适合国内以网游为主的环境。但译者认为这是一种误解，许多游戏本身所涉及的技术是具通用性的。例如游戏性相关的游戏性系统、场景管理、人工智能、物理模拟等部分，许多时候也会同时用于网游的前台和后台。现时，一些动作为主、非MMO的国内端游甚至会直接在后台运行传统意义上的游戏引擎。至于前台相关的技术，单机和端游的区别更少。此外，随着近年移动终端的兴起，其硬件性能已超越传统掌上游戏机，开发手游所需的技术与传统掌上游戏机并无太大差异。还可预料，现时单机／游戏机的一些较高级的架构及技术，将在不远的未来着陆移动终端平台。 译者认为，本书涵括游戏开发技术的方方面面，同时适合入门及经验丰富的游戏程序员。书名中的架构二字，并不单是给出一个系统结构图，而是描述每个子系统的需求、相关技术及与其他子系统的关系。对译者本人而言，本书的第11章（动画系统）及第14章（运行时游戏性基础系统）是本书特別精彩之处，含有许多少见于其他书籍的内容。而第10章（渲染引擎）由于是游戏引擎中的一个极大的部分，有限的篇幅可能未能覆盖广度及深度，推荐读者参考[1]（注2），人工智能方面也需参考其他专著。 本译作采用LaTeX排版（注3），以Inkscape编译矢量图片。为了令阅读更流畅，内文中的网址都统一改以脚注标示。另外，由于现时游戏开发相关的文献以英文为主，而且游戏开发涉及的知识面很广，本译作尽量以括号形式保留英文术语。为了方便读者查找内容，在附录中增设中英文双向索引（索引条目与原著的不同）。 本人在香港成长学习及工作，至2008年才赴内地游戏工作室工作，不黯内地的中文写作及用字习惯，翻译中曾遇到不少困难。有幸得到出版社人员以及良师益友的帮助，才能完成本译作。特别感谢周筠老师支持本作的提案，并耐心地给予协助及鼓励。编辑张春雨老师和卢鸫翔老师，以及好友余晟给予了大量翻译上的知识及指导。也感谢游戏业界专家云风、大宝和Dave给予了许多宝贵意见。此书的翻译及排版工作比预期更花时间，感谢妻子及儿女们的体谅。此次翻译工作历时三年半，因工作及家庭事宜导致严重延误，唯有在翻译及排版工作上更尽心尽力，希望求得等待此译作的读者们谅解。无论是批评或建议，诚希阁下通过电邮miloyip@gmail.com、新浪微博、豆瓣等渠道不吝赐教。 叶劲峰（Milo Yip） 2013年10月 原作者是顽皮狗（Naughty Dog）《神秘海域（Uncharted）》系列的通才程序员、《最后生还者（The Last of Us）》的首席程序员，之前还曾在EA和Midway工作。 中括号表示引用附录中的参考文献。一些参考条目加入了其中译本的信息。 具体是使用CTEX套装，它是在MiKTeX的基础上增加中文的支持。 前言 最早的电子游戏完全由硬件构成，但微处理器（microprocessor）的高速发展完全改变了游戏的面貌。现在的游戏是在多用途的PC和专门的电子游戏主机（video game console）上玩的，凭借软件带来绝妙的游戏体验。从最初的游戏诞生至今已有半个世纪，但很多人仍然认为游戏是一个未成熟的产业。即使游戏可能是个年轻的产业，若仔细观察，也会发现它正在高速发展。 现时游戏已成为一个上百亿美元的产业，覆盖不同年龄、性别的广泛受众。 千变万化的游戏，可以分为从纸牌游戏到大型多人在线游戏（massively multiplayer online game，MMOG）等多个种类（category）和“类型（genre）”（注1），也可以运行在任何装有微芯片（microchip）的设备上 。你现在可以在PC、手机及多种特别为游戏而设计的手持/电视游戏主机上玩游戏。家用电视游戏通常代表最尖端的游戏科技，又由于它们是周期性地推出新版本，因此有游戏机“世代”（generation）的说法。最新一代（注2）的游戏机包括微软的Xbox 360和索尼的PlayStation 3，但一定不可忽视长盛不衰的PC，以及最近非常流行的任天堂Wii。 最近，剧增的下载式休闲游戏，使这个多样化的商业游戏世界变得更复杂。虽然如此，大型游戏仍然是一门大生意。今天的游戏平台非常复杂，有难以置信的运算能力，这使软件的复杂度得以进一步提升。所有这些先进的软件都需要由人创造出来，这导致团队人数增加，开发成本上涨。随着产业变得成熟，开发团队要寻求更好、更高效的方式去制作产品，可复用软件（reusable software）和中间件（middleware）便应运而生，以补偿软件复杂度的提升。 由于有这么多风格迥异的游戏及多种游戏平台，因此不可能存在单一理想的软件方案。然而，业界已经发展出一些模式 ，也有大量的潜在方案可供选择。现今的问题是如何找到一个合适的方案去迎合某个项目的需要。再进一步，开发团队必须考虑项目的方方面面，以及如何把各方面集成。对于一个崭新的游戏设计，鲜有可能找到一个完美搭配游戏设计各方面的软件包。 现时业界内的老手，入行时都是“开荒牛”。我们这代人很少是计算机科学专业出身（Matt的专业是航空工程、Jason的专业是系统设计工程），但现时很多学院已设有游戏开发的课程和学位。时至今日，为了获取有用的游戏开发信息，学生和开发者必须找到好的途径。对于高端的图形技术，从研究到实践都有大量高质量的信息。可是，这些信息经常不能直接应用到游戏的生产环境，或者没有一个生产级质量的实现。对于图形以外的游戏开发技术，市面上有一些所谓的入门书籍，没提及参考文献就描述很多内容细节，像自己发明的一样。这种做法根本没有用处，甚至经常带有不准确的内容。另一方面，市场上有一些高端的专门领域书籍，例如物理、碰撞、人工智能等。可是，这类书或者啰嗦到让你难以忍受，或者高深到让部分读者无法理解，又或者内容过于零散而难于融会贯通。有一些甚至会直接和某项技术挂钩，软硬件一旦改动，其内容就会迅速过时。 此外，互联网也是收集相关知识的绝佳工具。可是，除非你确实知道要找些什么，否则断链、不准确的资料、质量差的内容也会成为学习障碍。 好在，我们有Jason Gregory，他是一位拥有在顽皮狗（Naughty Dog）工作经验的业界老手，而顽皮狗是全球高度瞩目的游戏工作室之一。Jason在南加州大学教授游戏编程课程时，找不到概括游戏架构的教科书。值得庆幸的是，他承担了这个任务，填补了这个空白。 Jason把应用到实际发行游戏的生产级别知识，以及整个游戏开发的大局编集于本书。他凭经验，不仅融汇了游戏开发的概念和技巧，还用实际的代码示例及实现例子去说明怎样贯通知识来制作游戏。本书的引用及参考文献可以让读者更深入探索游戏开发过程的各方面。虽然例子经常是基于某些技术的，但是概念和技巧是用来实际创作游戏的，它们可以超越个别引擎或API的束缚。 本书是一本我们入行做游戏时想要的书。我们认为本书能让入门者增长知识，也能为有经验者开拓更大的视野。 Jeff Lander（注3） Matthew Whiting（注4） 译注：Genre一词在文学中为体裁。电影和游戏里通常译作类型。不同的游戏类型可见1.2节。 译注：按一般说法，2005年至今属于第7个游戏机世代。这3款游戏机的发行年份为Xbox 360（2005）、PlayStation 3（2006）、Wii（2006）。有关游戏机世代可参考维基百科。 译注：Jeff Lander现时为Darwin 3D公司的首席技术总监、Game Tech公司创始人，曾为艺电首席程序员、Luxoflux公司游戏性及动画技术程序员。 译注：Matthew Whiting现时为Wholesale Algorithms公司程序员，曾为Luxoflux公司首席软件工程师、Insomniac Games公司程序员。 序言 欢迎来到《游戏引擎架构》世界。本书旨在全面探讨典型商业游戏引擎的主要组件。游戏编程是一个庞大的主题，有许多内容需要讨论。不过相信你会发现，我们讨论的深度将足以使你充分理解本书所涵盖的工程理论及常用实践的方方面面。话虽如此，令人着迷的漫长游戏编程之旅其实才刚刚启程。与此相关的每项技术都包含丰富内容，本书将为你打下基础，并引领你进入更广阔的学习空间。 本书焦点在于游戏引擎的技术及架构。我们会探讨商业游戏引擎中，各个子系统的相关理论，以及实现这些理论所需要的典型数据结构、算法和软件接口。游戏引擎与游戏的界限颇为模糊。我们将把注意力集中在引擎本身，包括多个低阶基础系统（low-level foundation system）、渲染引擎（rendering engine）、碰撞系统（collision system）、物理模拟（physics simulation）、人物动画（character animation），及一个我称为游戏性基础层（gameplay foundation layer）的深入讨论。此层包括游戏对象模型（game object model）、世界编辑器（world editor）、事件系统（event system）及脚本系统（scripting system）。我们也将会接触游戏性编程（gameplay programming）的多个方面，包括玩家机制（player mechanics）、摄像机（camera）及人工智能（artificial intelligence，AI）。然而，这类讨论会被限制在游戏性系统和引擎接口范围。 本书可以作为大学中等级游戏程序设计中两到三门课程的教材。当然，本书也适合软件工程师、业余爱好者、自学的游戏程序员，以及游戏行业从业人员。通过阅读本书，资历较浅的游戏程序员可以巩固他们所学的游戏数学、引擎架构及游戏科技方面的知识。专注某一领域的资深程序员也能从本书更为全面的介绍中获益。 为了更好地学习本书内容，你需要掌握基本的面向对象编程概念并至少拥有一些C++编程经验。尽管游戏行业已经开始尝试使用一些新的、令人兴奋的编程语言，然而工业级的3D游戏引擎仍然是用C或C++编写的，任何认真的游戏程序员都应该掌握C++。我们将在第3章重温一些面向对象编程的基本原则，毫无疑问，你还会从本书学到一些C++的小技巧，不过C++的基础最好还是通过阅读[39]、[31]及[32]来获得。如果你对C++已经有点生疏，建议你在阅读本书的同时，最好能重温这几本或者类似书籍。如果你完全没有C++经验，在看本书之前，可以考虑先阅读[39]的前几章，或者尝试学习一些C++的在线教程。 学习编程技能最好的方法就是写代码。在阅读本书时，强烈建议你选择一些特别感兴趣的主题付诸实践。举例来说，如果你觉得人物动画很有趣，那么可以首先安装OGRE，并测试一下它的蒙皮动画示范。接着还可以尝试用OGRE实现本书谈及的一些动画混合技巧。下一步你可能会打算用游戏手柄控制人物在平面上行走。等你能玩转一些简单的东西了，就应该以此为基础，继续前进！之后可以转移到另一个游戏技术范畴，周而复始。这些项目是什么并不重要，重要的是你在实践游戏编程的艺术，而不是纸上谈兵。 游戏科技是一个活生生、会呼吸的家伙 ，永远不可能将之束缚于书本之上 。因此，附加的资源、勘误、更新、示例代码、项目构思等已经发到本书的网站。 目录 推荐序1 iii推荐序2 v译序 vii序言 xvii前言 xix致谢 xxi第一部分 基础 1第1章 导论 31.1 典型游戏团队的结构 41.2 游戏是什么 71.3 游戏引擎是什么 101.4 不同游戏类型中的引擎差异 111.5 游戏引擎概观 221.6 运行时引擎架构 271.7 工具及资产管道 46第2章 专业工具 532.1 版本控制 532.2 微软Visual Studio 612.3 剖析工具 782.4 内存泄漏和损坏检测 792.5 其他工具 80第3章 游戏软件工程基础 833.1 重温C++及最佳实践 833.2 C/C++的数据、代码及内存 903.3 捕捉及处理错误 118第4章 游戏所需的三维数学 1254.1 在二维中解决三维问题 1254.2 点和矢量 1254.3 矩阵 1394.4 四元数 1564.5 比较各种旋转表达方式 1644.6 其他数学对象 1684.7 硬件加速的SIMD运算 1734.8 产生随机数 180第二部分 低阶引擎系统 183第5章 游戏支持系统 1855.1 子系统的启动和终止 1855.2 内存管理 1935.3 容器 2085.4 字符串 2255.5 引擎配置 234第6章 资源及文件系统 2416.1 文件系统 2416.2 资源管理器 251第7章 游戏循环及实时模拟 2777.1 渲染循环 2777.2 游戏循环 2787.3 游戏循环的架构风格 2807.4 抽象时间线 2837.5 测量及处理时间 2857.6 多处理器的游戏循环 2967.7 网络多人游戏循环 304第8章 人体学接口设备（HID） 3098.1 各种人体学接口设备 3098.2 人体学接口设备的接口技术 3118.3 输入类型 3128.4 输出类型 3168.5 游戏引擎的人体学接口设备系统 3188.6 人体学接口设备使用实践 332第9章 调试及开发工具 3339.1 日志及跟踪 3339.2 调试用的绘图功能 3379.3 游戏内置菜单 3449.4 游戏内置主控台 3479.5 调试用摄像机和游戏暂停 3489.6 作弊 3489.7 屏幕截图及录像 3499.8 游戏内置性能剖析 3499.9 游戏内置的内存统计和泄漏检测 356第三部分 图形及动画 359第10章 渲染引擎 36110.1 采用深度缓冲的三角形光栅化基础 36110.2 渲染管道 40410.3 高级光照及全局光照 42610.4 视觉效果和覆盖层 43810.5 延伸阅读 446第11章 动画系统 44711.1 角色动画的类型 44711.2 骨骼 45211.3 姿势 45411.4 动画片段 45911.5 蒙皮及生成矩阵调色板 47111.6 动画混合 47611.7 后期处理 49311.8 压缩技术 49611.9 动画系统架构 50111.10 动画管道 50211.11 动作状态机 51511.12 动画控制器 535第12章 碰撞及刚体动力学 53712.1 你想在游戏中加入物理吗 53712.2 碰撞/物理中间件 54212.3 碰撞检测系统 54412.4 刚体动力学 56912.5 整合物理引擎至游戏 60112.6 展望：高级物理功能 616第四部分 游戏性 617第13章 游戏性系统简介 61913.1 剖析游戏世界 61913.2 实现动态元素：游戏对象 62313.3 数据驱动游戏引擎 62613.4 游戏世界编辑器 627第14章 运行时游戏性基础系统 63714.1 游戏性基础系统的组件 63714.2 各种运行时对象模型架构 64014.3 世界组块的数据格式 65714.4 游戏世界的加载和串流 66314.5 对象引用与世界查询 67014.6 实时更新游戏对象 67614.7 事件与消息泵 69014.8 脚本 70714.9 高层次的游戏流程 726第五部分 总结 727第15章 还有更多内容吗 72915.1 一些未谈及的引擎系统 72915.2 游戏性系统 730参考文献 733中文索引 737英文索引 755 参考文献 Tomas Akenine-Moller, Eric Haines, and Naty Hoffman. Real-Time Rendering (3rd Edition). Wellesley, MA: A K Peters, 2008. 中译本：《实时计算机图形学（第2版）》，普建涛译，北京大学出版社，2004. Andrei Alexandrescu. Modern C++ Design: Generic Programming and Design Patterns Applied. Resding, MA: Addison-Wesley, 2001. 中译本：《C++设计新思维：泛型编程与设计模式之应用》，侯捷/於春景译，华中科技大学出版社，2003. Grenville Armitage, Mark Claypool and Philip Branch. Networking and Online Games: Understanding and Engineering Multiplayer Internet Games. New York, NY: John Wiley and Sons, 2006. James Arvo (editor). Graphics Gems II. San Diego, CA: Academic Press, 1991. Grady Booch, Robert A. Maksimchuk, Michael W. Engel, Bobbi J. Young, Jim Conallen, and Kelli A. Houston. Object-Oriented Analysis and Design with Applications (3rd Edition). Reading, MA: Addison-Wesley, 2007. 中译本：《面向对象分析与设计（第3版）》，王海鹏/潘加宇译，电子工业出版社，2012. Mark DeLoura (editor). Game Programming Gems. Hingham, MA: Charles River Media, 2000. 中译本：《游戏编程精粹 1》， 王淑礼译，人民邮电出版社，2004. Mark DeLoura (editor). Game Programming Gems 2. Hingham, MA: Charles River Media, 2001. 中译本：《游戏编程精粹 2》，袁国忠译，人民邮电出版社，2003. Philip Dutré, Kavita Bala and Philippe Bekaert. Advanced Global Illumination (2nd Edition). Wellesley, MA: A K Peters, 2006. David H. Eberly. 3D Game Engine Design: A Practical Approach to Real-Time Computer Graphics. San Francisco, CA: Morgan Kaufmann, 2001. 国内英文版：《3D游戏引擎设计：实时计算机图形学的应用方法（第2版）》，人民邮电出版社，2009. David H. Eberly. 3D Game Engine Architecture: Engineering Real-Time Applications with Wild Magic. San Francisco, CA: Morgan Kaufmann, 2005. David H. Eberly. Game Physics. San Francisco, CA: Morgan Kaufmann, 2003. Christer Ericson. Real-Time Collision Detection. San Francisco, CA: Morgan Kaufmann, 2005. 中译本：《实时碰撞检测算法技术》，刘天慧译，清华大学出版社，2010. Randima Fernando (editor). GPU Gems: Programming Techniques, Tips and Tricks for Real-Time Graphics. Reading, MA: Addison-Wesley, 2004. 中译本：《GPU精粹：实时图形编程的技术、技巧和技艺》，姚勇译，人民邮电出版社，2006. James D. Foley, Andries van Dam, Steven K. Feiner, and John F. Hughes. Computer Graphics: Principles and Practice in C (2nd Edition). Reading, MA: Addison-Wesley, 1995. 中译本：《计算机图形学原理及实践──C语言描述》，唐泽圣/董士海/李华/吴恩华/汪国平译，机械工业出版社，2004. Grant R. Fowles and George L. Cassiday. Analytical Mechanics (7th Edition). Pacific Grove, CA: Brooks Cole, 2005. John David Funge. AI for Games and Animation: A Cognitive Modeling Approach. Wellesley, MA: A K Peters, 1999. Erich Gamma, Richard Helm, Ralph Johnson, and John M. Vlissiddes. Design Patterns: Elements of Reusable Object-Oriented Software. Reading, MA: Addison-Wesley, 1994. 中译本：《设计模式：可复用面向对象软件的基础》，李英军/马晓星/蔡敏/刘建中译，机械工业出版社，2005. Andrew S. Glassner (editor). Graphics Gems I. San Francisco, CA: Morgan Kaufmann, 1990. Paul S. Heckbert (editor). Graphics Gems IV. San Diego, CA: Academic Press, 1994. Maurice Herlihy, Nir Shavit. The Art of Multiprocessor Programming. San Francisco, CA: Morgan Kaufmann, 2008. 中译本：《多处理器编程的艺术》，金海/胡侃译，机械工业出版社，2009. Roberto Ierusalimschy, Luiz Henrique de Figueiredo and Waldemar Celes. Lua 5.1 Reference Manual. Lua.org, 2006. Roberto Ierusalimschy. Programming in Lua, 2nd Edition. Lua.org, 2006. 中译本：《Lua程序设计（第2版）》，周惟迪译，电子工业出版社，2008. Isaac Victor Kerlow. The Art of 3-D Computer Animation and Imaging (2nd Edition). New York, NY: John Wiley and Sons, 2000. David Kirk (editor). Graphics Gems III. San Francisco, CA: Morgan Kaufmann, 1994. Danny Kodicek. Mathematics and Physics for Game Programmers. Hingham, MA: Charles River Media, 2005. Raph Koster. A Theory of Fun for Game Design. Phoenix, AZ: Paraglyph, 2004. 中译本：《快乐之道：游戏设计的黄金法则》，姜文斌等译，百家出版社，2005. John Lakos. Large-Scale C++ Software Design. Reading, MA: Addison-Wesley, 1995. 中译本：《大规模C++程序设计》，李师贤/明仲/曾新红/刘显明译，中国电力出版社，2003. Eric Lengyel. Mathematics for 3D Game Programming and Computer Graphics (2nd Edition). Hingham, MA: Charles River Media, 2003. Tuoc V. Luong, James S. H. Lok, David J. Taylor and Kevin Driscoll. Internationalization: Developing Software for Global Markets. New York, NY: John Wiley & Sons, 1995. Steve Maguire. Writing Solid Code: Microsoft's Techniques for Developing Bug Free C Programs. Bellevue, WA: Microsoft Press, 1993. 国内英文版：《编程精粹：编写高质量C语言代码》，人民邮电出版社，2009. Scott Meyers. Effective C++: 55 Specific Ways to Improve Your Programs and Designs (3rd Edition). Reading, MA: Addison-Wesley, 2005. 中译本：《Effective C++：改善程序与设计的55个具体做法（第3版）》，侯捷译，电子工业出版社，2011. Scott Meyers. More Effective C++: 35 New Ways to Improve Your Programs and Designs. Reading, MA: Addison-Wesley, 1996. 中译本：《More Effective C++：35个改善编程与设计的有效方法（中文版）》，侯捷译，电子工业出版社，2011. Scott Meyers. Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library. Reading, MA: Addison-Wesley, 2001. 中译本：《Effective STL：50条有效使用STL的经验》，潘爱民/陈铭/邹开红译，电子工业出版社，2013. Ian Millington. Game Physics Engine Development. San Francisco, CA: Morgan Kaufmann, 2007. Hubert Nguyen (editor). GPU Gems 3. Reading, MA: Addison-Wesley, 2007. 中译本：《GPU精粹3》，杨柏林/陈根浪/王聪译，清华大学出版社，2010. Alan W. Paeth (editor). Graphics Gems V. San Francisco, CA: Morgan Kaufmann, 1995. C. Michael Pilato, Ben Collins-Sussman, and Brian W. Fitzpatrick. Version Control with Subversion (2nd Edition). Sebastopol , CA: O'Reilly Media, 2008. （常被称作“The Subversion Book”，线上版本.） 国内英文版：《使用Subversion进行版本控制》，开明出版社，2009. Matt Pharr (editor). GPU Gems 2: Programming Techniques for High-Performance Graphics and General-Purpose Computation. Reading, MA: Addison-Wesley, 2005. 中译本：《GPU精粹2：高性能图形芯片和通用计算编程技巧》，龚敏敏译，清华大学出版社，2007. Bjarne Stroustrup. The C++ Programming Language, Special Edition (3rd Edition). Reading, MA: Addison-Wesley, 2000. 中译本《C++程序设计语言（特别版）》，裘宗燕译，机械工业出版社，2010. Dante Treglia (editor). Game Programming Gems 3. Hingham, MA: Charles River Media, 2002. 中译本：《游戏编程精粹3》，张磊译，人民邮电出版社，2003. Gino van den Bergen. Collision Detection in Interactive 3D Environments. San Francisco, CA: Morgan Kaufmann, 2003. Alan Watt. 3D Computer Graphics (3rd Edition). Reading, MA: Addison Wesley, 1999. James Whitehead II, Bryan McLemore and Matthew Orlando. World of Warcraft Programming: A Guide and Reference for Creating WoW Addons. New York, NY: John Wiley & Sons, 2008. 中译本：《魔兽世界编程宝典：World of Warcraft Addons完全参考手册》，杨柏林/张卫星/王聪译，清华大学出版社，2010. Richard Williams. The Animator's Survival Kit. London, England: Faber & Faber, 2002. 中译本：《原动画基础教程：动画人的生存手册》，邓晓娥译，中国青年出版社，2006. 勘误 第1次印册（2014年2月） P.xviii: 译注中 Wholesale Algoithms -> Wholesale Algorithms P.10: 最后一段第一行 微软的媒体播放器 -> 微软的Windows Media Player (多谢读者OpenGPU来函指正) P.15: 1.4.3节第三点 按妞 -> 按钮 (多谢读者一个小小凡人来函指正) P.40: 正文最后一行 按扭 -> 按钮 P.50: 1.7.8节第二节第一行 同是 -> 同时 (多谢读者czfdd来函指正) P.98: 代码 writeExampleStruct(Example& ex, Stream& ex) 中 Stream& ex -> Stream& stream (多谢读者Snow来函指正) P.106: 第一段中有六处 BBS -> BSS，最后一段代码的注释也有同样错误 (多谢读者trout来函指正) P.119: 译注中 软体工程 -> 软件工程 (多谢读者Snow来函指正) P.214: 正文第一段有两处 虚内存 -> 虚拟内存 (多谢读者Snow来函指正) P.216: 脚注24应标明为译注 (多谢读者Snow来函指正) P.221: 第一段代码的第二个断言应为 ASSERT(link.m_pPrev != NULL); (多谢读者Snow来函指正) P.230: 5.4.4.1节 第二段 软体 -> 软件 P.286: 脚注4应标明为译注 (多谢读者Snow来函指正) P.322: 第二段 按扭事件字 -> 按钮事件 P.349: 9.8节第二段第二行两处 部析器 -> 剖析器 (多谢读者Snow来函指正) P.738-572: 双数页页眉 参考文献 -> 中文索引 P.755-772: 双数页页眉 参考文献 -> 英文索引 P.755: kd tree项应归入K而不是Symbols 以上的错误已于第2次印册中修正。 第2次印册及之前 P.11: 第四行 细致程度 -> 层次细节 (这是level-of-detail/LOD的内地通译，多谢读者OpenGPU来函指正) P.12: 正文第一段及图1.2标题 使命之唤 -> 使命召唤 (多谢读者OpenGPU来函指正) P.12: 正文第一段 战栗时空 -> 半条命 (多谢读者OpenGPU来函指正) P.16: 第一点 表面下散射 -> 次表面散射 (多谢读者OpenGPU来函指正) P.17: 1.4.4节第五行 次文化 -> 亚文化 (此译法在内地更常用。多谢读者OpenGPU来函提示) P.22: 战栗时空 -> 半条命 P.24: 战栗时空2 -> 半条命2 P.34: 1.6.8.2节第一行 提呈 -> 提交 (这术语在本书其他地方都写作提交。多谢读者OpenGPU来函提示) P.35: 第七行 提呈 -> 提交 (这术语在本书其他地方都写作提交。多谢读者OpenGPU来函提示) P.50: 战栗时空2 -> 半条命2 P.365: 第四段第二行: 细致程度 -> 层次细节 P.441: 10.4.3.2节第三行 细致程度 -> 层次细节 P.494: sinusiod -> sinusoid (多谢读者OpenGPU来函指正) P.511: 11.10.4节第一行 谈入 -> 淡入 (多谢读者Snow来函指正) P.541: 战栗时空2 -> 半条命2 P.627: 战栗时空2 -> 半条命2 P.654: 第二行 建康值 -> 血量 (原来是改正错别字，但译者发现应改作前后统一使用的“血量”。多谢读者Snow来函指正) P.692: 第二行 内部分式 -> 内部方式 (多谢读者Snow来函指正) P.696: 14.7.6节第四行 不设实际 -> 不切实际 (多谢读者Snow来函指正) 以上的错误已于第3次印册中修正。 其他意见 P.220: 正文第一段 m_root.m_pElement 和 P.218 第一段代码中的 m_pElem 不统一。原文有此问题，但因为它们是不同的struct，暂不列作错误。 (多谢读者Snow来函提示) P.331: 8.5.8节第二段中 “反覆”较常见的写法为“反复”，但前者也是正确的，暂不列作错误。 (多谢读者Snow来函提示) P.390: 10.1.3.3节静态光照第二段中“取而代之，我们会使用一张光照纹理贴到所有受光源影响范围内的物体上。这样做能令动态物体经过光源时得到正确的光照。” 后面的一句与前句好像难以一起理解。译者认为，作者应该是指，使用同一静态光源去为静态物件生成光照纹理，以及用于动态对象的光照，能使两者的效果维持一致性。译者会考虑对译文作出改善或加入译注解译。（多谢读者店残来函查询） P.689: 第五行 并行处理世代 -> 并行处理时代 是对era较准确的翻译。 (多谢读者Snow来函提示) 本篇文章为转载内容。原文链接：https://blog.csdn.net/mypongo/article/details/38388381。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...以使用v-on指令来关联动作 <input v-on:keydown.enter="handleEnter" /> // 然后在methods中定义处理函数 methods: { handleEnter: function () { // 处理回车键动作的代码 } } 如上面的代码所示，我们在input标签上使用了v-on指令，并且设定了keydown.enter作为关联的动作。这表示我们希望当用户按下回车键时，能够引发handleEnter函数。在这个函数中，我们可以编写处理回车键动作的代码，例如提交表单、执行搜索等操控。 当然，除了使用v-on指令外，我们还可以使用简写的@符号来关联动作： <input @keydown.enter="handleEnter" /> 这两种方式的效果是一样的。需要注意的是，keydown.enter只会回应用户按下回车键的动作，而keyup.enter则会在用户释放回车键时引发。因此，我们需要根据具体的需求来选择使用哪一种方式。

...在 Docker 中具体表现为将主机（物理机或虚拟机）上的某个端口与容器内部服务监听的端口进行关联绑定。通过端口映射，外部客户端可以通过访问主机的 IP 地址及指定端口号，间接访问到容器内运行的服务，实现了容器内外网络通信的桥梁作用。 docker run , docker run 是 Docker 容器生命周期管理中的一个重要命令，用于启动一个新的容器实例。该命令可以一次性完成拉取镜像、创建容器并启动容器等一系列操作。在本文中，docker run -p 参数组合被用来执行端口映射，即将主机端口与容器端口对应起来，使得外部可以直接访问主机IP和指定端口来连接到容器内部的服务。 NetworkSettings.Networks , 在 Docker 容器的 inspect 输出信息中，NetworkSettings.Networks 表示容器在网络配置方面的详细信息，包括容器加入的所有网络及其对应的网络接口设置。在本文中，通过 docker inspect 命令结合 --format 参数和特定模板语法查询容器的 IPAddress，获取的是当前容器在某一网络下的内部 IP 地址，这对于需要直接基于容器内部 IP 访问其服务的场景尤为关键。

...启或删除时，与数据卷关联的数据能够得到保留。在文章中，通过 -v 参数挂载数据卷，将主机系统的本地目录映射到容器内部的目录，从而确保应用状态的持久性和多个容器之间的数据交互。 只读文件系统（Readonly file system） , 在 Docker 容器运行时，可以通过设置选项使容器内的文件系统变为只读模式。这意味着在该模式下，容器内所有文件和目录都无法进行任何写入操作，以增强安全性或满足特定场景需求。在本文中，当用户尝试在一个使用了 --read-only 选项启动的 Docker 容器内对挂载的数据卷进行写入操作时，会遇到 \ Readonly file system\ 的错误提示，因为在这种情况下，容器不允许对任何包括挂载目录在内的文件系统进行修改。