[MemCache加锁机制]的搜索结果

...通过掌握该特性的运行机制，相信大家可以做到在正确的时机使用该特性，而非滥用或因恐惧弃而不用。 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。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...的广泛应用，内存映射机制对于提高系统资源利用率、实现高效的数据共享与交换具有重要意义。 例如，在Docker和Kubernetes等容器平台中，mmap系统调用被用于实现容器内部进程与宿主机文件系统的高效交互，以及容器间共享内存通信。通过内存映射，容器可以将宿主机上的持久化存储直接加载到内存中，实现数据的快速读取与更新，极大地提升了I/O性能。 此外，针对云原生环境下的大规模并行计算和实时数据处理场景，研究者们正在探索如何优化mmap以适应更高的并发需求和更低延迟的要求。2021年，有研究人员提出了一种改进的内存映射策略，旨在减少在高负载环境下由于频繁的内存映射操作导致的系统开销，并已在分布式数据库和大数据分析应用中取得了显著效果。 同时，内存映射的安全性问题也引起了业界的关注。今年早些时候，一项安全研究报告揭示了利用mmap进行提权攻击的新方法，再次提醒开发者在享受内存映射带来的便利时，也需要关注其潜在的安全风险，并采取相应的防御措施。 总之，内存映射作为底层系统调用的重要组成部分，其发展与优化将持续影响着整个软件生态系统的性能表现与安全性，值得广大开发者和技术研究者深入探究和实践。

...NET/C 的异常机制依然有一些疑惑。那么，可以阅读本文。 本文适用于已经入门 .NET/C 开发，已经开始在实践中抛出和捕获异常，但是对 .NET 异常机制的用法以及原则比较模糊的小伙伴。通过阅读本文，小伙伴们可以迅速在项目中使用比较推荐的异常处理原则来处理异常。 本文内容 快速了解 .NET 的异常机制 Exception 类 捕捉异常 引发异常 创建自定义异常 finally 异常堆栈跟踪 异常处理原则 try-catch-finally 该不该引发异常？ 该不该捕获异常？ 应用程序全局处理异常 抛出哪些异常？ 异常的分类 其他 一些常见异常的原因和解决方法 AccessViolationException 快速了解 .NET 的异常机制 Exception 类 我们大多数小伙伴可能更多的使用 Exception 的类型、Message 属性、StackTrace 以及内部异常来定位问题，但其实 Exception 类型还有更多的信息可以用于辅助定位问题。 Message 用来描述异常原因的详细信息 如果你捕捉到了异常，一般使用这段描述能知道发生的大致原因。 如果你准备抛出异常，在这个信息里面记录能帮助调试问题的详细文字信息。 StackTrace 包含用来确定错误位置的堆栈跟踪（当有调试信息如 PDB 时，这里就会包含源代码文件名和源代码行号） InnerException 包含内部异常信息 Source 这个属性包含导致错误的应用程序或对象的名称 Data 这是一个字典，可以存放基于键值的任意数据，帮助在异常信息中获得更多可以用于调试的数据 HelpLink 这是一个 url，这个 url 里可以提供大量用于说明此异常原因的信息 如果你自己写一个自定义异常类，那么你可以在自定义的异常类中记录更多的信息。然而大多数情况下我们都考虑使用 .NET 中自带的异常类，因此可以充分利用 Exception 类中的已有属性在特殊情况下报告更详细的利于调试的异常信息。 捕捉异常 捕捉异常的基本语法是： try{// 可能引发异常的代码。}catch (FileNotFoundException ex){// 处理一种类型的异常。}catch (IOException ex){// 处理另一种类的异常。} 除此之外，还有 when 关键字用于筛选异常： try{// 可能引发异常的代码。}catch (FileNotFoundException ex) when (Path.GetExtension(ex.FileName) is ".png"){// 处理一种类型的异常，并且此文件扩展名为 .png。}catch (FileNotFoundException ex){// 处理一种类型的异常。} 无论是否有带 when 关键字，都是前面的 catch 块匹配的时候执行匹配的 catch 块而无视后面可能也匹配的 catch 块。 如果 when 块中抛出异常，那么此异常将被忽略，when 中的表达式值视为 false。有个但是，请看：.NET Framework 的 bug？try-catch-when 中如果 when 语句抛出异常，程序将彻底崩溃 - walterlv。 引发异常 引发异常使用 throw 关键字。只是注意如果要重新抛出异常，请使用 throw; 语句或者将原有异常作为内部异常。 创建自定义异常 如果你只是随便在业务上创建一个异常，那么写一个类继承自 Exception 即可： public class MyCustomException : Exception{public string MyCustomProperty { get; }public MyCustomException(string customProperty) => MyCustomProperty = customProperty;} 不过，如果你需要写一些比较通用抽象的异常（用于被继承），或者在底层组件代码中写自定义异常，那么就建议考虑写全异常的所有构造函数，并且加上可序列化： [Serializable]public class InvalidDepartmentException : Exception{public InvalidDepartmentException() : base() { }public InvalidDepartmentException(string message) : base(message) { }public InvalidDepartmentException(string message, Exception innerException) : base(message, innerException) { }// 如果异常需要跨应用程序域、跨进程或者跨计算机抛出，就需要能被序列化。protected InvalidDepartmentException(SerializationInfo info, StreamingContext context) : base(info, context) { } } 在创建自定义异常的时候，建议： 名称以 Exception 结尾 Message 属性的值是一个句子，用于描述异常发生的原因。 提供帮助诊断错误的属性。 尽量写全四个构造函数，前三个方便使用，最后一个用于序列化异常（新的异常类应可序列化）。 finally 异常堆栈跟踪 堆栈跟踪从引发异常的语句开始，到捕获异常的 catch 语句结束。 利用这一点，你可以迅速找到引发异常的那个方法，也能找到是哪个方法中的 catch 捕捉到的这个异常。 异常处理原则 try-catch-finally 我们第一个要了解的异常处理原则是——明确 try catch finally 的用途！ try 块中，编写可能会发生异常的代码。 最好的情况是，你只将可能会发生异常的代码放到 try 块中，当然实际应用的时候可能会需要额外放入一些相关代码。但是如果你将多个可能发生异常的代码放到一个 try 块中，那么将来定位问题的时候你就会很抓狂（尤其是多个异常还是一个类别的时候）。 catch 块的作用是用来 “恢复错误” 的，是用来 “恢复错误” 的，是用来 “恢复错误” 的。 如果你在 try 块中先更改了类的状态，随后出了异常，那么最好能将状态改回来——这可以避免这个类型或者应用程序的其他状态出现不一致——这很容易造成应用程序“雪崩”。举一个例子：我们写一个程序有简洁模式和专业模式，在从简洁模式切换到专业模式的时候，我们设置 IsProfessionalMode 为 true，但随后出现了异常导致没有成功切换为专业模式；然而接下来所有的代码在执行时都判断 IsProfessionalMode 为 true 状态不正确，于是执行了一些非预期的操作，甚至可能用到了很多专业模式中才会初始化的类型实例（然而没有完成初始化），产生大量的额外异常；我们说程序雪崩了，多数功能再也无法正常使用了。 当然如果任务已全部完成，仅仅在对外通知的时候出现了异常，那么这个时候不需要恢复状态，因为实际上已经完成了任务。 你可能会有些担心如果我没有任何手段可以恢复错误怎么办？那这个时候就不要处理异常！——如果不知道如何恢复错误，请不要处理异常！让异常交给更上一层的模块处理，或者交给整个应用程序全局异常处理模块进行统一处理（这个后面会讲到）。 另外，异常不能用于在正常执行过程中更改程序的流程。异常只能用于报告和处理错误条件。 finally 块的作用是清理资源。 虽然 .NET 的垃圾回收机制可以在回收类型实例的时候帮助我们回收托管资源（例如 FileStream 类打开的文件），但那个时机不可控。因此我们需要在 finally 块中确保资源可被回收，这样当重新使用这个文件的时候能够立刻使用而不会被占用。 一段异常处理代码中可能没有 catch 块而有 finally 块，这个时候的重点是清理资源，通常也不知道如何正确处理这个错误。 一段异常处理代码中也可能 try 块留空，而只在 finally 里面写代码，这是为了“线程终止”安全考虑。在 .NET Core 中由于不支持线程终止因此可以不用这么写。详情可以参考：.NET/C 异常处理：写一个空的 try 块代码，而把重要代码写到 finally 中（Constrained Execution Regions） - walterlv。 该不该引发异常？ 什么情况下该引发异常？答案是——这真的是一个异常情况！ 于是，我们可能需要知道什么是“异常情况”。 一个可以参考的判断方法是——判断这件事发生的频率： 如果这件事并不常见，当它发生时确实代表发生了一个错误，那么这件事情就可以认为是异常。 如果这件事经常发生，代码中正常情况就应该处理这件事情，那么这件事情就不应该被认为是异常（而是正常流程的一部分）。 例如这些情况都应该认为是异常： 方法中某个参数不应该传入 null 时但传入了 null 这是开发者使用这个方法时没有遵循此方法的契约导致的，让开发者改变调用此方法的代码就可以完全避免这件事情发生 而下面这些情况则不应该认为是异常： 用户输入了一串字符，你需要将这串字符转换为数字 用户输入的内容本身就千奇百怪，出现非数字的输入再正常不过了，对非数字的处理本就应该成为正常流程的一部分 对于这些不应该认为是异常的情况，编写的代码就应该尽可能避免异常。 有两种方法来避免异常： 先判断再使用。 例如读取文件之前，先判断文件是否存在；例如读取文件流时先判断是否已到达文件末尾。 如果提前判断的成本过高，可采用 TryDo 模式来完成，例如字符串转数字中的 TryParse 方法，字典中的 TryGetValue 方法。 对极为常见的错误案例返回 null（或默认值），而不是引发异常。极其常见的错误案例可被视为常规控制流。通过在这些情况下返回 NULL（或默认值），可最大程度地减小对应用的性能产生的影响。（后面会专门说 null） 而当存在下列一种或多种情况时，应引发异常： 方法无法完成其定义的功能。 根据对象的状态，对某个对象进行不适当的调用。 请勿有意从自己的源代码中引发 System.Exception、System.SystemException、System.NullReferenceException 或 System.IndexOutOfRangeException。 该不该捕获异常？ 在前面 try-catch-finally 小节中，我们提到了 catch 块中应该写哪些代码，那里其实已经说明了哪些情况下应该处理异常，哪些情况下不应该处理异常。一句总结性的话是——如果知道如何从错误中恢复，那么就捕获并处理异常，否则交给更上层的业务去捕获异常；如果所有层都不知道如何处理异常，就交给全局异常处理模块进行处理。 应用程序全局处理异常 对于 .NET 程序，无论是 .NET Framework 还是 .NET Core，都有下面这三个可以全局处理的异常。这三个都是事件，可以自行监听。 AppDomain.UnhandledException 应用程序域未处理的异常，任何线程中未处理掉的异常都会进入此事件中 当这里能够收到事件，意味着应用程序现在频临崩溃的边缘（从设计上讲，都到这里了，也再没有任何代码能够使得程序从错误中恢复了） 不过也可以配置 legacyUnhandledExceptionPolicy 防止后台线程抛出的异常让程序崩溃退出 建议在这个事件中记录崩溃日志，然后对应用程序进行最后的拯救恢复操作（例如保存用户的文档数据） AppDomain.FirstChanceException 应用程序域中的第一次机会异常 我们前面说过，一个异常被捕获时，其堆栈信息将包含从 throw 块到 catch 块之间的所有帧，而在第一次机会异常事件中，只是刚刚 throw 出来，还没有被任何 catch 块捕捉，因此在这个事件中堆栈信息永远只会包含一帧（不过可以稍微变通一下在第一次机会异常 FirstChanceException 中获取比较完整的异常堆栈） 注意第一次机会异常事件即便异常会被 catch 也会引发，因为它引发在 catch 之前 不要认为异常已经被 catch 就万事大吉可以无视这个事件了。前面我们说过异常仅在真的是异常的情况才应该引发，因此如果这个事件中引发了异常，通常也真的意味着发生了错误（差别只是我们能否从错误中恢复而已）。如果你经常在正常的操作中发现可以通过此事件监听到第一次机会异常，那么一定是应用程序或框架中的异常设计出了问题（可能把正常应该处理的流程当作了异常，可能内部实现代码错误，可能出现了使用错误），这种情况一定是要改代码修 Bug 的。而一些被认为是异常的情况下收到此事件则是正常的。 TaskScheduler.UnobservedTaskException 在使用 async / await 关键字编写异步代码的时候，如果一直有 await 传递，那么异常始终可以被处理到；但中间有异步任务没有 await 导致异常没有被传递的时候，就会引发此事件。 如果在此事件中监听到异常，通常意味着代码中出现了不正确的 async / await 的使用（要么应该修改实现避免异常，要么应该正确处理异常并从中恢复错误） 对于 GUI 应用程序，还可以监听 UI 线程上专属的全局异常： WPF：Application.DispatcherUnhandledException 或者 Dispatcher.UnhandledException Windows Forms：Application.ThreadException 关于这些全局异常的处理方式和示例代码，可以参阅博客： WPF UnhandledException - Iron 的博客 - CSDN博客 抛出哪些异常？ 任何情况下都不应该抛出这些异常： 过于抽象，以至于无法表明其含义 Exception 这可是顶级基类，这都抛出来了，使用者再也无法正确地处理此异常了 SystemException 这是各种异常的基类，本身并没有明确的意义 ApplicationException 这是各种异常的基类，本身并没有明确的意义 由 CLR 引发的异常 NullReferenceException 试图在空引用上执行某些方法，除了告诉实现者出现了意料之外的 null 之外，没有什么其它价值了 IndexOutOfRangeException 使用索引的时候超出了边界 InvalidCastException 表示试图对某个类型进行强转但类型不匹配 StackOverflow 表示栈溢出，这通常说明实现代码的时候写了不正确的显式或隐式的递归 OutOfMemoryException 表示托管堆中已无法分出期望的内存空间，或程序已经没有更多内存可用了 AccessViolationException 这说明使用非托管内存时发生了错误 BadImageFormatException 这说明了加载的 dll 并不是期望中的托管 dll TypeLoadException 表示类型初始化的时候发生了错误 .NET 设计失误 FormatException 因为当它抛出来时无法准确描述到底什么错了 首先是你自己不应该抛出这样的异常。其次，你如果在运行中捕获到了上面这些异常，那么代码一定是写得有问题。 如果是捕获到了上面 CLR 的异常，那么有两种可能： 你的代码编写错误（例如本该判空的代码没有判空，又如索引数组超出界限） 你使用到的别人写的代码编写错误（那你就需要找到它改正，或者如果开源就去开源社区中修复吧） 而一旦捕获到了上面其他种类的异常，那就找到抛这个异常的人，然后对它一帧狂扁即可。 其他的异常则是可以抛出的，只要你可以准确地表明错误原因。 另外，尽量不要考虑抛出聚合异常 AggregateException，而是优先使用 ExceptionDispatchInfo 抛出其内部异常。详见：使用 ExceptionDispatchInfo 捕捉并重新抛出异常 - walterlv。 异常的分类 在 该不该引发异常 小节中我们说到一个异常会被引发，是因为某个方法声称的任务没有成功完成（失败），而失败的原因有四种： 方法的使用者用错了（没有按照方法的契约使用） 方法的执行代码写错了 方法执行时所在的环境不符合预期 简单说来，就是：使用错误，实现错误、环境错误。 使用错误： ArgumentException 表示参数使用错了 ArgumentNullException 表示参数不应该传入 null ArgumentOutOfRangeException 表示参数中的序号超出了范围 InvalidEnumArgumentException 表示参数中的枚举值不正确 InvalidOperationException 表示当前状态下不允许进行此操作（也就是说存在着允许进行此操作的另一种状态） ObjectDisposedException 表示对象已经 Dispose 过了，不能再使用了 NotSupportedException 表示不支持进行此操作（这是在说不要再试图对这种类型的对象调用此方法了，不支持） PlatformNotSupportedException 表示在此平台下不支持（如果程序跨平台的话） NotImplementedException 表示此功能尚在开发中，暂时请勿使用 实现错误： 前面由 CLR 抛出的异常代码主要都是实现错误 NullReferenceException 试图在空引用上执行某些方法，除了告诉实现者出现了意料之外的 null 之外，没有什么其它价值了 IndexOutOfRangeException 使用索引的时候超出了边界 InvalidCastException 表示试图对某个类型进行强转但类型不匹配 StackOverflow 表示栈溢出，这通常说明实现代码的时候写了不正确的显式或隐式的递归 OutOfMemoryException 表示托管堆中已无法分出期望的内存空间，或程序已经没有更多内存可用了 AccessViolationException 这说明使用非托管内存时发生了错误 BadImageFormatException 这说明了加载的 dll 并不是期望中的托管 dll TypeLoadException 表示类型初始化的时候发生了错误 环境错误： IOException 下的各种子类 Win32Exception 下的各种子类 …… 另外，还剩下一些不应该抛出的异常，例如过于抽象的异常和已经过时的异常，这在前面一小结中有说明。 其他 一些常见异常的原因和解决方法 在平时的开发当中，你可能会遇到这样一些异常，它不像是自己代码中抛出的那些常见的异常，但也不包含我们自己的异常堆栈。 这里介绍一些常见这些异常的原因和解决办法。 AccessViolationException 当出现此异常时，说明非托管内存中发生了错误。如果要解决问题，需要从非托管代码中着手调查。 这个异常是访问了不允许的内存时引发的。在原因上会类似于托管中的 NullReferenceException。 参考资料 Handling and throwing exceptions in .NET - Microsoft Docs Exceptions and Exception Handling - C Programming Guide - Microsoft Docs 我的博客会首发于 https://blog.walterlv.com/，而 CSDN 会从其中精选发布，但是一旦发布了就很少更新。 如果在博客看到有任何不懂的内容，欢迎交流。我搭建了 dotnet 职业技术学院 欢迎大家加入。 本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。欢迎转载、使用、重新发布，但务必保留文章署名吕毅（包含链接：https://walterlv.blog.csdn.net/），不得用于商业目的，基于本文修改后的作品务必以相同的许可发布。如有任何疑问，请与我联系。 本篇文章为转载内容。原文链接：https://blog.csdn.net/WPwalter/article/details/94610764。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...情高度关联，所以这套机制非常利于拓展新用户以及促活现有用户。 只需将您应用中的各个功能定义为语义意图 (semantic intent)，便可以充分享受 App Actions 带来的好处。App Actions 中的意图和我们早些时候在 Google Assistant 上推出的语音对谈式动作 (Conversational Action) 是使用同一套通用意图分类，这个分类支持语音控制的音箱、智能屏幕、车载系统、电视、耳机等设备。由于不需要额外的 API 接口，所以只要用户的 Android 平台版本支持，App Actions 就可以正常使用了。 App Actions 很快就会面向开发者发布，如果您希望收到这方面的通知，请点击这里找到相关链接参与订阅。 · Slices 和 App Actions 一同到来的新功能还有 Slices，这个功能可以让您的应用以模块化、富交互的形式插入到多个使用场景中，比如 Google Search 和 Assistant。Slices 支持的交互包括 actions、开关、滑动条、滑动内容等等。 Slices 是让内容与用户联系的极佳方式，所以我们希望它可以在更多的场景中出现。除了在 Android P 上对这个功能进行了平台级别的整合外， Slices 的 API 和模板也加入到了 Android Jetpack 里。Android Jetpack 是我们全新打造的一套创建优秀应用的工具和库，通过 Android Jetpack，您制作的 Slices 能在 Kitkat (API 等级 19) 及更高版本上使用 —— 这覆盖了 95% 的已激活 Android 设备。我们也会定期更新 Slices 的模板来支持更多类型的场景和交互 (比如文本输入)。 请查阅上手指南以了解如何制作 Slices，使用 SliceViewer 工具查看您做好的 Slices。接下来，我们计划进一步拓展其使用场景，包括在其他 app 中展现您的 Slices。 · 通知智能回复 (Smart reply in notifications) 机器智能可以为用户体验带来非常积极的进化，Gmail 和 Inbox 里的智能回复功能已经成功地证明了这一点。在 Android P 中，通知消息也加入了智能回复功能，而且我们准备了 API 让您可以为用户带来更度身的使用感受。用来帮助您更轻松地在通知中生成回复的 ML Kit 很快就会到来，请 点击访问此网站 了解详情。 · 文本识别 (Text Classifier) 在 Android P 中，我们将识别文本的机器学习模型进行了扩展，使得它可以识别出诸如日期或航班号这样的信息，并通过 TextClassifier API 来让开发者使用到这些改进。我们还更新了 Linkify API 来利用文本识别的结果生成链接，并为用户提供了更多点击后的选项，从而让他们得以更快地进行下一步操作。当然，开发者也可以在给文本识别出来的信息添加链接时拥有更多的选项。智能 Linkify 在识别精准度以及速度上都有明显的提升。 这个模型现在正在通过 Google Play 进行更新，所以您的应用使用现有的 API 就可以享受到本次更新所带来的变化。在安装更新完的模型后，设备即可直接在本地识别文本里的各种信息，而且这些识别出来的信息只保存在您的手机上而不会通过网络流传出去。 请点击蓝色字体前往 “Android Developers 官方文档”查看详细说明 简洁 (Simplicity) 在 Android P，我们格外强调简洁，并据此改进 Android 的 UI 从而帮助用户们更流畅、更高效地完成操作。对开发者来说，简洁的系统则会帮助用户更容易查找、使用和管理您的应用。 · 全新系统导航 (New system navigation) 我们为 Android P 设计了全新的系统导航，只需使用下图中这个在所有界面中都能看到的小按钮，即可更轻松地访问手机主屏、概览页以及 Assistant。新导航系统也使多任务切换及发现关联应用变得更加简单。在概览页，用户可以拥有更大的视野来查看他们之前中断的操作，这自然也会让他们更容易找到并回到之前的应用中。概览页也提供了搜索、预测推荐应用以及上文提到的 App Actions，而且只需再多划一次即可进入所有应用的列表。 · 文字放大镜 (Text Magnifier) 在 Android P 中，我们加入了新的放大镜工具 (Magnifier widget)，使选择文本和调整光标位置变得更加轻松。默认情况下，所有继承自 TextView 的类都会自动支持放大镜，但您也可以使用放大镜 API 将它添加到任何自定义的视图上，从而打造更多样化的体验。 · 后台限制 (Background restrictions) 用户可以更加简单地找到并管理那些在后台消耗电量的应用。通过 Android Vitals 积累下来的成果，Android 可以识别那些过度消耗电量的行为，如滥用唤醒锁定等。在 Android P 中，电池设置页面直接列出了这些过度消耗电量的应用，用户只需一次点击就可以限制它们在后台的活动。 一旦应用被限制，那么它的后台任务、警报、服务以及网络访问都会受限。想要避免被限制的话，请留意 Play Console 中的Android Vitals 控制面板，帮助您了解如何提高性能表现以及优化电量消耗。 后台限制能有效保护系统资源不被恶意消耗，从而确保开发者的应用在不同制造商的不同设备上也能拥有一个基础的合理的运行环境。虽然制造商可以在限制列表上额外添加限制的应用，但它们也必须在电池设置页面为用户开放这些限制的控制权。 我们添加了一个标准 API 来帮助应用知晓自己是否被限制，以及一个 ADB 命令来帮助开发者手动限制应用，从而进行测试。具体请参阅相关文档。接下来我们计划在 Play Console 的 Android Vitals 控制面板里添加一个统计数据，以展示应用受到限制的情况。 · 使用动态处理增强音频 (Enhanced audio with Dynamics Processing) Android P 在音频框架里加入了动态处理效果 (Dynamic Processing Effect) 来帮助开发者改善声音品质。通过动态处理，您可以分离出特定频率的声音，降低过大的音量，或者增强那些过小的音量。举例来说，即便说话者离麦克风较远，而且身处嘈杂或者被刺耳的各种环境音包围的地方，您的应用依然可以有效分离并增强他/她的细语。 动态处理 API 提供了多声场、多频段的动态处理效果，包括一个预均衡器、一个多频段压缩器，一个后均衡器以及一个串联的音量限制器。这样您就可以根据用户的喜好或者环境的变化来控制 Android 设备输出的声音。频段数量以及各个声场的开关都完全可控，大多数参数都支持实时控制，如增益、信号的压缩/释放 (attack/release) 时长，阈值等等。 请点击蓝色字体前往 “Android Developers 官方文档”查看详细说明 安全 (Security) · 用户识别提示 (Biometric prompt) Android P 为市面上涌现出来的各种用户识别机制在系统层面提供了统一的使用体验，应用们不再需要自行提供用户识别操作界面，而只需要使用统一的 BiometricPrompt API 即可。这套全新的 API 替代了 DP1 版本中的 FingerprintDialog API，且支持包括指纹识别 (包括屏幕下指纹识别)、面部识别以及虹膜识别，而且所有系统支持的用户识别需求都包含在一个 USE_BIOMETRIC 权限里。FingerprintManager 以及对应的 USE_FINGERPRINT 权限已经被废弃，请开发者尽快转用 BiometricPrompt。 · 受保护的确认操作 (Protected Confirmation) Android P 新增了受保护的确认操作 (Android Protected Confirmation)，这个功能使用可信执行环境 (Trusted Execution Environment, TEE) 来确保一个显示出来的提示文本被真实用户确认。只有在用户确认之后，TEE 才会放行这个文本并可由应用去验证。 · 对私有密钥的增强保护 (Stronger protection for private keys) 我们添加了一个新的 KeyStore 类型，StrongBox。并提供对应的 API 来支持那些提供了防入侵硬件措施的设备，比如独立的 CPU，内存以及安全存储。您可以在 KeyGenParameterSpec 里决定您的密钥是否该交给 StrongBox 安全芯片来保存。 Android P Beta 为用户带来新版本的 Android 需要 Google、芯片供应商以及设备制造商和运营商的共同努力。这个过程中充满了技术挑战，并非一日之功 —— 为了让这个过程更加顺畅，去年我们启动了 Project Treble，并将其包含在 Android Oreo 中。我们与合作伙伴们一直在努力开发这个项目，也已经看到 Treble 所能带来的机遇。 我们宣布，以下 6 家顶级合作伙伴将和我们一起把 Android P Beta 带给全世界的用户，这些设备包括：索尼 Xperia XZ2, 小米 Mi Mix 2S, 诺基亚 7 Plus, Oppo R15 Pro, Vivo X21UD 和 X21, 以及 Essential PH‑1。此外，再加上 Pixel 2, Pixel 2 XL, Pixel 和 Pixel XL，我们希望来自世界各地的早期体验者以及开发者们都能通过这些设备体验到 Android P Beta。 您可查看今天推送的文章查阅支持 beta 体验的合作伙伴和 Pixel 设备清单，并能看到每款设备的详细配置说明。如果您使用 Pixel 设备，现在就可以加入 Android Beta program，然后自动获得最新的 Android P Beta。 马上开始在您喜欢的设备上体验 Android P Beta 吧，欢迎您向我们反馈意见和建议！并请继续关注 Project Treble 的最新动态。 确保 app 兼容 随着越来越多的用户开始体验 Android P Beta，是时候开始测试您 app 的兼容性，以尽早解决在测试中发现的问题并尽快发布更新。请查看迁移手册了解操作步骤以及 Android P 的时间推进表。 请从 Google Play 下载您的应用，并在运行 Android P Beta 的设备或模拟器上测试用户流程。确保您的应用体验良好，并正确处理 Android P 的行为变更。尤其注意动态电量管理、Wi-Fi 权限变化、后台调用摄像头以及传感器的限制、针对应用数据的 SELinux 政策、默认启用 TLS 的变化，以及 Build.SERIAL 限制。 · 公开 API 的兼容性 (Compatibility through public APIs) 针对非 SDK 接口的测试十分重要。正如我们之前所强调的，在 Android P 中，我们将逐渐收紧一些非 SDK 接口的使用，这也要求广大的开发者们，包括 Google 内部的应用团队，使用公开 API。 如果您的应用正在使用私有 Android API 或者库，您需要改为使用 Android SDK 或 NDK 公开的 API。我们在 DP1 里已经对使用私有接口的开发者发出了警告信息，从 Android P Beta 开始，调用非 SDK 接口将会报错 (部分被豁免的私有 API 除外) —— 也就是说您的应用将会遭遇异常，而不再只是警告了。 为了帮助您定位非 SDK API 的使用情况，我们在 StrictMode 里加入了两个新的方法。您可以使用 detectNonSdkApiUsage() 在应用通过反射或 JNI 调用非 SDK API 的时候收到警报，您还可以使用 permitNonSdkApiUsage() 来阻止 StrictMode 针对这些调用报错。这些方法都可助您了解应用调用非 SDK API 的情况，但请注意，即便调用的 API 暂时得到了豁免，最保险的做法依然是尽快放弃对它们的使用。 如果您确实遇到了公开 API 无法满足需求的情况，请立刻告知我们。更多详细内容请查看相关文档。 · 凹口屏测试 (Test with display cutout) 针对凹口屏测试您的应用也十分重要。现在您可以在运行 Android P Beta 的合作伙伴机型上测试，确保您的应用在凹口屏上表现良好。同时，您也可以在 Android P 设备的开发者选项里打开对凹口屏的模拟，对您的应用做相应测试。 体验 Android P 在准备好开发条件后，请深入了解 Android P 并学习可以在您的应用中使用到的全新功能和 API。为了帮助您更轻松地探索和使用新 API，请查阅 API 变化报告 (API 27->DP2, DP1->DP2) 以及 Android P API 文档。访问开发者预览版网站了解详情。 下载/更新 Android P 开发者预览版 SDK 和工具包至 Android Studio 3.1，或使用最新版本的 Android Studio 3.2。如果您手边没有 Android P Beta 设备 (或查看今天推送的次条文章)，请使用 Android P 模拟器来运行和测试您的应用。 您的反馈一直都至关重要，我们欢迎您畅所欲言。如果您在开发或测试过程中遇到了问题，请在文章下方留言给我们。再次感谢大家一路以来的支持。 请点击蓝色字体前往 “Android Developers 官方文档”查看详细说明 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_34258782/article/details/87952581。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...et网络的多任务学习机制，并结合时空注意力机制进一步提升了图像分割的精度和效率。 此外，全球范围内的人工智能研究也在图像分割领域取得了突破性进展。例如，微软亚洲研究院今年公开了一项名为“HRNet”的高分辨率网络架构，它在医疗影像、自动驾驶等多个领域保持了顶级的图像分割性能。这一成果证明了通过保留高分辨率特征图并进行跨层次的信息融合，可以有效解决复杂背景下的精细化分割难题。 同时，阿里云不仅在技术研发上持续发力，还积极助力各行业实现数字化转型，如为教育、金融等行业提供了基于云服务的一站式证件照生成平台，用户只需上传原始照片即可快速获得满足各类规范要求的证件照，大大简化了传统流程，提高了工作效率。 综上所述，随着深度学习技术的不断迭代和云服务生态的完善，图像分割在证件照生成领域的应用正逐步走向成熟，并展现出巨大的市场潜力和社会价值。而作为行业领导者之一的阿里云，将持续引领技术创新，推动相关应用场景的落地与发展。

...理解： 触发— 响应机制。 网页中的每个元素都可以产生某些可以触发 JavaScript 的事件，例如，我们可以在用户点击某按钮时产生一个 事件，然后去执行某些操作。 代码演示 <body><button id="btn">浩哥</button><script>// 点击一个按钮，弹出一个对话框// 1.事件是有三部分组成的 1.事件源 2.事件类型 3.事件处理程序 也称为事件三要素// (1).事件源 事件被触发的对象 var but = document.getElementById('btn')// (2).事件类型 如何触发 什么事件 比如鼠标点击(onclick) 还是鼠标经过还是？？？？// (3).事件处理程序 通过一个函数赋值的方式 完成 因为函数就是实现某种功能的but.onclick = function() {alert('浩哥爱编程')}</script></body> 2.执行事件的步骤 1. 获取事件源DOM对象(意思是你要获取那个元素) 2. 注册事件(绑定事件 意思是通过什么方式来处理比如是鼠标经过还是鼠标点击等等行为) 3. 添加事件处理程序(采取函数赋值形式 意思是你想做啥) 代码演示 <body><div>123</div><script>// 事件执行步骤 点击div 控制台输出我被选中了// 1.获取事件源var div = document.querySelector('div')// 2.绑定事件 注册事件// div.onclick// 3.添加事件处理程序div.onclick = function() {console.log('我被点击了');}</script></body> 3.常见的鼠标事件 onmouseenter鼠标移入事件 onmouseleave鼠标移出事件 四.操作元素 JS的DOM操作可以改变网页内容、结构和样式，利用DOM操作元素来改变元素里面的内容、属性等。注意以下都是属性 1.操作元素内容(改变元素内容) elemeny.innerText 从起始位置到终止位置的内容，但它去除html标签，同时空格和换行也会去掉 elemernt.innerHTML 起始位置到终止位置的全部内容，包括html标签，同时保留空格和换行 elemernt.Content可以获取隐藏元素的文本，包含换行和空白 代码演示 <title>Document</title><style>div,p {height: 30px;width: 300px;line-height: 30px;text-align: center;color: fff;background-color: pink;}</style></head><body><button>显示当前系统时间</button><div>某个时间</div><p>123</p><script>// 当我们点击了按钮，div里面的文字会发生变化// 1.获取元素 注意这里的按钮 和div都要获取到 因为 点击按钮div里面要发生变化所以都要获取var but = document.querySelector('button');var div = document.querySelector('div');// 2.绑定事件// but.onclick// 3.程序处理but.onclick = function() {// 改变元素内容 element(元素).innerTextdiv.innerText = '2020-11-27'}// 4.我们元素可以不用添加事件，就可以直接显示日期var p = document.querySelector('p');p.innerText = '2020-11-27';</script> elemeny.innerText和elemeny.innerHTML的区别 代码演示 <body><div></div><p></p><ul><li> 文字</li><li>123</li></ul><script>// innertText 和 innertHTML 的区别// 1. innerText 不识别html标签 非标准 去除空格和换行var div = document.querySelector('div');div.innerText = '<strong>今天是:</strong> 2020';// 2.innertHTML 识别html标签 W3C标准 保留空格和换行的 推荐尽量使用这个 因为这个是标准var p = document.querySelector('p')p.innerHTML = '<strong>今天是:</strong> 2020';// 3.这俩个属性是可读写的 意思是 除了改变内容还可以元素读取里面的内容的var ul = document.querySelector('ul')console.log(ul.innerText);console.log(ul.innerHTML);// .4innerHtml innerText 之间的区别：设置内容的时候，如果内容当中包含标签字符串 innerHtml会有标签的特性，也就是说标签会在页面上生效如果内容当中包含标签字符串 innerText会把标签原样展示在页面上，不会让标签生效读取内容的时候，如果标签内部还有其它标签，innerHtml会把标签内部带着其它的标签全部输出如果标签内部还有其它标签，innerText只会输出所有标签里面的内容或者文本，不会输出标签如果标签内部没有其它标签，他们两个一致；都是读取文本内容，innerHtml会带空白和换行</script></body> 2. 操作常见元素属性 innerText、innerHTML 改变元素内容 src、href id、alt、title 代码演示 <body><button id="ldh">刘德华</button><button id="zxy">张学友</button><br><img src="./images/ldh.jpg" alt="" width="200px" height="200px" title="刘德华" id="img"><script>// 修改属性 src// 我们可以操作元素得方法 来修改元素得属性 就是 元素的是什么属性 在重新给值就可以完成相应的赋值操作了// 1.获取元素var ldh = document.getElementById('ldh')var zxy = document.getElementById('zxy')var img = document.getElementById('img')// 2.注册事件 程序处理zxy.onclick = function() {// 当我们点击了图片的时候图片路径就发生变化 这里的.表示 的 得意思 img对象下的src属性img.src = './images/zxy.jpg';// 当我们变换图片得同时里面得title也要跟着变 所以前面要加上img.img.title = '张学友';}ldh.onclick = function() {img.src = './images/ldh.jpg';img.title = '刘德华';}</script> 3.操作表单元素属性 利用DOM可以操作如下表单元素的属性 type、value、checked、selected、disabled 代码演示： <body><button>按钮</button><input type="text" value="输入内容"><script>// 我想把value里面的输入内容改变为 被点击了// 1.获取元素var but = document.querySelector('button')var input = document.querySelector('input')// 2.注册事件 处理程序but.onclick = function() {// input.innerHTML = '被点击了'; 这个是 普通盒子 比如 div 标签里面的内容// 表单里面的值 文字内容是通过value来修改的input.value = '被点击了'// 如果需要某个表单被禁用 不能再点击了使用 disabled 我们想要这个按钮 button禁用// but.disabled = true// 还有一种写法// this指向的是事件函数的调用者 谁调用就指向谁 这里调用者是btnthis.disabled = true}</script></body> 4.操作元素样式属性 我们可以通过 JS 修改元素的大小、颜色、位置等样式。 1.element.style 行内样式操作 注意： JS 里面的样式采取驼峰命名法 比如 fontSize、 backgroundColor JS 修改 style 样式操作，产生的是行内样式，所以行内式比内嵌式高 代码演示 <style>div {width: 200px;height: 200px;background-color: red;}</style></head><body><div></div><script>// 要求点击div变成粉色 height变为250px// 1.获取元素var div = document.querySelector('div');// 2.注册事件 处理程序div.onclick = function() {// div.style里面的属性 采取的是驼峰命名法// this等于div this调用者 谁调用谁执行this.style.backgroundColor = 'pink'this.style.height = '250px'}</script> 2.element.className 类名样式操作 注意： 如果样式修改较多，可以采取操作类名方式更改元素样式。 class因为是个保留字，因此使用className来操作元素类名属性 className 会直接更改元素的类名，会覆盖原先的类名。 代码演示 <style>div {width: 100px;height: 100px;background-color: pink;}.change {background-color: purple;color: fff;font-size: 25px;margin-top: 100px;}</style></head><body><div class="first">文本</div><script>// 1. 使用 element.style 获得修改元素样式 如果样式比较少 或者 功能简单的情况下使用var test = document.querySelector('div');test.onclick = function() {// this.style.backgroundColor = 'purple';// this.style.color = 'fff';// this.style.fontSize = '25px';// this.style.marginTop = '100px';// 让我们当前元素的类名改为了 change// 2. 我们可以通过 修改元素的className更改元素的样式 适合于样式较多或者功能复杂的情况 如果想继续添加样式即在change添加即可// 3. 如果想要保留原先的类名，我们可以这么做 多类名选择器// this.className = 'change';this.className = 'first change';}</script> 5.自定义属性的操作 js给我们规定了可以自己添加属性 在操作元素属性的时候，元素.语法只能操作元素天生具有的属性,如果是自定义的属性，通过.语法是无法操作的只能通过getAttribute和setAttribute去操作，他俩是通用的方法，无论元素天生的还是自定义的都可以可以操作 1.获取属性值 element.属性 获取属性值。 element.getAttribute(‘属性’)； 区别: element.属性 获取内置属性值(元素本身自带的属性 如果是自定义属性不能被获取) element.getAttribute(‘属性’)；主要获得自定义的属性 (标准) 我们自定义的属性 2.设置属性值 element.属性 = ‘值’ 设置内置属性值 element.setAttribute(‘属性’，‘值’) 区别： element.属性 设置内置属性值 element.setAttribute(‘属性’)；主要设置自定义的属性(标准) 3.移除属性 element.removeAttribute(‘属性’)； 代码演示 <body><div id="demo" index="1" class="nav"></div><script>var div = document.querySelector('div');// 1.获取元素的属性值// (1) element.属性console.log(div.id);// (2) element.getAttribute('属性') get获取得到 attribute属性的意思 我们自己添加的属性称之为自定义属性console.log(div.getAttribute('id')); //democonsole.log(div.getAttribute('index')); // 1// 2.设置元素的属性值// (1) element.属性 = '值' div.id = 'test'div.className = 'navs'// (2) element.setAttribute('属性','值')div.setAttribute('index', 2);div.setAttribute('class', 'footer') //这里就是class 不是className 比较特殊// 3.移除属性 removeAttribute(属性)div.removeAttribute('index');</script></body> 只要是自定义属性最好都是用element.setAttribute(‘属性’，‘值’)来设置 如果是自带属性用element.属性来设置 6.H5自定义属性 自定义属性的目的：第一、是为了保存属性 第二、并且使用数据。有一些数据可以保存到页面中而不用保存到数据库中。 自定义属性获取是通过getAttribute(‘属性’) 获取的 但是有些自定义属性很容易引起歧义，不容易判断是元素还是自定义属性 H5给我们新增了自定义属性： 1.设置H5自定义属性 H5规定自定义属性data-开头做为属性名并且赋值 比如<div data-index:“1”> 或者使用JS设置element.setAttribute(‘deta-index’,2) 2.获取H5自定义属性 兼容性获取 element.getAttribute(‘data-index’) 推荐开发中使用这个 H5新增element.dataset.index 或者element.datase[‘index’] ie 11以上才支持 代码演示 <body><div getTime="10" data-index="20" data-name-list="40"></div><script>// 获取元素var div = document.querySelector('div');console.log(div.geTime); //undefined getTime是自定义属性不能直接通过元素的属性来获取 而是用自定义属性来获取的getAttribute(‘属性’)console.log(div.getAttribute('getTime')); //10// H5添加自定义属性的写法以data-开头div.setAttribute('data-time', 30)// 1.兼容性获取H5自定义属性console.log(div.getAttribute('data-time')); // 30// 2.H5新增的获取自定义属性的方法 它只能获取data-开头的// dataset 是一个集合的意思存放了所有以data开头的自定义属性 如果你想取其中的某一个只需要在dataset.的后面加上自定义属性名即可console.log(div.dataset);console.log(div.dataset.time); // 30// 还有一种方法dataset['属性']console.log(div.dataset['time']); // 30// 如果自定义属性里面有多个-链接的单词 我们获取的时候采取驼峰命名法 不用要-了console.log(div.dataset.nameList); // 40console.log(div.dataset['nameList']); // 40</script></body> 五.节点操作 1.为什么要学习节点操作 获取元素通常使用俩种方式 （1）利用DOM提供的方法获取元素 但是逻辑性不强 繁琐 （2）利用节点层级关系获取元素 如 利用父子，兄弟关系获取元素 逻辑性强，但是兼容性不怎么好 2.节点概述 网页中的所有内容都是节点(标签、属性、文本、注释等等) ，在DOM中，节点使用node表示。HTML DOM 树中的所有节点均可通过javascript进行访问，所有HTML元素(节点) 均可被修改，也可以创建或删除 一般地，节点至少拥有nade Type(节点类型)、nodeName(节点名称)和nodeValue(节点值) 这三个基本属性 元素节点 nodeType 为 1 属性节点 node Name为 2 文本节点 nodeValue为 3 (文本节点包含文字、空格、换行等等) 实际开发中，节点操作主要操作的是元素节点 3.节点层级 利用DOM树可以把节点划分为不同得层级关系，常见得是父子兄层级关系 1.父级节点 1.node.parentNode parenNode属性可以返回某节点得父节点，注意是最近的父节点哟！！！ 如果指定的节点没有父节点就返回null 代码演示 <body><div class="box"><div class="box1"></div></div><script>var box1 = document.querySelector('.box1')// 得到的是离元素最近的父节点(亲爸爸) 得不到就返回得是nullconsole.log(box1.parentNode); // parentNode 翻译过来就是父亲的节点</script></body> 2.子级节点操作 1.parentNode.children（非标准） parentNode.children 是一个只读属性，返回所有的子元素节点。它只返回子元素节点，其余节点不返回(重点记住这个就好，以后重点使用) 虽然children是一个非标准，但是得到了各个浏览器的支持，我们大胆使用即可！！！ 代码演示 <body><ul><li>1</li><li>1</li><li>1</li><li>1</li></ul><script>// DOM 提供的方法（APL）获取 这样获取比较麻烦var ul = document.querySelector('ul')var lis = ul.querySelectorAll('li')// children子节点获取 ul里面所有的小li 放心使用没有限制兼容性 实际开发中经常使用的console.log(ul.children);</script> 如何返回子节点的第一个和最后一个？ 2.parentNode.firstElementChild firstElementChild返回第一个子元素节点，找不到则返回unll 3.parentNode.lastElementChild lastElementChild返回最后一个子元素节点，找不到则返回null 注意：这俩个方法有兼容性问题，IE9以上才支持 谨慎使用 但是我们有解决方案 如果想要第一个子元素节点，可以使用 parentNode.chilren[0] 如果想要最后一个子元素节点，可以使用 parentNode.chilren[parentNode.chilren.length - 1] 代码演示 <body><ul><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul><script>var ul = document.querySelector('ul')// 1.firstElementChild 返回第一个子元素节点 ie9 以上才支持注意兼容console.log(ul.firstElementChild);// 2.lastElementChild返回最后一个子元素节点console.log(ul.lastElementChild);// 3.实际开发中用到的既没有兼容性问题又可以返回子节点的第一个和最后一个console.log(ul.children[0]);console.log(ul.children[ul.children.length - 1]); //ul.children.length - 1获取的永远是子节点最后一个</script></body> 3.兄弟节点 1.node.nextSibling nextSibling 返回当前元素的下一个兄弟节点，找不到则返回null。注意包含所有的节点 2.node.previousSibling previousSibling 返回当前元素上一个兄弟节点，找不到则返回null。注意包含所以有的节点 代码演示 <body><div>我是div</div><span>我是span</span><script>var div = document.querySelector('div')// 返回当前元素的下一个兄弟节点nextSibling，找不到返回null。注意包含元素节点或者文本节点等等console.log(div.nextSibling); //这里返回的是text 因为它的下一个兄弟节点是换行// 返回的是当前元素的上一个节点previousSibling，找不到返回null。注意包含元素节点或者文本节点等等console.log(div.previousSibling); //这里返回的是text 因为它的上一个兄弟节点是换行</script></body> 3.node.nexElementSibling nexElementSibling 返回当前元素下一个兄弟元素节点，找不到返回null 4.node.previousElementSibling previousElementSibling返回当前元素上一个兄弟节点，找不到返回null 注意：这俩个方法有兼容性问题，IE9以上才支持 代码演示 <body><div>我是div</div><span>我是span</span><script>var div = document.querySelector('div')// nextElementSiblingd得到下一个兄弟元素节点console.log(div.nextElementSibling); // span // previousElementSibling 得到的是上一个兄弟元素节点console.log(div.previousElementSibling); // null 因为它上面没有兄弟元素了返回空的</script></body> 怎么解决兼容性问题呢？ 可以封装一个兼容性函数（简单了解即可 在实际开发中用的不多） function getNextElementSibling(element) {var el = element;while (el = el.nextSibling) {if (el.nodeType === 1) {return el;} }return null;} 4.创建节点 1.document.createElement('tagName') document.createElement( ) 方法创建由 tagName 指定的 HTML 元素。因为这些元素原先不存在的是根据我们的需求动态生成的，所有我们也称为动态创建元素节点 我们创建了节点要给添加到节点里面去 称为 添加节点 1.node.appendChild（child） node.appendChild（ ）方法将一个节点添加到指定父节点的子节点列表末尾 2.node.insertBefore(child，指定添加元素位置) node.insertBefore( ) 方法将一个节点添加到父节点的指定子节点前面 代码演示 <body><ul><li>1</li></ul><script>// 1.创建节点 createElementvar li = document.createElement('li')// 2.添加节点 创建了节点要添加到某一个元素身上去 叫添加节点 node.appendChild(child) done 父级 child 子级 如果前面有元素了则在后面追加元素类似数组中的push依次追加var ul = document.querySelector('ul')ul.appendChild(li)// 3.添加节点 node.insertBefore(child，指定元素) 在子节点前面添加子节点 child子级你要添加的元素var lili = document.createElement('li')ul.insertBefore(lili, ul.children[0]) //ul.children 这句话的意思是添加到ul父亲的子节点第一个// 总结 如果想在页面中添加元素分为俩步骤1.创建元素 2.添加元素</script></body> 5.删除节点 node.removeChild(child) node.removeChlid（）方法从DOM 中删除一个子节点，返回删除的节点 简单点就是从父元素中删除某一个孩子node就是父亲child就是孩子 删除的节点.remove(没有参数) 注意：ie不支持 代码演示 <body><button>按钮</button><ul><li>熊大</li><li>熊二</li><li>熊三</li></ul><script>// 1.获取元素var ul = document.querySelector('ul')var but = document.querySelector('button');// 2.删除元素// but.onclick = function() {// ul.removeChild(ul.children[0])// }// 3.点击按钮键依次删除，最后没有删除内容了 就禁用按钮 disabled = true 禁用按钮语法but.onclick = function() {if (ul.children.length == 0) {this.disabled = true} else {ul.removeChild(ul.children[0])} }</script></body> 6.复制节点(克隆节点) node.cloneNode() node.dloneNode()方法返回调用该方法节点得一个副本，也称为克隆节点/拷贝节点 注意 1.如果括号参数为空或者为false，则是浅拷贝，只复制里面得标签，不复制内容 2.如果括号参数为true，则是深度拷贝，会复制节点本身以及里面所有的内容 代码演示 <body><ul><li>1</li><li>2</li><li>3</li></ul><script>// 1.获取元素var ul = document.querySelector('ul');// 2.复制元素 node.cloneNode() 如果参数括号为空或者false则只会复制元素不会复制内容，如果待有参数true则内容和元素都会被复制var lis = ul.children[0].cloneNode(true);// 3.获取元素ul.appendChild(lis)</script></body> 7.替换(改)节点 node.replaceChild(新节点,替换到什么位置) 代码演示 <body><ul class="list"><li>1</li><li>2</li></ul><script>// 替换（改）节点 父节点.replaceChild(新元素, 替换到什么位置)// (1)获取父元素var ulNode = document.querySelector('.list');// (2)创建新的元素var liRead = document.createElement('li')// (3)给新元素添加内容liRead.innerHTML = '5';// (4)替换元素ulNode.replaceChild(liRead, ulNode.children[1])</script></body> 8.三种动态创建元素区别 document.write() element.innerHTML document.createElement() 区别 document.write()是直接将内容写入页面的内容流，但是文档流执行完毕，它则会导致页面全部重绘 element.innerHTML是将内容写入某个DOM节点，不会导致页面全部重绘 element.innerHTML 创建多个元素效率更高(不要拼接字符串，采取数组形式拼接)，结果有点复杂 createElement()创建多个元素效率低一点点，但是结果更加清晰 总结：不同浏览器下,innerHTML效率要比createElement()高 代码演示 <body><button>点击</button><p>abc</p><div class="inner"></div><div class="create"></div><script>// window.onload = function() {// document.write('<div>123</div>');// }// 三种创建元素方式区别 // 1. document.write() 创建元素 如果页面文档流加载完毕，再调用这句话会导致页面重绘// var btn = document.querySelector('button');// btn.onclick = function() {// document.write('<div>123</div>');// }// 2. innerHTML 创建元素var inner = document.querySelector('.inner');// for (var i = 0; i <= 100; i++) {// inner.innerHTML += '<a href="">百度</a>'// }var arr = [];for (var i = 0; i <= 100; i++) {arr.push('<a href="">百度</a>');}inner.innerHTML = arr.join('');// 3. document.createElement() 创建元素var create = document.querySelector('.create');for (var i = 0; i <= 100; i++) {var a = document.createElement('a');create.appendChild(a);}</script></body> 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_46978034/article/details/110190352。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...C++提供了构造函数机制，用来为对象的数据成员进行初始化。在前面的学习中一直未讲这个概念，其实如果你未设计构造函数，系统在创建对象时，会自动提供一个默认的构造函数，而它只为对象分配内存空间其他什么也不做。 如果类中的所有数据成员是公有的，可以在定义对象时对其数据成员初始化。例如： class Time{public:int hour;int minute;int sec;};Time t1{15,36,26}; 在一个打括号内顺序列出各个公有数据成员的值，在两个值之间用逗号分隔。注意这只能用于数据成员都是共有的情况。 在前面的例子里，是用成员函数对对象的数据成员赋初值，如果一个类定义了多个对象，对每个对象都要调用成员函数对数据成员赋初值，那么程序就会变得繁琐，所以用成员函数为数据成员赋初值不是一个好办法。 2.构造函数的作用 构造函数用于为对象分配空间和进行初始化，它属于某一个类，可以由系统自动生成。也可以由程序员编写，程序员根据初始化的要求设计构造函数及函数参数。 构造函数是一种特殊的成员函数，在程序中不需要写调用语句，在系统建立对象时由系统自觉调用执行。 构造函数的特点： 构造函数的名字与它的类名必须相同 它没有类型，也不返回值 它可以带参数，也可以不带参数 include <iostream>using namespace std;class Time {public:Time() {hour = 0;minute = 0;sec = 0;}void set_time();void show_time();private:int hour;int minute;int sec;};int main() {Time t1;t1.set_time();t1.show_time();Time t2;t2.show_time();return 0;}void Time::set_time() {cin >> hour;cin >> minute;cin >> sec;}void Time::show_time() {cout << hour << ":" << minute << ":" << sec << endl;} 在类Time中定义了构造函数Time，它与所在的类同名。在建立对象时自动执行构造函数，该函数的作用是为对象中的每个数据成员赋初值0。注意只有执行构造函数时才能为数据成员赋初值。 程序运行时首先建立对象t1，并对t1中的数据成员赋初值0，然后执行t1.set_time函数，从键盘输入新值给对象t1的数据成员，再输出t1的数据成员的值。接着建立对象t2，同时对t2中的数据成员赋初值0，最后输出t2的数据成员的初值。程序运行情况如下： 也可以在类内声明构造函数然后在类外定义构造函数。将程序修改为Time();然后在类外定义构造函数： Time::Time() {hour = 0;minute = 0;sec = 0;} 关于构造函数的使用，说明如下： 什么时候调用构造函数？当函数执行到对象定义语句时建立对象，此时就要调用构造函数，对象就有了自己的作用域，对象的生命周期开始了。 构造函数没有返回值，因此不需要在定义中声明类型。 构造函数不需要显式地调用，构造函数是在建立对象时由系统自动执行的，且只执行以此。构造函数一般定义为public。 在构造函数中除了可以对数据成员赋初值，还可以使用其他语句。 如果用户没有定义构造函数，C++系统会自动生成一个构造函数，而这个函数体是空的，不执行初始化操作。 3.带形参数的构造函数 （1）含义 可以采用带形参数的构造函数，在调用不同对象的构造函数时，从外边将不同的数据传递给构造函数，实现不同对象的初始化。 构造函数的首部的一般格式为：构造函数名（类型 形参1，类型 形参2，……）。在定义对象时指定实参，定义对象的格式为：类名 对象名（实参1，实参2，……）。 （2）【例3.2】 有两个长方柱，其长、宽、高分别为：（1）12，25，30（2）15，30，21编写程序，在类中用带参数的构造函数，计算它们的体积。 分析：可以在类中定义一个计算长方体体积的成员函数计算对象的体积。 include<iostream>using namespace std;class Box{public:Box(int,int,int); //声明int volume();private:int height;int width;int length;};Box::Box(int h,int w,int len) //长方体构造函数{height=h;width=w;length=len;}int Box::volume() //计算长方体体积{return(heightwidthlength);}int main(){Box box1(12,25,30); //定义对象box1cout<<"box1体积="<<box1.volume()<<endl;Box box2(15,30,21); //定义对象box2cout<<"box2体积="<<box2.volume()<<endl;return 0;} 【注】 带形参的构造函数在定义对象时必须指定实参 用这种方法可以实现不同对象的初始化 4.用参数初始化表对数据成员初始化 C++提供了参数初始化表的方法对数据成员初始化。这种方法不必再构造函数内对数据成员初始化，在函数的首部就能实现数据成员初始化。 函数名(类型1 形参1，类型2 形参2): 成员名1(形参1),成员名2(形参2){ } 功能：执行构造函数时，将形参1的值赋予成员1，将形参2的值赋予成员2，形参的值由定义对象时的实参值决定。此时定义对象的格式依然是带实参的形式：类名 对象名(实参1,实参2); 例：定义带形参初始化表的构造函数 Box::Box(int h,int w,int len):height(h),width(w),length(len){}//定义对象:Box box1(12,25,30);//……Box box2(15,30,21); 5.构造函数的重载 （1）含义 构造函数也可以重载。一个类可以有多个同名构造函数，函数参数的个数、参数的类型各不相同。 （2）【例3.3】 在【例3.2】的基础上定义两个构造函数，其中一个无参数，另一个有参数 include <iostream>using namespace std;class Box {public:Box();Box(int h, int w, int len): height(h), width(w), length(len) {}int volume();private:int height;int width;int length;};Box::Box() {height = 10;width = 10;length = 10;}int Box::volume() {return (height width length);}int main() {Box box1;cout << "box1 体积" << box1.volume() << endl;Box box2(15, 30, 25);cout << "box2 体积" << box2.volume() << endl;return 0;} （3）说明 不带形参的构造函数为默认构造函数，每个类只有一个默认构造函数，如果是系统自动给的默认构造函数，其函数体是空的 虽然每个类可以包含多个构造函数，但是创建对象时，系统仅执行其中一个 6.使用默认参数值的构造函数 （1）含义 C++允许在构造函数里为形参指定默认值，如果创建对象时，未给出相应的实参时，系统将用形参的默认值为形参赋值。 （2）格式 函数名（类型 形参1=常数，类型 形参2=常数，……）； （3）【例3.4】 将【例3.3】中的构造函数改用带默认值的参数，长、宽、高的默认值都是10 include <iostream>using namespace std;class Box {public:Box(int w = 10, int h = 10, int len = 10);int volume();private:int height;int width;int length;};Box::Box(int w, int h, int len) {height = h;width = w;length = len;}int Box::volume() {return (height width length);}int main() {Box box1;cout << "box1 体积" << box1.volume() << endl;Box box2(15);cout << "box2 体积" << box2.volume() << endl;Box box3(15, 30);cout << "box3 体积" << box3.volume() << endl;Box box4(15, 30, 20);cout << "box4 体积" << box4.volume() << endl;return 0;} （4）说明 如果在类外定义构造函数，应该在声明构造函数时指定默认参数值，再定以函数时不再指定默认参数值 在声明构造函数时，形参名可以省略。例如：Box(int 10,int 10,int 10); 如果构造函数的所有形参都指定了默认值，在定义对象时，可以指定实参也可不指定实参。由于不指定实参也可以调用构造函数，因此全部形参都指定了默认值的构造函数也属于默认构造函数。为了避免歧义，不允许同时定义不带形参的构造函数和全部形参都指定默认值的构造函数。 不能同时使用重载构造函数和带默认值的构造函数 二、析构函数 1.含义 析构函数也是个特殊的成员函数，它的作用与构造函数相反，当对象的生命周期结束时，系统自动调用析构函数，收回对象占用的内存空间。 2.执行析构函数的时机 在一个函数内定义的对象当这个函数结束时，自动执行析构函数释放对象 static局部对象要到main函数结束或执行exit命令时才自动执行析构函数释放对象 全局对象（在函数外定义的对象）当main函数结束或执行exit命令时自动执行析构函数释放对象 如果用new建立动态对象，用delete时自动执行析构函数释放对象 3.特征 以~符号开始后跟类名 析构函数没有数据类型、返回值、形参。由于没有形参所以析构函数不能重载。一个类只有一个析构函数 如果程序员没有定义析构函数，C++编译系统会自动生成一个析构函数 【注】析构函数除了释放对象（资源）外，还可以执行程序员在最后一次适用对象后希望执行的任何操作。例如输出有关的信息。 4.【例3.5】包含构造函数和析构函数的C++程序 include <iostream>include <string>using namespace std;class Student {public:Student(int n, string nam, char s) {num = n;name = nam;sex = s;cout << "Constructor called." << endl;}~Student() {cout << "Destructor called." << endl;}void display() {cout << "num:" << num << endl;cout << "name:" << name << endl;cout << "sex:" << sex << endl;}private:int num;string name;char sex;};int main() {Student stud1(10010, "wang_li", 'f');stud1.display();Student stud2(10011, "zhang_han", 'm');stud2.display();return 0;}//main函数前声明的类其作用域是全局的 三、调用构造函数和析构函数的顺序 1.同一类存储类别的对象 一般情况下，调用析构函数的次序与调用构造函数的次序恰好相反：最先调用构造函数的对象，最后调用析构函数；最后调用构造函数的对象，最先调用析构函数。可简记为：先构造的后析构，后构造的先析构。它相当于一个栈，后进先出。 2.全局范围内定义的对象 在全局范围内定义的对象（在所有函数之外定义的对象），在文件中的所有函数（包括主函数）执行前调用构造函数。当主函数结束或执行exit函数时，调用析构函数。 3.局部自动对象 如果定义局部自动对象（在函数内定义对象），在创建对象时调用构造函数。如多次调用对象所在的函数，则每次创建对象时都调用构造函数。在函数调用结束时调用析构函数。 4.静态局部对象 如果在函数中定义静态局部对象，则在第一次调用该函数建立对象时调用构造函数，但在主函数结束或调用exit函数时才调用析构函数。 5.例 void fun(){student st1; //定义局部自动对象static student st2; //定义静态局部对象...} 对象st1是每次调用函数fun时调用构造函数。在函数fun结束时调用析构函数。 对象st2是第一次调用函数fun时调用构造函数，在函数fun结束时并不调用析构函数，到主函数结束时才调用析构函数 四、对象数组 1.含义 类是一种特殊的数据类型，它当然是C++的合法类型，自然可以定义对象数组。在一个对象数组中各个元素都是同类对象。例如一个班级有50个同学，每个学生有学号、年龄、成绩等属性，可以为这个班级建立一个对象数组，数组包括了50个元素：student std[50];。 可以这样建立构造函数：student::student(int 1001,int 18,int 60);。 在建立数组时，同样要调用构造函数。上面的数组有50个元素，要调用50次构造函数。如果构造函数有多个参数，C++要求：在等号后的花括号中为每个对象分别写出构造函数并指定实参。格式为： student st[n]={ student(实参1,实参2,实参3); …… student(实参1,实参2,实参3); }； 假定对象有三个数据成员：学号、年龄、成绩。下面定义有三个学生的对象数组： student st[3]={ student(1001,18,87); student(1002,19,76); student(1003,18,80); }；//构造函数带实参 在建立对象数组时，分别调用构造函数，对每个对象初始化。每个元素的实参用括号括起来，实参的位置与构造函数形参的位置一一对应，不会混淆。 2.【例3.6】 include <iostream>using namespace std;class Box {public:Box(int h = 10, int w = 12, int len = 15): height(h), width(w), length(len) {} //int volume();private:int height;int width;int length;};int Box::volume() {return (height width length);}int main() {Box a[3] = {Box(10, 12, 15), Box(15, 18, 20), Box(16, 20, 26)};cout << "a[0]的体积是" << a[0].volume() << endl;cout << "a[1]的体积是" << a[1].volume() << endl;cout << "a[2]的体积是" << a[2].volume() << endl;return 0;}//每个数组元素是一个对象 五、对象指针 指针的含义是内存单元的地址，可以指向一般的变量，也可以指向对象。 1.指向对象的指针 对象要占据一片连续的内存空间，CPU实际都是按地址访问内存，所以对象在内存的其实地址是CPU确定对象在内存中位置的依据。这个起始地址称为对象指针。 C++的对象也可以参加取地址运算：&对象名。运算的结果是该对象的起始地址，也称对象的指针，要用与对象类型相同的指针变量保存运算的结果。 C++中定义对象的指针变量与定义其他的指针变量相似，格式如下：类名 变量名表。类名表示对象所属的类，变量名按标识符规则取名，两个变量名之间用逗号分隔。定义好指针变量后，必须先给赋予合法的地址后才能使用。 例如定义如下一个类： class Time {public:Time() {hour = 0;minute = 0;sec = 0;}void set_time();void show_time();private:int hour;int minute;int sec;};void Time::set_time() {cin >> hour;cin >> minute;cin >> sec;}void Time::show_time() {cout << hour << ":" << minute << ":" << sec << endl;} 在此基础上，有如下语句： Time pt; //定义pt是指向Time类对象的指针Time t1; //定义Time类对象t1pt=&t1; //将对象t1的地址赋予pt 程序在此基础上就可以用指针变量访问对象的成员。 (pt).hour;pt->hour;(pt).show_time();pt->show_time(); 2.指向对象成员的指针 （1）含义 对象由成员组成。对象占据的内存区是各个数据成员占据的内存区的总和。对象成员也有地址，即指针。这指针分指向数据成员的指针和指向成员函数的指针。 （2）指向对象公有数据成员的指针 定义数据成员的指针变量：数据类型 指针变量名（这里的数据类型是数据成员的数据类型） 计算公有数据成员的地址：&对象名.成员名 Time t1;int p1; //定义一个指向整型数据的指针变量p1=&t1.hour; //假定hour是公有成员cout<<p1<<endl; （3）指向对象成员函数的指针 定义指向成员函数的指针变量：数据类型(类名::变量名)(形参表); 数据类型是成员函数的类型；类名是对象所属的类；变量名按标识符取名；形参表：指定成员函数的形参表（形参个数、类型） 取成员函数的地址：&类名::成员函数名 给指针变量赋初值：指针变量名=&类名::成员函数名; 用指针变量调用成员函数：(对象名.指针变量名)([实参表]); 对象名：指定调用成员函数的对象；：明确其后的是一个指针变量；实参表：与成员函数的形参表对应，如无形参，可以省略实参表 （4）【例3.7】有关对象指针的使用方法 include <iostream>using namespace std;class Time {public:Time(int, int, int);int hour;int minute;int sec;void get_time();};Time::Time(int h, int m, int s) {hour = h;minute = m;sec = s;}void Time::get_time() {cout << hour << ":" << minute << ":" << sec << endl;}int main() {Time t1(10, 13, 56);int p1 = &t1.hour; //定义指向数据成员的指针p1cout << p1 << endl;t1.get_time(); //调用成员函数Time p2 = &t1; //定义指向对象t1的指针p2p2->get_time(); //用对象指针调用成员函数void(Time::p3)(); //定义指向成员函数的指针p3 = &Time::get_time; //给成员函数的指针赋初值(t1.p3)(); //用指向成员函数的指针调用成员函数return 0;} 【注】代码的34，35行可合并为：void(Time::p3)=&Time::get_time; 3.this指针 一个类的成员函数只有一个内存拷贝。类中不论哪个对象调用某个成员函数，调用的都是内存中同一个成员函数代码。例如Time类一个成员函数： void Time::get_time(){cout<<hour<<":"<<minute<<":"<<sec<<endl;}t1.get_time();t2.get_time(); 当不同对象的成员函数访问数据成员时，怎么保证访问的就是指定对象的数据成员？其实每个成员函数中都包含一个特殊的指针，他的名字是this指针。它是指向本类对象的指针。当对象调用成员函数时，它的值就是该对象的起始地址。所以为了区分不同对象访问成员函数，语法要求的调用成员函数的格式是：对象名.成员函数名(实参表)。从语法上明确是对象名所指的对象调用成员函数。This指针是隐式使用的，在调用成员函数时C++把对象的地址作为实参传递给this指针。例如成员函数定义如下： int Box::volume(){return(heightwidthlength);} C++编译成： int Box::volume(this){return(this->heightthis->widththis->length);} 对于计算长方体体积的成员函数volume，当对象调用它时，就把对象地址给this指针，编译程序将的地址作为实参调用成员函数：a.volume(&a);。实际上函数是计算(this->height)(this->width)(this->length)，这时就等价计算(a.height)(a.width)(a.length)。 可以用(this)表示调用成员函数的对象。(this)就是this所指的对象。如前面的计算长方体体积的函数中return语句可以写成：return((this).height(this).width(this).length);注意，this两侧的括号不能省略。 C++通过编译程序，在对象调用成员函数时，把对象的地址赋予this指针，用this指针指向对象，实现了用同一个成员函数访问不同对象的数据成员。 六、共用数据的保护 如果既希望数据在一定范围内共享，又不愿它被随意修改，从技术上可以把数据指定为只读型的。C++提供const手段，将数据、对象、成员函数指定为常量，从而实现了只读要求，达到保护数据的目的。 1.常对象 定义格式： const 类名 对象名（实参表）;或 类名 const 对象名（实参表）; 把对象定义为常对象，对象中的数据成员就是常变量，在定义时必须带实参作为数据成员的初值，在程序中不允许修改常对象的数据成员值。 如果一个常对象的成员函数未被定义为常成员函数（除构造函数和析构函数外），则对象不能调用这样的函数。 const Time t1(10,16,36);t1.get_time();//错误，不能调用 为了访问常对象中的数据成员，要定义常成员函数。 void get_time() const 如果在常对象中要修改某个数据成员，C++提供了指定可变的数据成员方法。 格式：mutable 类型 数据成员 在定义数据成员时加mutable后，将数据成员声明为可变的数据成员，就可以用声明为const的成员函数修改它的值。 2.常对象成员 可以在声明普通对象时将数据成员或成员函数声明为常数据成员或常成员函数。 （1）常数据成员 格式： const 类型 数据成员名 将类中的数据成员定义为具有只读的性质。注意只能通过带参数初始表的构造函数对常数据成员进行初始化。例如： const int hour;Time::Time(int h){hour=h;...//错误}Time::Time(int h):hour(h){}//正确 在类中声明了某个常数据成员后，该类中每个对象的这个数据成员的值都是只读的，而每个对象的这个数据成员的值可以不同，由定义对象时给出。 （2）常成员函数 定义格式：类型 函数名 （形参表）const const是函数类型的一部分，在声明函数原型和定义函数时都要用const关键字。 【注1】const是函数类型的一个组成部分，因此在函数的实现部分也要使用关键字const。常成员函数不能修改对象的数据成员，也不能调用该类中没有由关键字const修饰的成员函数，从而保证了在常成员函数中不会修改数据成员的值。如果一个对象被说明为常对象，则通过该对象只能调用它的常成员函数。 【注2】一般成员函数可以访问或修改本类中非const数据成员。而常成员函数只能读本类中的数据成员，而不能写他们。 数据成员 非const成员函数 const成员函数 非const的数据成员 可以引用，也可以改变值 可以引用，但不可以改变值 const数据成员 可以引用，但不可以改变值 可以引用，但不可以改变值 const对象的数据成员 不允许引用和改变值 可以引用，但不可以改变值 常成员函数的使用： 如果类中有部分数据成员的值要求为只读，可以将它们声明为const，这样成员函数只能读这些数据成员的值，但不能修改它们的值 如果所有数据成员的值为只读，可将对象声明为const，在类中必须声明const成员函数，常对象只能通过常成员函数读数据成员 常对象不能调用非const成员函数 【注】如果常对象的成员函数未加const，编译系统将其当作非const成员函数；常成员函数不能调用非const成员函数 3.指向对象的常指针 如果在定义指向对象的指针时，使用了关键字const，他就是一个常指针，必须在定义时对其初始化，并且在程序运行中不能再修改指针的值。 格式：const 指针变量名=对象地址 Time t1(10,12,15),t2;Time const p1=&t1;//在此后，不能修改p1Time const p1=&t2;//错误语句 指向对象的常指针，在程序运行中始终指向的是同一个对象。即指针变量的值始终不变，但它所指对象的数据成员值可以修改。当需要将一个指针变量固定地与一个对象相联系时，就可将指针变量指定为const。往往用常指针作为函数的形参，目的是不允许在函数中修改指针变量的值，让它始终指向原来的对象。 4.指向常对象的指针变量 5.对象的常引用 （1）含义 前面学过引用是传递参数的有效方法。用引用形参时，形参变量与实参变量是同一个变量，在函数内修改引用形参也就是修改实参变量。如果用引用形参又不想让函数修改实参，可以使用常引用机制。 （2）格式 const 类名 &形参变量名 （3）【例3.8】对象的引用 include <iostream>using namespace std;class Time {public:Time(int, int, int);int hour;int minute;int sec;};Time::Time(int h, int m, int s) {hour = h;minute = m;sec = s;}void fun(Time &t) {t.hour = 18;}int main() {Time t1(10, 13, 56);fun(t1);cout << t1.hour << endl;return 0;} //如果用引用形参又不想让函数修改实参，可以使用常引用机制include <iostream>using namespace std;class Time {public:Time(int, int, int);void fun(int &t) {hour = t;t = 18;}int hour;int minute;int sec;};Time::Time(int h, int m, int s) {hour = h;minute = m;sec = s;}int main(int argc, char argc[]) {int x = 15;Time t1(10, 13, 56);t1.fun(x);cout << t1.hour << endl;cout << x << endl;return 0;} 6.const型数据小结 七、对象的动态建立与释放——动态建立对象 C++提供了new和delete运算符，实现动态分配、回收内存。他们也可以用来动态建立对象和释放对象。 格式：new 类名; 功能：在堆里分配内存，建立指定类的一个对象。如果分配成功，将返回动态对象的起始地址（指针）；如不成功，返回0.为了保存这个指针，必须事先建立以类名为类型的指针变量。 格式：类名 指针变量名 Box pt;pt=new Box;//如果分配成功，就可以用指针变量pt访问动态对象的数据成员cout<<pt->height;cout<<pt->volume(); 当不再需要使用动态变量时，必须用delete运算符释放内存。 格式：delete 指针变量（存放的是用new运算返回的指针） 八、对象的赋值和复制 1.对象的赋值 （1）含义 如果一个类定义了两个或多个对象，则这些同类对象之间可以相互赋值。这里所指的对象的值含义是对象中所有数据成员的值。对象1、对象2都是已建立好的同类对象。 格式：对象1=对象2； （2）【例3.9】对象的赋值 include <iostream>using namespace std;class Box {public:Box(int = 10, int = 10, int = 10);int volume();private:int height;int width;int length;};Box::Box(int h, int w, int len) {height = h;width = w;length = len;}int Box::volume() {return (height width length);}int main() {Box box1(15, 30, 25), box2;cout << "box1 体积=" << box1.volume() << endl;box2 = box1;cout << "box2 体积=" << box2.volume() << endl;return 0;} （3）说明 对象的赋值只对数据成员操作 数据成员中不能含有动态分配的数据成员 2.对象的复制 （1）含义 对象赋值的前提是对象1和对象2是已经建立的对象。C++还可以按照一个对象克隆出另一个对象（从无到有），这就是复制对象。复制对象是创建对象的另一种方法（以前学过的是定义对象）。创建对象必须调用构造函数，复制对象要调用复制构造函数。以Box类为例，复制构造函数的形式是： Box::Box(const Box &b){height=b.height;width=b.width;length=b.length;} 复制构造函数只有一个参数，这个参数是本类的对象，且采用引用对象形式。为了防止修改数据，加const限制。构造函数的内容就是将实参对象的数据成员值赋予新对象对应的数据成员，如果程序中未定义复制构造函数，编译系统将提供默认的复制构造函数，复制类中的数据成员。 复制对象有两种格式： 类名 对象2（对象1）；按对象1复制对象2 类名 对象2=对象1，对象3=对象1，……按对象1复制对象2、对象3 （2）【例】用复制对象的方法创建Box类的对象（用默认复制构造函数） //include "stdafx.h"include <iostream>using namespace std;class Box {public:Box(int = 10, int = 10, int = 10);int volume();private:int height;int width;int length;};Box::Box(int h, int w, int len) {height = h;width = w;length = len;}int Box::volume() {return (height width length);}int main() {Box box1(15, 30, 25);cout << "box1 体积=" << box1.volume() << endl;//Box box2=box1,box3=box2;Box box2(box1), box3(box2);cout << "box2 体积=" << box2.volume() << endl;cout << "box3 体积=" << box3.volume() << endl;return 0;} （3）说明 在以下情况调用复制构造函数： 在程序里用复制对象格式创建对象 当函数的参数是对象。调用函数时，需要将实参对象复制给形参对象，在此系统将调用复制构造函数 void fun(Box b){...}int main(){Box box1(12,15,18);fun(box1);return 0;} 在函数返回值是类的对象时，需要将函数里的对象复制一个临时对象当作函数值返回 Box f(){Box box1(12,15,18);return box1;}int main(){Box box2;box2=f();} 九、静态成员 C++用const保护数据对象不被修改，在实际中还需要共享数据，C++怎样提供数据共享机制？C++静态成员、友元实现对象之间、类之间的数据共享。 1.静态数据成员 （1）定义格式 static 类型 数据成员名 class Box{public:Box(int=10,int=10,int=10);int volume();private:static int height;int width;int length;}; （2）特性 设Box有n个对象box1..boxn。这n个对象的height成员在内存中共享一个整型数据空间。如果某个对象修改了height成员的值，其他n-1个对象的height成员值也被改变，从而达到n个对象共享height成员值的目的。 （3）说明 由于一个类的所有对象共享静态数据成员，所以不能用构造函数为静态数据成员初始化，只能在类外专门对其初始化。如果程序未对静态数据成员赋初值，则编译系统自动用0为它赋初值 格式：数据类型 类名::静态数据成员名=初值； 即可已用对象名引用静态成员，也可以用类名引用静态成员 静态数据成员在对象外单独开辟内存空间，只要在类中定义了静态成员，即使不定义对象，系统也为静态成员分配内存空间，可以被引用 在程序开始时为静态成员分配内存空间，直到程序结束才释放内存空间 静态数据成员作用域是它的类的作用域（如果在一个函数内定义类，他的静态数据成员作用域就是这个函数）在此范围内可以用“类名::静态成员名”的形式访问静态数据成员 （4）【例3.10】引用静态数据成员 include <iostream>using namespace std;class Box {public:Box(int, int);int volume();static int height;int width;int length;};Box::Box(int w, int len) {width = w;length = len;}int Box::volume() {return (height width length);}int Box::height = 10;int main() {Box a(15, 20), b(25, 30);cout << a.height << endl;cout << b.height << endl;cout << Box::height << endl;cout << a.volume() << endl;cout << b.volume() << endl;return 0;} 2.静态成员函数 （1）含义 C++提供静态成员函数，用它访问静态数据成员，静态成员函数不属于某个对象而属于类。 类中的非静态成员函数可以访问类中所有数据成员；而静态成员函数可以直接访问类的静态成员，不能直接访问非静态成员。 静态成员函数定义格式： static 类型 成员函数（形参表）{……} 调用公有静态成员函数格式： 类名::成员函数（实参表） 引用方式 静态数据成员 非静态数据成员 静态成员函数 成员名 对象名.成员名 非静态成员函数 成员名 成员名 【注】静态成员函数不带this指针，所以必须用对象名和成员运算符.访问非静态成员；而普通成员函数有this指针，可以在函数中直接引用成员名。 （2）【例3.11】关于引用非静态成员和静态成员的具体方法 class Student {private:int num;int age;float score;static float sum;static int count;public:Student(int, int, int);void total();static float average();};Student::Student(int m, int a, int s) {num = m;age = a;score = s;}void Student::total() {sum += score;count++;}float Student::average() {return (sum / count);}float Student::sum = 0;int Student::count = 0;int main() {Student stud[3] = {Student(1001, 18, 70), Student(1002, 19, 79), Student(1005, 20, 98)};int n;cout << "请输入学生的人数：";cin >> n;for (int i = 1; i < n; i++)stud[i].total();cout << n << "个学生的平均成绩是："cout << Student::average() << endl;return 0;} （3）【例】具有静态数据成员的point类 include <iostream>using namespace std;class Point {private:int X, Y;static int countP;public:Point(int xx = 0, int yy = 0) {X = xx;Y = yy;countP++;}Point(Point &p); //复制构造函数int GetX() {return X;}int GetY() {return Y;}int GetC() {cout << "Object id=" << countP << endl;return 0;} };Point::Point(Point &p) {X = p.X;Y = p.Y;countP++;}int Point::countP = 0;int main() {Point A(4, 5);cout << "Point A," << A.GetC() << "," << A.GetY();A.GetC();Point B(A);cout << "Point B," << B.GetC() << "," << B.GetY();B.GetC();return 0;} （4）静态成员函数举例 include <iostream>using namespace std;class application {private:static int global;public:static void f();static void g();};int application::global = 0;void application::f() {global = 5;}void application::g() {cout << global << endl;}int main() {application::f();application::g();return 0;} class A{private:int x; //非静态成员public:static void f(A a);};void A::f(A a){cout<<x; //对x的引用是错误的cout<<a.x; //正确} （5）具有静态数据、函数成员的Point类 include <iostream>using namespace std;class Point { //point类声明private: //私有数据成员int X, Y;static int countP;public: //外部接口Point(int xx = 0, int yy = 0) {X = xx;Y = yy;countP++;}Point(Point &p); //复制构造函数int GetX() {return X;}int GetY() {return Y;}static int GetC() {cout << "Object id=" << countP << endl;return 0;} };Point::Point(Point &p) {X = p.X;Y = p.Y;countP++;}int Point::countP = 0;int main() //主函数实现{ Point A(4, 5); //声明对象Acout << "Point A," << A.GetC() << "," << A.GetY();A.GetC(); //输出对象号，对象名引用Point B(A); //声明对象Bcout << "Point B," << B.GetC() << "," << B.GetY();Point::GetC(); //输出对象号，类名引用return 0;} （6）静态成员函数、静态数组及其初始化 include <iostream>include <stdio.h>using namespace std;class A {static int a[20];int x;public:A(int xx = 0) {x = xx;}static void in();static void out();void show() {cout << "x=" << x << endl;} };int A::a[20] = {0, 0};void A::in() {cout << "input a[20]:" << endl;for (int i = 0; i < 20; ++i)cin >> a[i];}void A::out() {for (int i = 0; i < 20; ++i)cout << "a[" << i << "]=" << a[i] << endl;}int main() {A::in();A::out();A a;a.out();a.show();return 0;} 十、友元 除了在同类对象之间共享数据外，类和类之间也可以共享数据。类的私有成员只能被类的成员函数访问，但是有时需要在类的外部访问类的私有成员，C++通过友元的手段实现这一特殊要求。友元可以是不属于任何类的一般函数，也可以是另一个类的成员函数，还可以是整个的一个类（这个类中的所有成员函数都可以成为友元函数）。 友元是C++提供的一种破坏数据封装和数据隐藏的机制。为了保证数据的完整性及数据封装与隐藏的原则，建议尽量不使用或少使用友元。 1.友元函数 （1）含义 如果在A类外定义一个函数（它可以是另一个类的成员函数，也可以是一个普通函数），在A类中声明该函数是A的友元函数后，这个函数就能访问A类中的所有成员。 （2）格式 friend 类型 类1::成员函数x(类2 &对象); friend 类型 函数y(类2 &对象); //类1是另一个类的类名，类2是本类的类名 功能：第一种形式在类2中声明类1的成员函数x为友元函数。第二种形式在类2中声明一个普通函数y是友元函数。 友元函数内访问对象的格式： 对象名.成员名 因为友元不是成员函数，它不属于类，所以它访问对象时必须冠以对象名。定义友元函数时形参通过定义引用对象，这样在友元函数内就能访问实参对象了。 （3）【例3.12】将普通函数声明为友元函数 include <iostream>using namespace std;class Time {public:Time(int, int, int);friend void display(Time &);private:int hour;int minute;int sec;};Time::Time(int h, int m, int s) {hour = h;minute = m;sec = s;}void display(Time &t) {cout << t.hour << ":" << t.minute << ":" << t.sec << endl;}int main() {Time t1(10, 13, 56);display(t1);return 0;} 【例】使用友元函数计算两点距离 include <iostream>include <cmath>using namespace std;class Point {public:Point(int xx = 0, int yy = 0) {X = xx;Y = yy;}int GetX() {return X;}int GetY() {return Y;}friend double Distance(Point &a, Point &b);private:int X, Y;};double Distance(Point &a, Point &b) {double dx = a.X - b.X;double dy = b.Y - b.Y;return sqrt(dx dx + dy dy);}int main() {Point p1(3.0, 5.0), p2(4.0, 6.0);double d = Distance(p1, p2);cout << "The distance is " << d << endl;return 0;} include <iostream>include <math.h>using namespace std;class TPoint {private:double x, y;public:TPoint(double a, double b) {x = a;y = b;cout << "点：（" << x << "," << y << "）" << endl;}friend double distance(TPoint &a, TPoint &b) {return sqrt((a.x - b.x) (a.x - b.x) + (a.y - b.y) (a.y - b.y));} };int main(int argc, char argv[]) {TPoint myp1(2.1, 1.3), myp2(5.4, 6.5);cout << "两点之间的距离为：";cout << distance(myp1, myp2) << endl;return 0;} （4）友元成员函数 【例3.13】将成员函数声明为友元函数 例子中有两个类Time和Date。其中Time类里定义了成员函数void display(Date &)，他除了显示时间外还要显示日期，这个日期通过引用形参访问。在Date类中将Time类的display成员函数定义为友元函数，允许display访问Date类的所有私有数据成员。 include <iostream>using namespace std;class Date;class Time {private:int hour;int minute;int sec;public:Time(int, int, int);void display(const Date &);};class Date {private:int month;int day;int year;public:Date(int, int, int);friend void Time::display(const Date &);};Time::Time(int h, int m, int s) hour = h;minute = m;sec = s;}void Time::display(const Date &da) {cout << da.month << "/" << da.day << "/" << da.year << endl;cout << hour << ":" << minute << ":" << sec << endl;}Date::Date(int m, int d, int y) {month = m;day = d;year = y;}int main() {Time t1(10, 13, 56);Date d1(12, 25, 2004);t1.display(d1);return 0;} 【注1】友元是单向的，此例中声明Time的成员函数display是Date类的友元，允许它访问Date类的所有成员，但不等于说Date类的成员函数也是Time类的友元。 【注2】一个函数（包括普通函数和成员函数）可以被多个类声明为“朋友”，这样就可以引用多个类中的私有数据 【注3】例如可以将例3.13程序中的display函数作为类外的普通函数，分别在Time和Date类中将display声明为友元。Display就可以分别引用Time和Date类的对象的私有数据成员。输出年月日和时分秒。 2.友元类 C++允许将一个类声明为另一个类的友元。假定A类是B类的友元类，A类中所有的成员函数都是B类的友元函数，在B类中声明A类为友元类的格式：friend A; 【注1】友元关系是单向的，不是双向的 【注2】友元关系不能传递 【注3】实际中一般不把整个类声明友元类，而只是将确有需要的成员函数声明为友元函数 include <iostream>include <math.h>using namespace std;class B;class A {private:int x;public:A() {x = 3;}friend class B;};class B {public:void disp1(A temp) {temp.x++;cout << "disp1:x" << temp.x << endl;}void disp2(A temp) {temp.x--;cout << "disp2:x" << temp.x << endl;} };int main(int argc, char argv[]) {A a;B b;b.disp1(a);b.disp2(a);return 0;} class Student; //前向声明，类名声明class Teacher{privated:int noOfStudents;Student pList[100];public:void assignGrades(Student &s); //赋成绩void adjustHours(Student &s); //调整学时数};class Student{privated:int hours;float gpa;public:friend class Teacher;};void Teacher::assignGrades(Student &s){...};void Teacher::adjustHours(Student &s){...}; //函数定义必须在Student定义之后 十一、类模板 1.含义 对于功能相同而只是数据类型不同的函数，不必须定义出所有函数，我们定义一个可对任何类型变量操作的函数模板。对于功能相同的类而数据类型不同，不必定义出所有类，只要定义一个可对任何类进行操作的类模板。 例如定义比较两个整数的类和比较两个浮点数的类，这两个类做的工作是相似的，所以可以用类模板，减少工作量。 class Compare_int{private:int x,y;public:Compare_int(int a,int b){x=a;y=b;}int max(){return (x>y)?x:y;}int min(){return (x<y)?x:y;} };class Compare_float{private:float x,y;public:Compare_float(float a,float b){x=a;y=b;}float max(){return (x>y)?x:y;}float min(){return (x<y)?x:y;} }; 2.定义类模板的格式 template <class 类型参数名> class 类模板名 {……} 类型参数名：按标识符取名。如有多个类型参数，每个类型参数都要以class为前导，两个类型参数之间用逗号分隔 类模板名：按标识符取名 类模板{...}内定义数据成员和成员函数的规则：用类型参数作为数据类型，用类模板名作为类 template<class numtype>class Compare{private:numtype x,y;public:Compare(numtype a,numtype b){x=a,y=b;}numtype max(){return (x>y)?x:y;}numtype min(){return (x<y)?x:y;} }; 3.在类模板外定义成员函数的语法 类型参数 类模板名<类型参数>::成员函数名（形参表）{……} 例如在类模板外定义max和min成员函数 template<class numtype>class Compare{public:Compare(numtype a,numtype b){x=a,y=b;}numtype max();numtype min();private:numtype x,y;};numtype Compare<numtype>::max(){return(x>y)?x:y;}numtype Compare<numtype>::min(){return(x<y)?x:y;} 4.使用类模板时，定义对象的格式 类模板名 <实际类型名>对象名； 类模板名 <实际类型名>对象名（实参表）； 例如：Compare <int>cmp2(4,7) 在编译时， 编译系统用int取代类模板中的类型参数numtype，就把类模板具体化了。这时Compare<int>将相当于Compare_int类。 5.【例3.14】声明类模板，实现两个整数、浮点数和字符的比较，求出大数和小数 include <iostream>using namespace std;template<class numtype>class Compare {private:numtype x, y;public:Compare(numtype a, numtype b) {x = a;y = b;}numtype max() {return (x > y) ? x : y;}numtype min() {return (x < y) ? x : y;} };int main() {Compare<int>cmp1(3, 7);cout << cmp1.max() << "是两个整数中的大数." << endl;cout << cmp1.min() << "是两个整数中的小数." << endl;Compare<float>cmp2(45.78, 93.6);cout << cmp2.max() << "是两个浮点数中的大数." << endl;cout << cmp2.min() << "是两个浮点数中的小数." << endl;Compare<char>cmp3('a', 'A');cout << cmp3.max() << "是两个字符中的大者." << endl;cout << cmp3.min() << "是两个字符中的小者." << endl;return 0;} 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_72318954/article/details/127064376。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...是一种严格的安全确认机制，其安全性是非常高的，但是保证安全性的前提是牺牲了性能，这个就是分布式系统里面的CAP理论，做任何架构的前提需要有取舍。所以基于XA协议的分布式事务并发性不高，不适合高并发场景。 2、基于activemq的解决方案 如图： 1、支付宝扣款成功时往message表插入消息 2、message表有message_id(流水id，标识夸系统的一次转账操作),status（confirm，unconfirm） 3、timer扫描message表的unconfirm状态记录往activemq插入消息 4、余额宝收到消息消费消息时先查询message表如果有记录就不处理如果没记录就进行数据库增款操作 5、如果余额宝数据库操作成功往余额宝message表插入消息，表字段跟支付宝message一致 6、如果5操作成功，回调支付宝接口修改message表状态，把unconfirm状态转换成confirm状态 问题描述： 1、支付宝设计message表的目的 如果支付宝往activemq插入消息而余额宝消费消息异常，有可能是消费消息成功而事务操作异常，有可能是网络异常等等不确定因素。如果出现异常而activemq收到了确认消息的信号，这时候activemq中的消息是删除了的，消息丢失了。设置message表就是有一个消息存根，activemq中消息丢失了message表中的消息还在。解决了activemq消息丢失问题 2、余额宝设计message表的目的 当余额宝消费成功并且数据库操作成功时，回调支付宝的消息确认接口，如果回调接口时出现异常导致支付宝状态修改失败还是unconfirm状态，这时候还会被timer扫描到，又会往activemq插入消息，又会被余额宝消费一边，但是这条消息已经消费成功了的只是回调失败而已，所以就需要有一个这样的message表，当余额宝消费时先插入message表，如果message根据message_id能查询到记录就说明之前这条消息被消费过就不再消费只需要回调成功即可，如果查询不到消息就消费这条消息继续数据库操作，数据库操作成功就往message表插入消息。 这样就解决了消息重复消费问题，这也是消费端的幂等操作。 基于消息中间件的分布式事务是最理想的分布式事务解决方案，兼顾了安全性和并发性！ 接下来贴代码： 支付宝代码： @Controller@RequestMapping("/order")public class OrderController {/ @Description TODO @param @return 参数 @return String 返回类型 @throws userID：转账的用户ID amount：转多少钱/@Autowired@Qualifier("activemq")OrderService orderService;@RequestMapping("/transfer")public @ResponseBody String transferAmount(String userId,String messageId, int amount) {try {orderService.updateAmount(amount,messageId, userId);}catch (Exception e) {e.printStackTrace();return "===============================transferAmount failed===================";}return "===============================transferAmount successfull===================";}@RequestMapping("/callback")public String callback(String param) {JSONObject parse = JSONObject.parseObject(param);String respCode = parse.getString("respCode");if(!"OK".equalsIgnoreCase(respCode)) {return null;}try {orderService.updateMessage(param);}catch (Exception e) {e.printStackTrace();return "fail";}return "ok";} } public interface OrderService {public void updateAmount(int amount, String userId,String messageId);public void updateMessage(String param);} @Service("activemq")@Transactional(rollbackFor = Exception.class)public class OrderServiceActivemqImpl implements OrderService {Logger logger = LoggerFactory.getLogger(getClass());@AutowiredJdbcTemplate jdbcTemplate;@AutowiredJmsTemplate jmsTemplate;@Overridepublic void updateAmount(final int amount, final String messageId, final String userId) {String sql = "update account set amount = amount - ?,update_time=now() where user_id = ?";int count = jdbcTemplate.update(sql, new Object[]{amount, userId});if (count == 1) {//插入到消息记录表sql = "insert into message(user_id,message_id,amount,status) values (?,?,?,?)";int row = jdbcTemplate.update(sql,new Object[]{userId,messageId,amount,"unconfirm"});if(row == 1) {//往activemq中插入消息jmsTemplate.send("zg.jack.queue", new MessageCreator() {@Overridepublic Message createMessage(Session session) throws JMSException {com.zhuguang.jack.bean.Message message = new com.zhuguang.jack.bean.Message();message.setAmount(Integer.valueOf(amount));message.setStatus("unconfirm");message.setUserId(userId);message.setMessageId(messageId);return session.createObjectMessage(message);} });} }}@Overridepublic void updateMessage(String param) {JSONObject parse = JSONObject.parseObject(param);String messageId = parse.getString("messageId");String sql = "update message set status = ? where message_id = ?";int count = jdbcTemplate.update(sql,new Object[]{"confirm",messageId});if(count == 1) {logger.info(messageId + " callback successfull");} }} activemq.xml <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:amq="http://activemq.apache.org/schema/core"xmlns:jms="http://www.springframework.org/schema/jms"xmlns:context="http://www.springframework.org/schema/context"xmlns:mvc="http://www.springframework.org/schema/mvc"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.1.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.1.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-4.1.xsdhttp://www.springframework.org/schema/jmshttp://www.springframework.org/schema/jms/spring-jms-4.1.xsdhttp://activemq.apache.org/schema/corehttp://activemq.apache.org/schema/core/activemq-core-5.12.1.xsd"><context:component-scan base-package="com.zhuguang.jack" /><mvc:annotation-driven /><amq:connectionFactory id="amqConnectionFactory"brokerURL="tcp://192.168.88.131:61616"userName="system"password="manager" /><!-- 配置JMS连接工长 --><bean id="connectionFactory"class="org.springframework.jms.connection.CachingConnectionFactory"><constructor-arg ref="amqConnectionFactory" /><property name="sessionCacheSize" value="100" /></bean><!-- 定义消息队列（Queue） --><bean id="demoQueueDestination" class="org.apache.activemq.command.ActiveMQQueue"><!-- 设置消息队列的名字 --><constructor-arg><value>zg.jack.queue</value></constructor-arg></bean><!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 --><bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"><property name="connectionFactory" ref="connectionFactory" /><property name="defaultDestination" ref="demoQueueDestination" /><property name="receiveTimeout" value="10000" /><!-- true是topic，false是queue，默认是false，此处显示写出false --><property name="pubSubDomain" value="false" /></bean></beans> spring-dispatcher.xml <beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"xmlns:context="http://www.springframework.org/schema/context"xmlns:task="http://www.springframework.org/schema/task" xmlns:aop="http://www.springframework.org/schema/aop"xmlns:tx="http://www.springframework.org/schema/tx"xmlns:util="http://www.springframework.org/schema/util" xmlns:mvc="http://www.springframework.org/schema/mvc"xsi:schemaLocation="http://www.springframework.org/schema/utilhttp://www.springframework.org/schema/util/spring-util-3.2.xsdhttp://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-3.2.xsdhttp://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.0.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"><!-- 引入同文件夹下的redis属性配置文件 --><!-- 解决springMVC响应数据乱码 text/plain就是响应的时候原样返回数据--><import resource="../activemq/activemq.xml"/><!--<context:property-placeholder ignore-unresolvable="true" location="classpath:config/core/core.properties,classpath:config/redis/redis-config.properties" />--><bean id="propertyConfigurerForProject1" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="order" value="1" /><property name="ignoreUnresolvablePlaceholders" value="true" /><property name="location"><value>classpath:config/core/core.properties</value></property></bean><mvc:annotation-driven><mvc:message-converters register-defaults="true"><bean class="org.springframework.http.converter.StringHttpMessageConverter"><property name="supportedMediaTypes" value = "text/plain;charset=UTF-8" /></bean></mvc:message-converters></mvc:annotation-driven><!-- 避免IE执行AJAX时,返回JSON出现下载文件 --><bean id="mappingJacksonHttpMessageConverter" class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"><property name="supportedMediaTypes"><list><value>text/html;charset=UTF-8</value></list></property></bean><!-- 开启controller注解支持 --><!-- 注：如果base-package=com.avicit 则注解事务不起作用 TODO 读源码 --><context:component-scan base-package="com.zhuguang"></context:component-scan><mvc:view-controller path="/" view-name="redirect:/index" /><beanclass="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" /><bean id="handlerAdapter"class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"></bean><beanclass="org.springframework.web.servlet.view.ContentNegotiatingViewResolver"><property name="mediaTypes"><map><entry key="json" value="application/json" /><entry key="xml" value="application/xml" /><entry key="html" value="text/html" /></map></property><property name="viewResolvers"><list><bean class="org.springframework.web.servlet.view.BeanNameViewResolver" /><bean class="org.springframework.web.servlet.view.UrlBasedViewResolver"><property name="viewClass" value="org.springframework.web.servlet.view.JstlView" /><property name="prefix" value="/" /><property name="suffix" value=".jsp" /></bean></list></property></bean><!-- 支持上传文件 --> <!-- 控制器异常处理 --><bean id="exceptionResolver"class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver"><property name="exceptionMappings"><props><prop key="java.lang.Exception">error</prop></props></property></bean><bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"><property name="driverClass"><value>${jdbc.driverClassName}</value></property><property name="jdbcUrl"><value>${jdbc.url}</value></property><property name="user"><value>${jdbc.username}</value></property><property name="password"><value>${jdbc.password}</value></property><property name="minPoolSize" value="10" /><property name="maxPoolSize" value="100" /><property name="maxIdleTime" value="1800" /><property name="acquireIncrement" value="3" /><property name="maxStatements" value="1000" /><property name="initialPoolSize" value="10" /><property name="idleConnectionTestPeriod" value="60" /><property name="acquireRetryAttempts" value="30" /><property name="breakAfterAcquireFailure" value="false" /><property name="testConnectionOnCheckout" value="false" /><property name="acquireRetryDelay"><value>100</value></property></bean><bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource" ref="dataSource"></property></bean><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"/></bean><tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" /><aop:aspectj-autoproxy expose-proxy="true"/></beans> logback.xml <?xml version="1.0" encoding="UTF-8"?><!--scan：当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。scanPeriod：设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒当scan为true时，此属性生效。默认的时间间隔为1分钟。debug：当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。--><configuration scan="false" scanPeriod="60 seconds" debug="false"><!-- 定义日志的根目录 --><!-- <property name="LOG_HOME" value="/app/log" /> --><!-- 定义日志文件名称 --><property name="appName" value="netty"></property><!-- ch.qos.logback.core.ConsoleAppender 表示控制台输出 --><appender name="stdout" class="ch.qos.logback.core.ConsoleAppender"><Encoding>UTF-8</Encoding><!--日志输出格式：%d表示日期时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度%logger{50} 表示logger名字最长50个字符，否则按照句点分割。 %msg：日志消息，%n是换行符--><encoder><pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern></encoder></appender><!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 --> <appender name="appLogAppender" class="ch.qos.logback.core.rolling.RollingFileAppender"><Encoding>UTF-8</Encoding><!-- 指定日志文件的名称 --> <file>${appName}.log</file><!--当发生滚动时，决定 RollingFileAppender 的行为，涉及文件移动和重命名TimeBasedRollingPolicy： 最常用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动。--><rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"><!--滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}：按天进行日志滚动 %i：当文件大小超过maxFileSize时，按照i进行文件滚动--><fileNamePattern>${appName}-%d{yyyy-MM-dd}-%i.log</fileNamePattern><!-- 可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件。假设设置每天滚动，且maxHistory是365，则只保存最近365天的文件，删除之前的旧文件。注意，删除旧文件是，那些为了归档而创建的目录也会被删除。--><MaxHistory>365</MaxHistory><!-- 当日志文件超过maxFileSize指定的大小是，根据上面提到的%i进行日志文件滚动 注意此处配置SizeBasedTriggeringPolicy是无法实现按文件大小进行滚动的，必须配置timeBasedFileNamingAndTriggeringPolicy--><timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP"><maxFileSize>100MB</maxFileSize></timeBasedFileNamingAndTriggeringPolicy></rollingPolicy><!--日志输出格式：%d表示日期时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %logger{50} 表示logger名字最长50个字符，否则按照句点分割。 %msg：日志消息，%n是换行符--> <encoder><pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [ %logger{50} : %line ] - %msg%n</pattern></encoder></appender><!-- logger主要用于存放日志对象，也可以定义日志类型、级别name：表示匹配的logger类型前缀，也就是包的前半部分level：要记录的日志级别，包括 TRACE < DEBUG < INFO < WARN < ERRORadditivity：作用在于children-logger是否使用 rootLogger配置的appender进行输出，false：表示只用当前logger的appender-ref，true：表示当前logger的appender-ref和rootLogger的appender-ref都有效--><!-- <logger name="edu.hyh" level="info" additivity="true"><appender-ref ref="appLogAppender" /></logger> --><!-- root与logger是父子关系，没有特别定义则默认为root，任何一个类只会和一个logger对应，要么是定义的logger，要么是root，判断的关键在于找到这个logger，然后判断这个logger的appender和level。 --><root level="debug"><appender-ref ref="stdout" /><appender-ref ref="appLogAppender" /></root></configuration> 2、余额宝代码 package com.zhuguang.jack.controller;import com.alibaba.fastjson.JSONObject;import com.zhuguang.jack.service.OrderService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;@Controller@RequestMapping("/order")public class OrderController {/ @Description TODO @param @return 参数 @return String 返回类型 @throws 模拟银行转账 userID：转账的用户ID amount：转多少钱/@AutowiredOrderService orderService;@RequestMapping("/transfer")public @ResponseBody String transferAmount(String userId, String amount) {try {orderService.updateAmount(Integer.valueOf(amount), userId);}catch (Exception e) {e.printStackTrace();return "===============================transferAmount failed===================";}return "===============================transferAmount successfull===================";} } 消息监听器 package com.zhuguang.jack.listener;import com.alibaba.fastjson.JSONObject;import com.zhuguang.jack.service.OrderService;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.http.client.SimpleClientHttpRequestFactory;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.web.client.RestTemplate;import javax.jms.JMSException;import javax.jms.Message;import javax.jms.MessageListener;import javax.jms.ObjectMessage;@Service("queueMessageListener")public class QueueMessageListener implements MessageListener {private Logger logger = LoggerFactory.getLogger(getClass());@AutowiredOrderService orderService;@Transactional(rollbackFor = Exception.class)@Overridepublic void onMessage(Message message) {if (message instanceof ObjectMessage) {ObjectMessage objectMessage = (ObjectMessage) message;try {com.zhuguang.jack.bean.Message message1 = (com.zhuguang.jack.bean.Message) objectMessage.getObject();String userId = message1.getUserId();int count = orderService.queryMessageCountByUserId(userId);if (count == 0) {orderService.updateAmount(message1.getAmount(), message1.getUserId());orderService.insertMessage(message1.getUserId(), message1.getMessageId(), message1.getAmount(), "ok");} else {logger.info("异常转账");}RestTemplate restTemplate = createRestTemplate();JSONObject jo = new JSONObject();jo.put("messageId", message1.getMessageId());jo.put("respCode", "OK");String url = "http://jack.bank_a.com:8080/alipay/order/callback?param="+ jo.toJSONString();restTemplate.getForObject(url,null);} catch (JMSException e) {e.printStackTrace();throw new RuntimeException("异常");} }}public RestTemplate createRestTemplate() {SimpleClientHttpRequestFactory simpleClientHttpRequestFactory = new SimpleClientHttpRequestFactory();simpleClientHttpRequestFactory.setConnectTimeout(3000);simpleClientHttpRequestFactory.setReadTimeout(2000);return new RestTemplate(simpleClientHttpRequestFactory);} } package com.zhuguang.jack.service;public interface OrderService {public void updateAmount(int amount, String userId);public int queryMessageCountByUserId(String userId);public int insertMessage(String userId,String messageId,int amount,String status);} package com.zhuguang.jack.service;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.http.client.SimpleClientHttpRequestFactory;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.web.client.RestTemplate;@Service@Transactional(rollbackFor = Exception.class)public class OrderServiceImpl implements OrderService {private Logger logger = LoggerFactory.getLogger(getClass());@AutowiredJdbcTemplate jdbcTemplate;/ 更新数据库表，把账户余额减去amountd/@Overridepublic void updateAmount(int amount, String userId) {//1、农业银行转账3000，也就说农业银行jack账户要减3000String sql = "update account set amount = amount + ?,update_time=now() where user_id = ?";int count = jdbcTemplate.update(sql, new Object[] {amount, userId});if (count != 1) {throw new RuntimeException("订单创建失败，农业银行转账失败！");} }public RestTemplate createRestTemplate() {SimpleClientHttpRequestFactory simpleClientHttpRequestFactory = new SimpleClientHttpRequestFactory();simpleClientHttpRequestFactory.setConnectTimeout(3000);simpleClientHttpRequestFactory.setReadTimeout(2000);return new RestTemplate(simpleClientHttpRequestFactory);}@Overridepublic int queryMessageCountByUserId(String messageId) {String sql = "select count() from message where message_id = ?";int count = jdbcTemplate.queryForInt(sql, new Object[]{messageId});return count;}@Overridepublic int insertMessage(String userId, String message_id,int amount, String status) {String sql = "insert into message(user_id,message_id,amount,status) values(?,?,?)";int count = jdbcTemplate.update(sql, new Object[]{userId, message_id,amount, status});if(count == 1) {logger.info("Ok");}return count;} } activemq.xml <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:amq="http://activemq.apache.org/schema/core"xmlns:jms="http://www.springframework.org/schema/jms"xmlns:context="http://www.springframework.org/schema/context"xmlns:mvc="http://www.springframework.org/schema/mvc"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.1.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.1.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-4.1.xsdhttp://www.springframework.org/schema/jmshttp://www.springframework.org/schema/jms/spring-jms-4.1.xsdhttp://activemq.apache.org/schema/corehttp://activemq.apache.org/schema/core/activemq-core-5.12.1.xsd"><context:component-scan base-package="com.zhuguang.jack" /><mvc:annotation-driven /><amq:connectionFactory id="amqConnectionFactory"brokerURL="tcp://192.168.88.131:61616"userName="system"password="manager" /><!-- 配置JMS连接工长 --><bean id="connectionFactory"class="org.springframework.jms.connection.CachingConnectionFactory"><constructor-arg ref="amqConnectionFactory" /><property name="sessionCacheSize" value="100" /></bean><!-- 定义消息队列（Queue） --><bean id="demoQueueDestination" class="org.apache.activemq.command.ActiveMQQueue"><!-- 设置消息队列的名字 --><constructor-arg><value>zg.jack.queue</value></constructor-arg></bean><!-- 显示注入消息监听容器（Queue），配置连接工厂，监听的目标是demoQueueDestination，监听器是上面定义的监听器 --><bean id="queueListenerContainer"class="org.springframework.jms.listener.DefaultMessageListenerContainer"><property name="connectionFactory" ref="connectionFactory" /><property name="destination" ref="demoQueueDestination" /><property name="messageListener" ref="queueMessageListener" /></bean><!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 --><bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"><property name="connectionFactory" ref="connectionFactory" /><property name="defaultDestination" ref="demoQueueDestination" /><property name="receiveTimeout" value="10000" /><!-- true是topic，false是queue，默认是false，此处显示写出false --><property name="pubSubDomain" value="false" /></bean></beans> OK~~~~~~~~~~~~大功告成！！！， 如果大家觉得满意并且对技术感兴趣请加群：171239762， 纯技术交流群，非诚勿扰。 本篇文章为转载内容。原文链接：https://blog.csdn.net/luoyang_java/article/details/84953241。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...ouch 事件的传递机制，还特意画了，一个 就是 button LinearLayout 嵌套 。 Ｊ哥回答：就是这个， 这也难不倒我。因为Ｊ哥觉得　这个问题肯定会问到　所以　早有准备，这里　我就大体说下结论，详细原理　给你传送门。 我回答，这个很简单，只要你继承一下　button　　和　linearlayout　复写一下　三个方法　dispatchtouchEvent onInterceptTouchEvent 和onTouchEvent .就能很清楚的明白 传递的过程，我给你总的说下结论的，点击这个button，一般是 外面的父控件 先响应这个down 事件，然后 往子类里面传递，让子类 在往子类的下一级子类去传递，让最终的孩子去决定是不要要消费掉这个点击事件，如果消费掉，那么父类将不会响应，如果子类不消费，那么会退回到次级子类，然后看是否要消费，这样，一句话 就是父传子， 子决定要不要，不要 然后传回去。 这里有很详细 很详细的介绍， 包裹事件的分发。所以我就不罗嗦，http://blog.csdn.net/yanbober/article/details/45887547?ref=myread 面试官01问： 项目中图片的优化。 Ｊ哥回答：我给他展示的项目 其中有一款app 是有很多图片 ，但是 很流畅，也没有oom。关于图片 优化，一般我们采用三级缓存，1 。内存加载 2.本地加载 3 网络加载。 首先 我们看 内存中有没有，有直接拿来用，这里 我项目里是这样做的，我先获取一下 分配给我们应用的可用内存是多少，然后 拿1/4 或者 1/8做一个 lrucache. 把我们的bitmap对象添加进去。有些比较常用的图片，我会保存到本地，避免每次重复联网下载。结合 开源的 afinal universalimageloader 以及 13年谷歌官方推荐的volley(号称是 asynchttpclient 和universalimageloader)的结合、 所以 在我的项目中基本没有遇到过图片导致的oom 问题，对于单张的 大图片，我也会利用bitmapFactory，进行计算大小，然后 计算手机分辨率，进行定量的 压缩 处理。 面试官问： GC的回收 Ｊ哥回答：我说。GC 回收 应该不只是按照一种方式，应该有多种不同的算法，我看过谷歌 官网介绍的一点，有这样一块区域，他分为 latest（最近） middle（中等）permanent（永久的），这样三块子区域。里面分别存放，刚刚被创建的，以及 时间 靠后的，很久的，对象，不断地新对象 往latest里面添加，当达到相应对象区域的阀值的时候，就会触发GC，GC 进行回收的时候，对于latest 中回收的速度是最快的，而permanent 相对是最久的，而时间 也跟 每块区域中对象的个数有关系， 还有一种算法，是根据最近被引用的时间，或者 被引用的次数 去进行 GC的、、这里随便扯就是了。GC 回收并不是立即执行的。是不定时的。ＧＣ回收的时候　会阻塞线程，所以代码中要避免创建不必要的对象，例如ｆｏｒ循环中　创建大量对象　就会容易引起ＧＣ。 当我们也可以主动 在方法中执行system.gc() 去手动释放一些资源。 面试官01问： 怎么避免 viewpager 预加载 fragment的、 Ｊ哥回答：这个问题 我也碰到过，我们都知道，viewpager 它本身会预加载 左右两个 和当前一个对象、而 我们viewpager setOffscreenPageLimit(0) 不生效因为看源码知道，这个方法默认最少也要加载一个。所以 这个fragment 还没有被当前页面显示出来，已经夹在好了，有可能数据不是最新的，我是在 setuservisibilityhint() 这个方法中跟参数 动态去判断 要不要刷新的。 问了一圈，这个哥们大概没什么问的了，然后 就让我等一下，说让他们技术总监过来 。 我就等。。。 然后等了几分钟，进来一小姑娘，坐下，看了我简历，我以为是人事，来跟我谈人生理想。结果，没说几句话，让我讲一下我的项目。我qu，惊呆我了。我问，你也是做android的，我去，是这样的、、把J哥吓到, 然后问了Ｊ哥几个问题。 Android 小姑娘问： 看你项目中的listview 中item类型 是统一的，而加入 item 差别挺大的 你怎么复用。 Ｊ哥回答：J哥装作很牛的样子说，我暂时想到两种方法，1.给这个对象 加一个type 然后 根据 type 去复用，或者 把这几种类型 一起加载，然后控制显示隐藏。然后 我反问小姑娘，假如 我这里 有一百条数据，这一百条是无序的，包含了 10种 item类型，你有没有什么好方法 去处理这个问题， 小姑娘说，你不是定义了类型吗，我们就是 通过type 去判断的。 Android 小姑娘问： onAttch onDetach还是onAttachedToWindow，onDetachedFromWindow Ｊ哥回答：其实 那个小姑娘忘记这两个方法了。我说什么方法，她说onAttachIntent() 和 onDetachIntent(). 反正 J哥是没听说过， 我只见过 onAttach ,但是 这个方法 我也没用过。我就问她，这两个方法是做什么的，小姑娘跟我说 是 把子view绑定到界面上的，那么的话 应该是onAttachedToWindow，onDetachedFromWindow方法了，小姑娘说： 在这个方法 可以计算子 view的高度宽度，在 oncreate 里面不能计算，其实虽然刚开始 在oncreate里面是不能计算，但是还是有方法计算的，（本人觉得面试 问你 API 是 最2的了，忍不住吐槽下，我遇到过，Camera 拍照，问我获取 一个图片，还是 视频的 方法，我去百度 一下，随便就知道，真是不懂 为什么会问方法。随便一个程序员 都会百度。。） 跟小姑娘聊得其他问题 不太记得了，感觉这个女程序员啊。。就问方法 给我的印象不太好，不管方法用没用到，我觉得面试 直接问你方法 好2 好2... 然后技术总监 有进来跟我聊了，后技术总监 有进来跟我聊了、技术总监 年龄30出头吧，到是没有问我什么技术问题， 总监： 问我 做没做过通信这块，能不能做这一块。 Ｊ哥回答：，我说做过，通信有几种协议的，我们用的 是xmpp协议的 ，服务器 是 基于apache的 openfire 搭建的，客户端 是用的asmack。还有一些 其他协议的 ，比如我知道有些项目中用的 soap协议的，还有ip 协议的。ＰＳ：反正就是扯 我说　通信　客户端这一块　我没问题，但是　服务端　我　从工作以来　一直偏向　ａｎｄｒｏｉｄ　移动端开发，后台这一块，如果数据量大了，还要考虑并发之类的，我是做不了，让我做个ｔｏｍｃａｔ搭建的ｄｅｍｏ　我可能可以。 其他也是随便聊了下，然后　就说，让人事来跟我谈理想了。 总监： 问我 什么时候能上班 Ｊ哥回答：我说 这个看公司需求啦。 其他也是随便聊了下，然后　就说，让人事来跟我谈理想了。 这里　感觉应该没问题了。差不多能拿下了。 人事１：一进来，就问东问西。问加班看法啊，他们公司技术　一般都八九点走啊。说七点基本没有走的啊、、、 Ｊ哥回答：我说，一般遇到项目加功能　，版本升级，等等　这些加班都没什么，只要不是一直在加班。。。。这里每个人自己看法就好了、、 反正人事　是一直跟我强调这个，她不停强调　我就暗暗下决心，薪资　我是不会要低了。 人事１：看你还年轻啊，还能拼一拼啊、、、、 Ｊ哥回答：我说现在　这几年对我人生规划也算比较重要的时期，也是过一年少一年了，其实她的意思　还是侧面强调加班。。。。日了UZI了。 中间一堆废话，然后我问了她 公司一般上下班时间啊。。之类的有没有技术交流啊，之类的。。。 最后到关键问题上啦，最关心的，薪资问题。 人事１：期望薪资 Ｊ哥回答：我说16K左右吧。她问 你以前公司多少 握手 15K。她说她们公司 是 14薪。反正 我还是说16K。她说 那好，你等下，然后就出去了。 不知道 跟什么人 讨论了许久，然后又来一个 可能是人事吧。又进来，问了一遍，也问了薪资。。哥还是说16K 。 。。估计是她们公司想要我，但是又觉得有点超出她们薪资期望吧，当场被没有给什么offer。然后就有点婉拒的说，两天给我答复，心里很气愤，饿着肚子 面试到三点，竟然婉拒、、、 反正我是很生气，我说，好，然后我就走。结果，没过一个小时，人事又打电话来，非要约我 见一下她们CEO。这是什么鬼，难道她们CEO要给我煲汤 了？我说可以，然后时间定在后天了，，反正心灵鸡汤对我是没用了、 OK ，这家面试 先写到这里，下面下午还有一家，等下在写。准备睡觉。今天面试回来，累的就睡着了，晚上十点多才醒过来，想了想还是 把今天面试的过程总结一下。 ------------------------------待续------------------------- 第二弹http://blog.csdn.net/u011733020/article/details/46058273 本篇文章为转载内容。原文链接：https://blog.csdn.net/haluoluo211/article/details/51010955。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...激始终作出一致反应的机制；而概率机模型则指即使输入确定，输出也存在一定的概率分布，即在特定情况下可能出现不同结果。在大脑思维过程中，这两种模型共同作用，反映了人类及其他生物思考的随机性和必然性，其中“灵魂”被比喻为旁观者，观察并体验着由概率机产生的各种心流状态。

...容需要通过统一的审核机制。如果是数量相对少的PGC内容，会直接进行风险审核，没有问题会大范围推荐。 UGC内容需要经过一个风险模型的过滤，有问题的会进入二次风险审核。审核通过后，内容会被真正进行推荐。这时如果收到一定量以上的评论或者举报负向反馈，还会再回到复审环节，有问题直接下架。 整个机制相对而言比较健全，作为行业领先者，在内容安全上，今日头条一直用最高的标准要求自己。 分享内容识别技术主要鉴黄模型，谩骂模型以及低俗模型。今日头条的低俗模型通过深度学习算法训练，样本库非常大，图片、文本同时分析。 这部分模型更注重召回率，准确率甚至可以牺牲一些。谩骂模型的样本库同样超过百万，召回率高达95%+，准确率80%+。如果用户经常出言不讳或者不当的评论，我们有一些惩罚机制。 泛低质识别涉及的情况非常多，像假新闻、黑稿、题文不符、标题党、内容质量低等等，这部分内容由机器理解是非常难的，需要大量反馈信息，包括其他样本信息比对。 目前低质模型的准确率和召回率都不是特别高，还需要结合人工复审，将阈值提高。目前最终的召回已达到95%，这部分其实还有非常多的工作可以做。别平台。 如果需要机器学习视频，可以在公众号后台聊天框回复【机器学习】，可以免费获取编程视频 。 你可能还喜欢 数学在机器学习中到底有多重要？ AI 新手学习路线，附上最详细的资源整理！ 提升机器学习数学基础，推荐7本书 酷爆了！围观2020年十大科技趋势 机器学习该如何入门，听听过来人的经验！ 长按加入T圈，接触人工智能 觉得内容还不错的话，给我点个“在看”呗 本篇文章为转载内容。原文链接：https://blog.csdn.net/itcodexy/article/details/109574173。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...tead. 延迟加载机制 jieba 采用延迟加载，import jieba 和 jieba.Tokenizer() 不会立即触发词典的加载，一旦有必要才开始加载词典构建前缀字典。如果你想手工初始 jieba，也可以手动初始化。 import jiebajieba.initialize() 手动初始化（可选） 在 0.28 之前的版本是不能指定主词典的路径的，有了延迟加载机制后，你可以改变主词典的路径: jieba.set_dictionary('data/dict.txt.big') 例子： https://github.com/fxsjy/jieba/blob/master/test/test_change_dictpath.py 其他词典 占用内存较小的词典文件 https://github.com/fxsjy/jieba/raw/master/extra_dict/dict.txt.small 支持繁体分词更好的词典文件 https://github.com/fxsjy/jieba/raw/master/extra_dict/dict.txt.big 下载你所需要的词典，然后覆盖 jieba/dict.txt 即可；或者用 jieba.set_dictionary('data/dict.txt.big') 其他语言实现 结巴分词 Java 版本 作者：piaolingxue 地址：https://github.com/huaban/jieba-analysis 结巴分词 C++ 版本 作者：yanyiwu 地址：https://github.com/yanyiwu/cppjieba 结巴分词 Rust 版本 作者：messense, MnO2 地址：https://github.com/messense/jieba-rs 结巴分词 Node.js 版本 作者：yanyiwu 地址：https://github.com/yanyiwu/nodejieba 结巴分词 Erlang 版本 作者：falood 地址：https://github.com/falood/exjieba 结巴分词 R 版本 作者：qinwf 地址：https://github.com/qinwf/jiebaR 结巴分词 iOS 版本 作者：yanyiwu 地址：https://github.com/yanyiwu/iosjieba 结巴分词 PHP 版本 作者：fukuball 地址：https://github.com/fukuball/jieba-php 结巴分词 .NET(C) 版本 作者：anderscui 地址：https://github.com/anderscui/jieba.NET/ 结巴分词 Go 版本 作者: wangbin 地址: https://github.com/wangbin/jiebago 作者: yanyiwu 地址: https://github.com/yanyiwu/gojieba 结巴分词Android版本 作者 Dongliang.W 地址：https://github.com/452896915/jieba-android 友情链接 https://github.com/baidu/lac 百度中文词法分析（分词+词性+专名）系统 https://github.com/baidu/AnyQ 百度FAQ自动问答系统 https://github.com/baidu/Senta 百度情感识别系统 系统集成 Solr: https://github.com/sing1ee/jieba-solr 分词速度 1.5 MB / Second in Full Mode 400 KB / Second in Default Mode 测试环境: Intel® Core™ i7-2600 CPU @ 3.4GHz；《围城》.txt 常见问题 1. 模型的数据是如何生成的？ 详见： https://github.com/fxsjy/jieba/issues/7 2. “台中”总是被切成“台 中”？（以及类似情况） P(台中) ＜ P(台)×P(中)，“台中”词频不够导致其成词概率较低 解决方法：强制调高词频 jieba.add_word('台中') 或者 jieba.suggest_freq('台中', True) 3. “今天天气 不错”应该被切成“今天 天气 不错”？（以及类似情况） 解决方法：强制调低词频 jieba.suggest_freq(('今天', '天气'), True) 或者直接删除该词 jieba.del_word('今天天气') 4. 切出了词典中没有的词语，效果不理想？ 解决方法：关闭新词发现 jieba.cut('丰田太省了', HMM=False) jieba.cut('我们中出了一个叛徒', HMM=False) 更多问题请点击：https://github.com/fxsjy/jieba/issues?sort=updated&state=closed 修订历史 https://github.com/fxsjy/jieba/blob/master/Changelog jieba “Jieba” (Chinese for “to stutter”) Chinese text segmentation: built to be the best Python Chinese word segmentation module. Features Support three types of segmentation mode: Accurate Mode attempts to cut the sentence into the most accurate segmentations, which is suitable for text analysis. Full Mode gets all the possible words from the sentence. Fast but not accurate. Search Engine Mode, based on the Accurate Mode, attempts to cut long words into several short words, which can raise the recall rate. Suitable for search engines. Supports Traditional Chinese Supports customized dictionaries MIT License Online demo http://jiebademo.ap01.aws.af.cm/ (Powered by Appfog) Usage Fully automatic installation: easy_install jieba or pip install jieba Semi-automatic installation: Download http://pypi.python.org/pypi/jieba/ , run python setup.py install after extracting. Manual installation: place the jieba directory in the current directory or python site-packages directory. import jieba. Algorithm Based on a prefix dictionary structure to achieve efficient word graph scanning. Build a directed acyclic graph (DAG) for all possible word combinations. Use dynamic programming to find the most probable combination based on the word frequency. For unknown words, a HMM-based model is used with the Viterbi algorithm. Main Functions Cut The jieba.cut function accepts three input parameters: the first parameter is the string to be cut; the second parameter is cut_all, controlling the cut mode; the third parameter is to control whether to use the Hidden Markov Model. jieba.cut_for_search accepts two parameter: the string to be cut; whether to use the Hidden Markov Model. This will cut the sentence into short words suitable for search engines. The input string can be an unicode/str object, or a str/bytes object which is encoded in UTF-8 or GBK. Note that using GBK encoding is not recommended because it may be unexpectly decoded as UTF-8. jieba.cut and jieba.cut_for_search returns an generator, from which you can use a for loop to get the segmentation result (in unicode). jieba.lcut and jieba.lcut_for_search returns a list. jieba.Tokenizer(dictionary=DEFAULT_DICT) creates a new customized Tokenizer, which enables you to use different dictionaries at the same time. jieba.dt is the default Tokenizer, to which almost all global functions are mapped. Code example: segmentation encoding=utf-8import jiebaseg_list = jieba.cut("我来到北京清华大学", cut_all=True)print("Full Mode: " + "/ ".join(seg_list)) 全模式seg_list = jieba.cut("我来到北京清华大学", cut_all=False)print("Default Mode: " + "/ ".join(seg_list)) 默认模式seg_list = jieba.cut("他来到了网易杭研大厦")print(", ".join(seg_list))seg_list = jieba.cut_for_search("小明硕士毕业于中国科学院计算所，后在日本京都大学深造") 搜索引擎模式print(", ".join(seg_list)) Output: [Full Mode]: 我/ 来到/ 北京/ 清华/ 清华大学/ 华大/ 大学[Accurate Mode]: 我/ 来到/ 北京/ 清华大学[Unknown Words Recognize] 他, 来到, 了, 网易, 杭研, 大厦 (In this case, "杭研" is not in the dictionary, but is identified by the Viterbi algorithm)[Search Engine Mode]： 小明, 硕士, 毕业, 于, 中国, 科学, 学院, 科学院, 中国科学院, 计算, 计算所, 后, 在, 日本, 京都, 大学, 日本京都大学, 深造 Add a custom dictionary Load dictionary Developers can specify their own custom dictionary to be included in the jieba default dictionary. Jieba is able to identify new words, but you can add your own new words can ensure a higher accuracy. Usage： jieba.load_userdict(file_name) file_name is a file-like object or the path of the custom dictionary The dictionary format is the same as that of dict.txt: one word per line; each line is divided into three parts separated by a space: word, word frequency, POS tag. If file_name is a path or a file opened in binary mode, the dictionary must be UTF-8 encoded. The word frequency and POS tag can be omitted respectively. The word frequency will be filled with a suitable value if omitted. For example: 创新办 3 i云计算 5凱特琳 nz台中 Change a Tokenizer’s tmp_dir and cache_file to specify the path of the cache file, for using on a restricted file system. Example: 云计算 5李小福 2创新办 3[Before]： 李小福 / 是 / 创新 / 办 / 主任 / 也 / 是 / 云 / 计算 / 方面 / 的 / 专家 /[After]：　李小福 / 是 / 创新办 / 主任 / 也 / 是 / 云计算 / 方面 / 的 / 专家 / Modify dictionary Use add_word(word, freq=None, tag=None) and del_word(word) to modify the dictionary dynamically in programs. Use suggest_freq(segment, tune=True) to adjust the frequency of a single word so that it can (or cannot) be segmented. Note that HMM may affect the final result. Example: >>> print('/'.join(jieba.cut('如果放到post中将出错。', HMM=False)))如果/放到/post/中将/出错/。>>> jieba.suggest_freq(('中', '将'), True)494>>> print('/'.join(jieba.cut('如果放到post中将出错。', HMM=False)))如果/放到/post/中/将/出错/。>>> print('/'.join(jieba.cut('「台中」正确应该不会被切开', HMM=False)))「/台/中/」/正确/应该/不会/被/切开>>> jieba.suggest_freq('台中', True)69>>> print('/'.join(jieba.cut('「台中」正确应该不会被切开', HMM=False)))「/台中/」/正确/应该/不会/被/切开 Keyword Extraction import jieba.analyse jieba.analyse.extract_tags(sentence, topK=20, withWeight=False, allowPOS=()) sentence: the text to be extracted topK: return how many keywords with the highest TF/IDF weights. The default value is 20 withWeight: whether return TF/IDF weights with the keywords. The default value is False allowPOS: filter words with which POSs are included. Empty for no filtering. jieba.analyse.TFIDF(idf_path=None) creates a new TFIDF instance, idf_path specifies IDF file path. Example (keyword extraction) https://github.com/fxsjy/jieba/blob/master/test/extract_tags.py Developers can specify their own custom IDF corpus in jieba keyword extraction Usage： jieba.analyse.set_idf_path(file_name) file_name is the path for the custom corpus Custom Corpus Sample：https://github.com/fxsjy/jieba/blob/master/extra_dict/idf.txt.big Sample Code：https://github.com/fxsjy/jieba/blob/master/test/extract_tags_idfpath.py Developers can specify their own custom stop words corpus in jieba keyword extraction Usage： jieba.analyse.set_stop_words(file_name) file_name is the path for the custom corpus Custom Corpus Sample：https://github.com/fxsjy/jieba/blob/master/extra_dict/stop_words.txt Sample Code：https://github.com/fxsjy/jieba/blob/master/test/extract_tags_stop_words.py There’s also a TextRank implementation available. Use: jieba.analyse.textrank(sentence, topK=20, withWeight=False, allowPOS=('ns', 'n', 'vn', 'v')) Note that it filters POS by default. jieba.analyse.TextRank() creates a new TextRank instance. Part of Speech Tagging jieba.posseg.POSTokenizer(tokenizer=None) creates a new customized Tokenizer. tokenizer specifies the jieba.Tokenizer to internally use. jieba.posseg.dt is the default POSTokenizer. Tags the POS of each word after segmentation, using labels compatible with ictclas. Example: >>> import jieba.posseg as pseg>>> words = pseg.cut("我爱北京天安门")>>> for w in words:... print('%s %s' % (w.word, w.flag))...我 r爱 v北京 ns天安门 ns Parallel Processing Principle: Split target text by line, assign the lines into multiple Python processes, and then merge the results, which is considerably faster. Based on the multiprocessing module of Python. Usage: jieba.enable_parallel(4) Enable parallel processing. The parameter is the number of processes. jieba.disable_parallel() Disable parallel processing. Example: https://github.com/fxsjy/jieba/blob/master/test/parallel/test_file.py Result: On a four-core 3.4GHz Linux machine, do accurate word segmentation on Complete Works of Jin Yong, and the speed reaches 1MB/s, which is 3.3 times faster than the single-process version. Note that parallel processing supports only default tokenizers, jieba.dt and jieba.posseg.dt. Tokenize: return words with position The input must be unicode Default mode result = jieba.tokenize(u'永和服装饰品有限公司')for tk in result:print("word %s\t\t start: %d \t\t end:%d" % (tk[0],tk[1],tk[2])) word 永和 start: 0 end:2word 服装 start: 2 end:4word 饰品 start: 4 end:6word 有限公司 start: 6 end:10 Search mode result = jieba.tokenize(u'永和服装饰品有限公司',mode='search')for tk in result:print("word %s\t\t start: %d \t\t end:%d" % (tk[0],tk[1],tk[2])) word 永和 start: 0 end:2word 服装 start: 2 end:4word 饰品 start: 4 end:6word 有限 start: 6 end:8word 公司 start: 8 end:10word 有限公司 start: 6 end:10 ChineseAnalyzer for Whoosh from jieba.analyse import ChineseAnalyzer Example: https://github.com/fxsjy/jieba/blob/master/test/test_whoosh.py Command Line Interface $> python -m jieba --helpJieba command line interface.positional arguments:filename input fileoptional arguments:-h, --help show this help message and exit-d [DELIM], --delimiter [DELIM]use DELIM instead of ' / ' for word delimiter; or aspace if it is used without DELIM-p [DELIM], --pos [DELIM]enable POS tagging; if DELIM is specified, use DELIMinstead of '_' for POS delimiter-D DICT, --dict DICT use DICT as dictionary-u USER_DICT, --user-dict USER_DICTuse USER_DICT together with the default dictionary orDICT (if specified)-a, --cut-all full pattern cutting (ignored with POS tagging)-n, --no-hmm don't use the Hidden Markov Model-q, --quiet don't print loading messages to stderr-V, --version show program's version number and exitIf no filename specified, use STDIN instead. Initialization By default, Jieba don’t build the prefix dictionary unless it’s necessary. This takes 1-3 seconds, after which it is not initialized again. If you want to initialize Jieba manually, you can call: import jiebajieba.initialize() (optional) You can also specify the dictionary (not supported before version 0.28) : jieba.set_dictionary('data/dict.txt.big') Using Other Dictionaries It is possible to use your own dictionary with Jieba, and there are also two dictionaries ready for download: A smaller dictionary for a smaller memory footprint: https://github.com/fxsjy/jieba/raw/master/extra_dict/dict.txt.small There is also a bigger dictionary that has better support for traditional Chinese (繁體): https://github.com/fxsjy/jieba/raw/master/extra_dict/dict.txt.big By default, an in-between dictionary is used, called dict.txt and included in the distribution. In either case, download the file you want, and then call jieba.set_dictionary('data/dict.txt.big') or just replace the existing dict.txt. Segmentation speed 1.5 MB / Second in Full Mode 400 KB / Second in Default Mode Test Env: Intel® Core™ i7-2600 CPU @ 3.4GHz；《围城》.txt 本篇文章为转载内容。原文链接：https://blog.csdn.net/yegeli/article/details/107246661。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...了一种灵活的身份验证机制，允许使用不同的身份验证插件来确保客户端连接的安全性。在my.cnf配置文件中，default_authentication_plugin参数用于指定MySQL服务器接受客户端连接时所使用的默认身份验证方法，例如caching_sha2_password，这是MySQL 8.0版本引入的一种更加安全的密码哈希算法实现的身份验证插件。

...容器之间共享的，这个机制可以极大减少镜像更新时候拉取镜像包的时间，通常应用程序更新升级都只是更新业务层（如Java程序的jar包），而镜像中的操作系统Lib层、运行时（如Jre）层等文件不会频繁更新。因此新版本镜像实质有变化的只有很小的一部分，在更新升级时候也只会从镜像仓库拉取很小的文件，所以速度很快。 应用资源调度：资源（计算/存储/网络）都是以应用为中心的，中心体现在资源分配是按照应用粒度分配资源、资源随应用迁移。 基于上述容器技术特点，可以推导出容器技术的3大使用场景：CI/CD、提升资源利用率、弹性伸缩。这3个使用场景自然推导出通用的商业层面收益：CI/CD提升研发效率、提升资源利用率降低成本、按需弹性伸缩在体验与成本之间达成平衡。 当然，除了商业目标之外，可能还有其他一些考虑因素，如基于容器技术实现计算任务调度平台、保持团队技术先进性等。 CI/CD提升研发效率 为什么容器技术适合CI/CD CI/CD是DevOps的关键组成部分，DevOps是一套软件工程的流程，用于持续提升软件开发效率与软件交付质量。DevOps流程来源于制造业的精益生产理念，在这个领域的领头羊是丰田公司，《丰田套路》这本书总结丰田公司如何通过PDCA(Plan-Do-Check-Act)方法实施持续改进。PDCA通常也称为PDCA循环，PDCA实施过程简要描述为：确定目标状态、分析当前状态、找出与目标状态的差距、制定实施计划、实施并总结、开始下一个PDCA过程。 DevOps基本也是这么一个PDCA流程循环，很容易认知到PDCA过程中效率是关键，同一时间段内，实施更多数量的PDCA过程，收益越高。在软件开发领域的DevOps流程中，各种等待（等待编译、等待打包、等待部署等）、各种中断（部署失败、机器故障）是影响DevOps流程效率的重要因素。 容器技术出来之后，将容器技术应用到DevOps场景下，可以从技术手段消除DevOps流程中的部分等待与中断，从而大幅度提升DevOps流程中CI/CD的效率。 容器的OCI标准定义了容器镜像规范，容器镜像包与传统的压缩包(zip/tgz等)相比有两个关键区别点：1）分层存储；2）打包即部署。 分层存储可以极大减少镜像更新时候拉取镜像包的时间，通常应用程序更新升级都只是更新业务层（如Java程序的jar包），而镜像中的操作系统Lib层、运行时（如Jre）层等文件不会频繁更新。因此新版本镜像实质有变化的只有很小的一部分，在更新升级时候也只会从镜像仓库拉取很小的文件，所以速度很快。 打包即部署是指在容器镜像制作过程包含了传统软件包部署的过程（安装依赖的操作系统库或工具、创建用户、创建运行目录、解压、设置文件权限等等），这么做的好处是把应用及其依赖封装到了一个相对封闭的环境，减少了应用对外部环境的依赖，增强了应用在各种不同环境下的行为一致性，同时也减少了应用部署时间。 基于容器镜像的这些优势，容器镜像用到CI/CD场景下，可以减少CI/CD过程中的等待时间，减少因环境差异而导致的部署中断，从而提升CI/CD的效率，提升整体研发效率。 CI/CD的关键诉求与挑战 快 开发人员本地开发调试完成后，提交代码，执行构建与部署，等待部署完成后验证功能。这个等待的过程尽可能短，否则开发人员工作容易被打断，造成后果就是效率降低。如果提交代码后几秒钟就能够完成部署，那么开发人员几乎不用等待，工作也不会被打断；如果需要好几分钟或十几分钟，那么可以想象，这十几分钟就是浪费了，这时候很容易做点别的事情，那么思路又被打断了。 所以构建CI/CD环境时候，快是第一个需要考虑的因素。要达到快，除了有足够的机器资源免除排队等待，引入并行编译技术也是常用做法，如Maven3支持多核并行构建。 自定义流程 不同行业存在不同的行业规范、监管要求，各个企业有一套内部质量规范，这些要求都对软件交付流程有定制需求，如要求使用商用的代码扫描工具做安全扫描，如构建结果与企业内部通信系统对接发送消息。 在团队协同方面，不同的公司，对DevOps流程在不同团队之间分工有差异，典型的有开发者负责代码编写构建出构建物（如jar包），而部署模板、配置由运维人员负责；有的企业开发人员负责构建并部署到测试环境；有的企业开发人员直接可以部署到生产环境。这些不同的场景，对CI/CD的流程、权限管控都有定制需求。 提升资源利用率 OCI标准包含容器镜像标准与容器运行时标准两部分，容器运行时标准聚焦在定义如何将镜像包从镜像仓库拉取到本地并更新、如何隔离运行时资源这些方面。得益于分层存储与打包即部署的特性，容器镜像从到镜像仓库拉取到本地运行速度非常快（通常小于30秒，依赖镜像本身大小等因素），基于此可以实现按需分配容器运行时资源（cpu与内存），并限定单个容器资源用量；然后根据容器进程资源使用率设定弹性伸缩规则，实现自动的弹性伸缩。 这种方式相对于传统的按峰值配置资源方式，可以提升资源利用率。 按需弹性伸缩在体验与成本之间达成平衡 联动弹性伸缩 应用运行到容器，按需分配资源之后，理想情况下，Kubernetes的池子里没有空闲的资源。这时候扩容应用实例数，新扩容的实例会因资源不足调度失败。这时候需要资源池能自动扩容，加入新的虚拟机，调度新扩容的应用。 由于应用对资源的配比与Flavor有要求，因此新加入的虚拟机，应当是与应用所需要的资源配比与Flavor一致的。缩容也是类似。 弹性伸缩还有一个诉求点是“平滑”，对业务做到不感知，也称为“优雅”扩容/缩容。 请求风暴 上面提到的弹性伸缩一般是有计划或缓慢增压的场景，存在另外一种无法预期的请求风暴场景，这种场景的特征是无法预测、突然请求量增大数倍或数十倍、持续时间短。典型的例子如行情交易系统，当行情突变的时候，用户访问量徒增，持续几十分钟或一个小时。 这种场景的弹性诉求，要求短时间内能将资源池扩大数倍，关键是速度要快（秒级），否则会来不及扩容，系统已经被冲垮（如果无限流的话）。 目前基于 Virtual Kubelet 与云厂家的 Serverless 容器，理论上可以提供应对请求风暴的方案。不过在具体实施时候，需要考虑传统托管式Kubernetes容器管理平台与Serverless容器之间互通的问题，需要基于具体厂家提供的能力来评估。 基于容器技术实现计算调度平台 计算（大数据/AI训练等）场景的特征是短时间内需要大量算力，算完即释放。容器的环境一致性以及调度便利性适合这种场景。 技术选型 容器技术是属于基础设施范围，但是与传统虚拟化技术（Xen/KVM）比较，容器技术是应用虚拟化，不是纯粹的资源虚拟化，与传统虚拟化存在差异。在容器技术选型时候，需要结合当前团队在应用管理与资源管理的现状，对照容器技术与虚拟化技术的差异，选择最合适的容器技术栈。 什么是容器技术 (1)容器是一种轻量化的应用虚拟化技术。 在讨论具体的容器技术栈的时候，先介绍目前几种常用的应用虚拟化技术，当前有3种主流的应用虚拟化技术: LXC，MicroVM，UniKernel（LibOS）。 LXC: Linux Container，通过 Linux的 namespace/cgroups/chroot 等技术隔离进程资源，目前应用最广的docker就是基于LXC实现应用虚拟化的。 MicroVM: MicroVM 介于 传统的VM 与 LXC之间，隔离性比LXC好，但是比传统的VM要轻量，轻量体现在体积小（几M到几十M）、启动快（小于1s）。 AWS Firecracker 就是一种MicroVM的实现，用于AWS的Serverless计算领域，Serverless要求启动快，租户之间隔离性好。 UniKernel: 是一种专用的（特定编程语言技术栈专用）、单地址空间、使用 library OS 构建出来的镜像。UniKernel要解决的问题是减少应用软件的技术栈层次，现代软件层次太多导致越来越臃肿：硬件+HostOS+虚拟化模拟+GuestOS+APP。UniKernel目标是：硬件+HostOS+虚拟化模拟+APP-with-libos。 三种技术对比表： 开销 体积 启动速度 隔离/安全 生态 LXC 低（几乎为0） 小 快（等同进程启动） 差（内核共享） 好 MicroVM 高 大 慢(小于1s) 好 中（Kata项目） UniKernel 中 中 中 好 差 根据上述对比来看，LXC是应用虚拟化首选的技术，如果LXC无法满足隔离性要，则可以考虑MicroVM这种技术。当前社区已经在着手融合LXC与MicroVM这两种技术，从应用打包/发布调度/运行层面统一规范，Kubernetes集成Kata支持混合应用调度特性可以了解一下。 UniKernel 在应用生态方面相对比较落后，目前在追赶中，目前通过 linuxkit 工具可以在UniKernel应用镜像中使用docker镜像。这种方式笔者还未验证过，另外docker镜像运行起来之后，如何监控目前还未知。 从上述三种应用虚拟化技术对比，可以得出结论: （2)容器技术与传统虚拟化技术不断融合中。 再从规范视角来看容器技术，可以将容器技术定义为: (3)容器=OCI+CRI+辅助工具。 OCI规范包含两部分，镜像规范与运行时规范。简要的说，要实现一个OCI的规范，需要能够下载镜像并解压镜像到文件系统上组成成一个文件目录结构，运行时工具能够理解这个目录结构并基于此目录结构管理（创建/启动/停止/删除）进程。 容器(container)的技术构成就是实现OCI规范的技术集合。 对于不同的操作系统（Linux/Windows），OCI规范的实现技术不同，当前docker的实现，支持Windows与Linux与MacOS操作系统。当前使用最广的是Linux系统，OCI的实现，在Linux上组成容器的主要技术： chroot: 通过分层文件系统堆叠出容器进程的rootfs，然后通过chroot设置容器进程的根文件系统为堆叠出的rootfs。 cgroups: 通过cgroups技术隔离容器进程的cpu/内存资源。 namesapce: 通过pid, uts, mount, network, user namesapce 分别隔离容器进程的进程ID，时间，文件系统挂载，网络，用户资源。 网络虚拟化: 容器进程被放置到独立的网络命名空间，通过Linux网络虚拟化veth, macvlan, bridge等技术连接主机网络与容器虚拟网络。 存储驱动: 本地文件系统，使用容器镜像分层文件堆叠的各种实现驱动，当前推荐的是overlay2。 广义的容器还包含容器编排，即当下很火热的Kubernetes。Kubernetes为了把控容器调度的生态，发布了CRI规范，通过CRI规范解耦Kubelet与容器，只要实现了CRI接口，都可以与Kubelet交互，从而被Kubernetes调度。OCI规范的容器实现与CRI标准接口对接的实现是CRI-O。 辅助工具用户构建镜像，验证镜像签名，管理存储卷等。 容器定义 容器是一种轻量化的应用虚拟化技术。 容器=OCI+CRI+辅助工具。 容器技术与传统虚拟化技术不断融合中。 什么是容器编排与调度 选择了应用虚拟化技术之后，还需要应用调度编排，当前Kubernetes是容器领域内编排的事实标准，不管使用何种应用虚拟化技术，都已经纳入到了Kubernetes治理框架中。 Kubernetes 通过 CRI 接口规范，将应用编排与应用虚拟化实现解耦：不管使用何种应用虚拟化技术（LXC, MicroVM, LibOS），都能够通过Kubernetes统一编排。 当前使用最多的是docker，其次是cri-o。docker与crio结合kata-runtime都能够支持多种应用虚拟化技术混合编排的场景，如LXC与MicroVM混合编排。 docker(now): Moby 公司贡献的 docker 相关部件，当前主流使用的模式。 docker(daemon) 提供对外访问的API与CLI(docker client) containerd 提供与 kubelet 对接的 CRI 接口实现 shim负责将Pod桥接到Host namespace。 cri-o: 由 RedHat/Intel/SUSE/IBM/Hyper 公司贡献的实现了CRI接口的符合OCI规范的运行时，当前包括 runc 与 kata-runtime ，也就是说使用 cir-o 可以同时运行LXC容器与MicroVM容器，具体在Kata介绍中有详细说明。 CRI-O: 实现了CRI接口的进程，与 kubelet 交互 crictl: 类似 docker 的命令行工具 conmon: Pod监控进程 other cri runtimes: 其他的一些cri实现，目前没有大规模应用到生产环境。 容器与传统虚拟化差异 容器(container)的技术构成 前面主要讲到的是容器与编排，包括CRI接口的各种实现，我们把容器领域的规范归纳为南向与北向两部分，CRI属于北向接口规范，对接编排系统，OCI就属于南向接口规范，实现应用虚拟化。 简单来讲，可以这么定义容器： 容器(container) ~= 应用打包(build) + 应用分发(ship) + 应用运行/资源隔离(run)。 build-ship-run 的内容都被定义到了OCI规范中，因此也可以这么定义容器： 容器(container) == OCI规范 OCI规范包含两部分，镜像规范与运行时规范。简要的说，要实现一个OCI的规范，需要能够下载镜像并解压镜像到文件系统上组成成一个文件目录结构，运行时工具能够理解这个目录结构并基于此目录结构管理（创建/启动/停止/删除）进程。 容器(container)的技术构成就是实现OCI规范的技术集合。 对于不同的操作系统（Linux/Windows），OCI规范的实现技术不同，当前docker的实现，支持Windows与Linux与MacOS操作系统。当前使用最广的是Linux系统，OCI的实现，在Linux上组成容器的主要技术： chroot: 通过分层文件系统堆叠出容器进程的rootfs，然后通过chroot设置容器进程的根文件系统为堆叠出的rootfs。 cgroups: 通过cgroups技术隔离容器进程的cpu/内存资源。 namesapce: 通过pid, uts, mount, network, user namesapce 分别隔离容器进程的进程ID，时间，文件系统挂载，网络，用户资源。 网络虚拟化: 容器进程被放置到独立的网络命名空间，通过Linux网络虚拟化veth, macvlan, bridge等技术连接主机网络与容器虚拟网络。 存储驱动: 本地文件系统，使用容器镜像分层文件堆叠的各种实现驱动，当前推荐的是overlay2。 广义的容器还包含容器编排，即当下很火热的Kubernetes。Kubernetes为了把控容器调度的生态，发布了CRI规范，通过CRI规范解耦Kubelet与容器，只要实现了CRI接口，都可以与Kubelet交互，从而被Kubernetes调度。OCI规范的容器实现与CRI标准接口对接的实现是CRI-O。 容器与虚拟机差异对比 容器与虚拟机的差异可以总结为2点：应用打包与分发的差异，应用资源隔离的差异。当然，导致这两点差异的根基是容器是以应用为中心来设计的，而虚拟化是以资源为中心来设计的，本文对比容器与虚拟机的差异，更多的是站在应用视角来对比。 从3个方面对比差异：资源隔离，应用打包与分发，延伸的日志/监控/DFX差异。 1.资源隔离 隔离机制差异 容器 虚拟化 mem/cpu cgroup, 使用时候设定 require 与 limit 值 QEMU, KVM network Linux网络虚拟化技术(veth,tap,bridge,macvlan,ipvlan), 跨虚拟机或出公网访问:SNAT/DNAT, service转发:iptables/ipvs, SR-IOV Linux网络虚拟化技术(veth,tap,bridge,macvlan,ipvlan), QEMU, SR-IOV storage 本地存储: 容器存储驱动 本地存储：virtio-blk 差异引入问题与实践建议 应用程序未适配 cgroup 的内存隔离导致问题: 典型的是 JVM 虚拟机，在 JVM 启动时候会根据系统内存自动设置 MaxHeapSize 值，通常是系统内存的1/4，但是 JVM 并未考虑 cgroup 场景，读系统内存时候任然读取主机的内存来设置 MaxHeapSize，这样会导致内存超过 cgroup 限制从而导致进程被 kill 。问题详细阐述与解决建议参考Java inside docker: What you must know to not FAIL。 多次网络虚拟化问题: 如果在虚拟机内使用容器，会多一层网络虚拟化，并加入了SNAT/DNAT技术, iptables/ipvs技术，对网络吞吐量与时延都有影响（具体依赖容器网络方案），对问题定位复杂度变高，同时还需要注意网络内核参数调优。 典型的网络调优参数有：转发表大小 /proc/sys/net/netfilter/nf_conntrack_max 使用iptables 作为service转发实现的时候，在转发规则较多的时候，iptables更新由于需要全量更新导致非常耗时，建议使用ipvs。详细参考[华为云在 K8S 大规模场景下的 Service 性能优化实践](https://zhuanlan.zhihu.com/p/37230013)。 容器IP地址频繁变化不固定，周边系统需要协调适配，包括基于IP地址的白名单或防火墙控制策略需要调整，CMDB记录的应用IP地址需要适配动态IP或者使用服务名替代IP地址。 存储驱动带来的性能损耗: 容器本地文件系统是通过联合文件系统方式堆叠出来的，当前主推与默认提供的是overlay2驱动，这种模式应用写本地文件系统文件或修改已有文件，使用Copy-On-Write方式，也就是会先拷贝源文件到可写层然后修改，如果这种操作非常频繁，建议使用 volume 方式。 2.应用打包与分发 应用打包/分发/调度差异 容器 虚拟化 打包 打包既部署 一般不会把应用程序与虚拟机打包在一起，通过部署系统部署应用 分发 使用镜像仓库存储与分发 使用文件存储 调度运行 使用K8S亲和/反亲和调度策略 使用部署系统的调度能力 差异引入问题与实践建议 部署提前到构建阶段，应用需要支持动态配置与静态程序分离；如果在传统部署脚本中依赖外部动态配置，这部分需要做一些调整。 打包格式发生变化，制作容器镜像需要注意安全/效率因素，可参考Dockerfile最佳实践 容器镜像存储与分发是按layer来组织的，镜像在传输过程中放篡改的方式是传统软件包有差异。 3.监控/日志/DFX 差异 容器 虚拟化 监控 cpu/mem的资源上限是cgroup定义的；containerd/shim/docker-daemon等进程的监控 传统进程监控 日志采集 stdout/stderr日志采集方式变化；日志持久化需要挂载到volume；进程会被随机调度到其他节点导致日志需要实时采集否则分散很难定位 传统日志采集 问题定位 进程down之后自动拉起会导致问题定位现场丢失；无法停止进程来定位问题因为停止即删除实例 传统问题定位手段 差异引入问题实践与建议 使用成熟的监控工具，运行在docker中的应用使用cadvisor+prometheus实现采集与警报，cadvisor中预置了常用的监控指标项 对于docker管理进程（containerd/shim/docker-daemon）也需要一并监控 使用成熟的日志采集工具，如果已有日志采集Agent，则可以考虑将日志文件挂载到volume后由Agent采集；需要注意的是stderr/stdout输出也要一并采集 如果希望容器内应用进程退出后保留现场定位问题，则可以将Pod的restartPolicy设置为never，进程退出后进程文件都还保留着(/var/lib/docker/containers)。但是这么做的话需要进程没有及时恢复，会影响业务，需要自己实现进程重拉起。 团队配合 与周边的开发团队、架构团队、测试团队、运维团队评审并交流方案，与周边团队达成一致。 落地策略与注意事项 逐步演进过程中网络互通 根据当前已经存在的基础实施情况，选择容器化落地策略。通常使用逐步演进的方式，由于容器化引入了独立的网络namespace导致容器与传统虚拟机进程网络隔离，逐步演进过程中如何打通隔离的网络是最大的挑战。 分两种场景讨论： 不同服务集群之间使用VIP模式互通: 这种模式相对简单，基于VIP做灰度发布。 不同服务集群之间使用微服务点对点模式互通(SpringCloud/ServiceComb/Dubbo都是这一类): 这种模式相对复杂，在逐步容器化过程中，要求容器网络与传统虚拟机网络能够互通（难点是在虚拟机进程内能够直接访问到容器网络的IP地址），当前解决这个问题有几种方法。 自建Kubernetes场景，可使用开源的kube-router，kube-router 使用BGP协议实现容器网络与传统虚拟机网络之间互通，要求网络交换机支持BGP协议。 使用云厂商托管Kubernetes场景，选择云厂商提供的VPC-Router互通的网络插件，如阿里云的Terway网络插件, 华为云的Underlay网络模式。 选择物理机还是虚拟机 选择物理机运行容器还是虚拟机运行容器，需要结合基础设施与业务隔离性要求综合考虑。分两种场景：自建IDC、租用公有云。 自建IDC: 理想情况是使用物理机组成一个大集群，根据业务诉求，对资源保障与安全性要求高的应用，使用MicorVM方式隔离；普通应用使用LXC方式隔离。所有物理机在一个大集群内，方便削峰填谷提升资源利用率。 租用公有云：当前公有云厂家提供的裸金属服务价格较贵且只能包周期，使用裸金属性价比并不高，使用虚拟机更合适。 集群规模与划分 选择集群时候，是多个应用共用一个大集群，还是按应用分组分成多个小集群呢？我们把节点规模数量>=1000的定义为大集群，节点数<1000的定义为小集群。 大集群的优点是资源池共享容器，方便资源调度（削峰填谷）；缺点是随着节点数量与负载数量的增多，会引入管理性能问题（需要量化）: DNS 解析表变大，增加/删除 Service 或 增加/删除 Endpoint 导致DNS表刷新慢 K8S Service 转发表变大，导致工作负载增加/删除刷新iptables/ipvs记录变慢 etcd 存储空间变大，如果加上ConfigMap，可能导致 etcd 访问时延增加 小集群的优点是不会有管理性能问题，缺点是会导致资源碎片化，不容易共享。共享分两种情况: 应用之间削峰填谷：目前无法实现 计算任务与应用之间削峰填谷：由于计算任务是短时任务，可以通过上层的任务调度软件，在多个集群之间分发计算任务，从而达到集群之间资源共享的目的。 选择集群规模的时候，可以参考上述分析，结合实际情况选择适合的集群划分。 Helm? Helm是为了解决K8S管理对象散碎的问题，在K8S中并没有"应用"的概念，只有一个个散的对象(Deployment, ConfigMap, Service, etc)，而一个"应用"是多个对象组合起来的，且这些对象之间还可能存在一定的版本配套关系。 Helm 通过将K8S多个对象打包为一个包并标注版本号形成一个"应用"，通过 Helm 管理进程部署/升级这个"应用"。这种方式解决了一些问题（应用分发更方便）同时也引入了一些问题（引入Helm增加应用发布/管理复杂度、在K8S修改了对象后如何同步到Helm）。对于是否需要使用Helm，建议如下： 在自运维模式下不使用Helm: 自运维模式下，很多场景是开发团队交付一个运行包，运维团队负责部署与配置下发，内部通过兼容性或软件包与配置版本配套清单、管理软件包与配置的配套关系。 在交付软件包模式下使用Helm: 交付软件包模式下，Helm 这种把散碎组件组装为一个应用的模式比较适合，使用Helm实现软件包分发/部署/升级场比较简单。 Reference DOCKER vs LXC vs VIRTUAL MACHINES Cgroup与LXC简介 Introducing Container Runtime Interface (CRI) in Kubernetes frakti rkt appc-spec OCI 和 runc：容器标准化和 docker Linux 容器技术史话：从 chroot 到未来 Linux Namespace和Cgroup Java inside docker: What you must know to not FAIL QEMU,KVM及QEMU-KVM介绍 kvm libvirt qemu实践系列(一)-kvm介绍 KVM 介绍（4）：I/O 设备直接分配和 SR-IOV [KVM PCI/PCIe Pass-Through SR-IOV] prometheus-book 到底什么是Unikernel？ The Rise and Fall of the Operating System The Design and Implementation of the Anykernel and Rump Kernels UniKernel Unikernel：从不入门到入门 OSv 京东如何打造K8s全球最大集群支撑万亿电商交易 Cloud Native App Hub 更多云最佳实践 https://best.practices.cloud 本篇文章为转载内容。原文链接：https://blog.csdn.net/sinat_33155975/article/details/118013855。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...，对于数据库系统内部机制的理解也至关重要，比如MySQL中的pipes_as_concat模式下字符串拼接符“||”的特殊作用，它警示开发者在构建查询时需考虑潜在的安全风险，并合理配置数据库参数以增强安全性。 总的来说，无论是针对传统SQL注入手法的深入探究，还是紧跟CVE公告及时发现并修复新出现的安全漏洞，CTF比赛所涵盖的各种实战演练都是广大网络安全从业者及爱好者丰富知识库、提高实战技能的有效途径。同时，这也提醒我们应时刻保持警惕，密切关注业界动态，不断提升自身的安全防护能力，确保在网络空间的攻防对抗中立于不败之地。

...是没有 vsync 机制的，CPU 和 GPU 的配合也比较混乱，这也造成著名的 tearing 问题，即 CPU/GPU 直接更新正在显示的屏幕 buffer 造成画面撕裂。 后续 Android 引入了双缓冲机制，但是 buffer 的切换也需要一个比较合适的时机，也就是屏幕扫描完上一帧后的时机，这也就是引入 vsync 的原因。 早先一般的屏幕刷新率是 60fps，所以每个 vsync 信号的间隔也是 16ms，不过随着技术的更迭以及厂商对于流畅性的追求，越来越多 90fps 和 120fps 的手机面世，相对应的间隔也就变成了 11ms 和 8ms。 VSYNC信号种类： 1.屏幕产生的硬件VSYNC：硬件VSYNC是一种脉冲信号，起到开关和触发某种操作的作用。 2.由SurfaceFlinger将其转成的软件VSYNC信号，经由Binder传递给Choreographer Choreographer： 编舞者，用于注册VSYNC信号并接收VSYNC信号回调，当内部接收到这个信号时最终会调用到doFrame进行帧的绘制操作。 Choreographer在系统中流程： 如何通过Choreographer计算掉帧情况：原理就是: 通过给Choreographer设置FrameCallback，在每次绘制前后看时间差是16.6ms的多少倍，即为前后掉帧率。 使用方式如下： //Application.javapublic void onCreate() {super.onCreate();//在Application中使用postFrameCallbackChoreographer.getInstance().postFrameCallback(new FPSFrameCallback(System.nanoTime()));}public class FPSFrameCallback implements Choreographer.FrameCallback {private static final String TAG = "FPS_TEST";private long mLastFrameTimeNanos = 0;private long mFrameIntervalNanos;public FPSFrameCallback(long lastFrameTimeNanos) {mLastFrameTimeNanos = lastFrameTimeNanos;mFrameIntervalNanos = (long)(1000000000 / 60.0);}@Overridepublic void doFrame(long frameTimeNanos) {//初始化时间if (mLastFrameTimeNanos == 0) {mLastFrameTimeNanos = frameTimeNanos;}final long jitterNanos = frameTimeNanos - mLastFrameTimeNanos;if (jitterNanos >= mFrameIntervalNanos) {final long skippedFrames = jitterNanos / mFrameIntervalNanos;if(skippedFrames>30){//丢帧30以上打印日志Log.i(TAG, "Skipped " + skippedFrames + " frames! "+ "The application may be doing too much work on its main thread.");} }mLastFrameTimeNanos=frameTimeNanos;//注册下一帧回调Choreographer.getInstance().postFrameCallback(this);} } UI绘制全路径分析： 有了前面几个概念，这里我们让SurfaceFlinger结合View的绘制流程用一张图来表达整个绘制流程： 生产者：APP方构建Surface的过程。 消费者：SurfaceFlinger UI绘制全路径分析卡顿原因： 接下来，我们逐个分析，看看都会有哪些原因可能造成卡顿： 1.渲染流程 1.Vsync 调度：这个是起始点，但是调度的过程会经过线程切换以及一些委派的逻辑，有可能造成卡顿，但是一般可能性比较小，我们也基本无法介入； 2.消息调度：主要是 doframe Message 的调度，这就是一个普通的 Handler 调度，如果这个调度被其他的 Message 阻塞产生了时延，会直接导致后续的所有流程不会被触发 3.input 处理：input 是一次 Vsync 调度最先执行的逻辑，主要处理 input 事件。如果有大量的事件堆积或者在事件分发逻辑中加入大量耗时业务逻辑，会造成当前帧的时长被拉大，造成卡顿，可以尝试通过事件采样的方案，减少 event 的处理 4.动画处理：主要是 animator 动画的更新，同理，动画数量过多，或者动画的更新中有比较耗时的逻辑，也会造成当前帧的渲染卡顿。对动画的降帧和降复杂度其实解决的就是这个问题； 5.view 处理：主要是接下来的三大流程，过度绘制、频繁刷新、复杂的视图效果都是此处造成卡顿的主要原因。比如我们平时所说的降低页面层级，主要解决的就是这个问题； 6.measure/layout/draw：view 渲染的三大流程，因为涉及到遍历和高频执行，所以这里涉及到的耗时问题均会被放大，比如我们会降不能在 draw 里面调用耗时函数，不能 new 对象等等； 7.DisplayList 的更新：这里主要是 canvas 和 displaylist 的映射，一般不会存在卡顿问题，反而可能存在映射失败导致的显示问题； 8.OpenGL 指令转换：这里主要是将 canvas 的命令转换为 OpenGL 的指令，一般不存在问题 9.buffer 交换：这里主要指 OpenGL 指令集交换给 GPU，这个一般和指令的复杂度有关 10.GPU 处理：顾名思义，这里是 GPU 对数据的处理，耗时主要和任务量和纹理复杂度有关。这也就是我们降低 GPU 负载有助于降低卡顿的原因； 11.layer 合成：Android P 修改了 Layer 的计算方法 , 把这部分放到了 SurfaceFlinger 主线程去执行, 如果后台 Layer 过多, 就会导致 SurfaceFlinger 在执行 rebuildLayerStacks 的时候耗时 , 导致 SurfaceFlinger 主线程执行时间过长。 可以选择降低Surface层级来优化卡顿。 12.光栅化/Display：这里暂时忽略，底层系统行为； Buffer 切换：主要是屏幕的显示，这里 buffer 的数量也会影响帧的整体延迟，不过是系统行为，不能干预。 2.系统负载 内存：内存的吃紧会直接导致 GC 的增加甚至 ANR，是造成卡顿的一个不可忽视的因素； CPU：CPU 对卡顿的影响主要在于线程调度慢、任务执行的慢和资源竞争，比如 1.降频会直接导致应用卡顿； 2.后台活动进程太多导致系统繁忙，cpu \ io \ memory 等资源都会被占用, 这时候很容易出现卡顿问题 ，这种情况比较常见,可以使用dumpsys cpuinfo查看当前设备的cpu使用情况： 3.主线程调度不到 , 处于 Runnable 状态，这种情况比较少见 4.System 锁：system_server 的 AMS 锁和 WMS 锁 , 在系统异常的情况下 , 会变得非常严重 , 如下图所示 , 许多系统的关键任务都被阻塞 , 等待锁的释放 , 这时候如果有 App 发来的 Binder 请求带锁 , 那么也会进入等待状态 , 这时候 App 就会产生性能问题 ; 如果此时做 Window 动画 , 那么 system_server 的这些锁也会导致窗口动画卡顿 GPU：GPU 的影响见渲染流程，但是其实还会间接影响到功耗和发热； 功耗/发热：功耗和发热一般是不分家的，高功耗会引起高发热，进而会引起系统保护，比如降频、热缓解等，间接的导致卡顿。 如何监控卡顿 线下监控： 我们知道卡顿问题的原因错综复杂，但最终都可以反馈到CPU使用率上来 1.使用dumpsys cpuinfo命令 这个命令可以获取当时设备cpu使用情况，我们可以在线下通过重度使用应用来检测可能存在的卡顿点 A8S:/ $ dumpsys cpuinfoLoad: 1.12 / 1.12 / 1.09CPU usage from 484321ms to 184247ms ago (2022-11-02 14:48:30.793 to 2022-11-02 14:53:30.866):2% 1053/scanserver: 0.2% user + 1.7% kernel0.6% 934/system_server: 0.4% user + 0.1% kernel / faults: 563 minor0.4% 564/signserver: 0% user + 0.4% kernel0.2% 256/ueventd: 0.1% user + 0% kernel / faults: 320 minor0.2% 474/surfaceflinger: 0.1% user + 0.1% kernel0.1% 576/vendor.sprd.hardware.gnss@2.0-service: 0.1% user + 0% kernel / faults: 54 minor0.1% 286/logd: 0% user + 0% kernel / faults: 10 minor0.1% 2821/com.allinpay.appstore: 0.1% user + 0% kernel / faults: 1312 minor0.1% 447/android.hardware.health@2.0-service: 0% user + 0% kernel / faults: 1175 minor0% 1855/com.smartpos.dataacqservice: 0% user + 0% kernel / faults: 755 minor0% 2875/com.allinpay.appstore:pushcore: 0% user + 0% kernel / faults: 744 minor0% 1191/com.android.systemui: 0% user + 0% kernel / faults: 70 minor0% 1774/com.android.nfc: 0% user + 0% kernel0% 172/kworker/1:2: 0% user + 0% kernel0% 145/irq/24-70900000: 0% user + 0% kernel0% 575/thermald: 0% user + 0% kernel / faults: 300 minor... 2.CPU Profiler 这个工具是AS自带的CPU性能检测工具，可以在PC上实时查看我们CPU使用情况。 AS提供了四种Profiling Model配置： 1.Sample Java Methods：在应用程序基于Java的代码执行过程中，频繁捕获应用程序的调用堆栈 获取有关应用程序基于Java的代码执行的时间和资源使用情况信息。 2.Trace java methods：在运行时对应用程序进行检测，以在每个方法调用的开始和结束时记录时间戳。收集时间戳并进行比较以生成方法跟踪数据，包括时序信息和CPU使用率。 请注意与检测每种方法相关的开销会影响运行时性能，并可能影响性能分析数据。对于生命周期相对较短的方法，这一点甚至更为明显。此外，如果您的应用在短时间内执行大量方法，则探查器可能会很快超过其文件大小限制，并且可能无法记录任何进一步的跟踪数据。 3.Sample C/C++ Functions:捕获应用程序本机线程的示例跟踪。要使用此配置，您必须将应用程序部署到运行Android 8.0（API级别26）或更高版本的设备。 4.Trace System Calls:捕获细粒度的详细信息，使您可以检查应用程序与系统资源的交互方式 您可以检查线程状态的确切时间和持续时间，可视化CPU瓶颈在所有内核中的位置，并添加自定义跟踪事件进行分析。在对性能问题进行故障排除时，此类信息可能至关重要。要使用此配置，您必须将应用程序部署到运行Android 7.0（API级别24）或更高版本的设备。 使用方式： Debug.startMethodTracing("");// 需要检测的代码片段...Debug.stopMethodTracing(); 优点：有比较全面的调用栈以及图像化方法时间显示，包含所有线程的情况 缺点：本身也会带来一点的性能开销，可能会带偏优化方向 火焰图：可以显示当前应用的方法堆栈： 3.Systrace Systrace在前面一篇分析启动优化的文章讲解过 这里我们简单来复习下： Systrace用来记录当前应用的系统以及应用(使用Trace类打点)的各阶段耗时信息包括绘制信息以及CPU信息等。 使用方式： Trace.beginSection("MyApp.onCreate_1");alt(200);Trace.endSection(); 在命令行中： python systrace.py -t 5 sched gfx view wm am app webview -a "com.chinaebipay.thirdcall" -o D:\trac1.html 记录的方法以及CPU中的耗时情况： 优点： 1.轻量级，开销小，CPU使用率可以直观反映 2.右侧的Alerts能够根据我们应用的问题给出具体的建议，比如说，它会告诉我们App界面的绘制比较慢或者GC比较频繁。 4.StrictModel StrictModel是Android提供的一种运行时检测机制，用来帮助开发者自动检测代码中不规范的地方。 主要和两部分相关： 1.线程相关 2.虚拟机相关 基础代码： private void initStrictMode() {// 1、设置Debug标志位，仅仅在线下环境才使用StrictModeif (DEV_MODE) {// 2、设置线程策略StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder().detectCustomSlowCalls() //API等级11，使用StrictMode.noteSlowCode.detectDiskReads().detectDiskWrites().detectNetwork() // or .detectAll() for all detectable problems.penaltyLog() //在Logcat 中打印违规异常信息// .penaltyDialog() //也可以直接跳出警报dialog// .penaltyDeath() //或者直接崩溃.build());// 3、设置虚拟机策略StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder().detectLeakedSqlLiteObjects()// 给NewsItem对象的实例数量限制为1.setClassInstanceLimit(NewsItem.class, 1).detectLeakedClosableObjects() //API等级11.penaltyLog().build());} } 线上监控： 线上需要自动化的卡顿检测方案来定位卡顿，它能记录卡顿发生时的场景。 自动化监控原理： 采用拦截消息调度流程，在消息执行前埋点计时，当耗时超过阈值时，则认为是一次卡顿，会进行堆栈抓取和上报工作 首先，我们看下Looper用于执行消息循环的loop()方法，关键代码如下所示： / Run the message queue in this thread. Be sure to call {@link quit()} to end the loop./public static void loop() {...for (;;) {Message msg = queue.next(); // might blockif (msg == null) {// No message indicates that the message queue is quitting.return;// This must be in a local variable, in case a UI event sets the loggerfinal Printer logging = me.mLogging;if (logging != null) {// 1logging.println(">>>>> Dispatching to " + msg.target + " " +msg.callback + ": " + msg.what);}...try {// 2 msg.target.dispatchMessage(msg);dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;} finally {if (traceTag != 0) {Trace.traceEnd(traceTag);} }...if (logging != null) {// 3logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);} 在Looper的loop()方法中，在其执行每一个消息（注释2处）的前后都由logging进行了一次打印输出。可以看到，在执行消息前是输出的">>>>> Dispatching to “，在执行消息后是输出的”<<<<< Finished to ",它们打印的日志是不一样的，我们就可以由此来判断消息执行的前后时间点。 具体的实现可以归纳为如下步骤： 1、首先，我们需要使用Looper.getMainLooper().setMessageLogging()去设置我们自己的Printer实现类去打印输出logging。这样，在每个message执行的之前和之后都会调用我们设置的这个Printer实现类。 2、如果我们匹配到">>>>> Dispatching to "之后，我们就可以执行一行代码：也就是在指定的时间阈值之后，我们在子线程去执行一个任务，这个任务就是去获取当前主线程的堆栈信息以及当前的一些场景信息，比如：内存大小、电脑、网络状态等。 3、如果在指定的阈值之内匹配到了"<<<<< Finished to "，那么说明message就被执行完成了，则表明此时没有产生我们认为的卡顿效果，那我们就可以将这个子线程任务取消掉。 这里我们使用blockcanary来做测试: BlockCanary APM是一个非侵入式的性能监控组件，可以通过通知的形式弹出卡顿信息。它的原理就是我们刚刚讲述到的卡顿监控的实现原理。 使用方式： 1.导入依赖 implementation 'com.github.markzhai:blockcanary-android:1.5.0' Application的onCreate方法中开启卡顿监控 // 注意在主进程初始化调用BlockCanary.install(this, new AppBlockCanaryContext()).start(); 3.继承BlockCanaryContext类去实现自己的监控配置上下文类 public class AppBlockCanaryContext extends BlockCanaryContext {....../ 指定判定为卡顿的阈值threshold (in millis), 你可以根据不同设备的性能去指定不同的阈值 @return threshold in mills/public int provideBlockThreshold() {return 1000;}....} 4.在Activity的onCreate方法中执行一个耗时操作 try {Thread.sleep(4000);} catch (InterruptedException e) {e.printStackTrace();} 5.结果： 可以看到一个和LeakCanary一样效果的阻塞可视化堆栈图 那有了BlockCanary的方法耗时监控方式是不是就可以解百愁了呢，呵呵。有那么容易就好了 根据原理：我们拿到的是msg执行前后的时间和堆栈信息，如果msg中有几百上千个方法，就无法确认到底是哪个方法导致的耗时，也有可能是多个方法堆积导致。 这就导致我们无法准确定位哪个方法是最耗时的。如图中：堆栈信息是T2的，而发生耗时的方法可能是T1到T2中任何一个方法甚至是堆积导致。 那如何优化这块？ 这里我们采用字节跳动给我们提供的一个方案：基于 Sliver trace 的卡顿监控体系 Sliver trace 整体流程图： 主要包含两个方面: 检测方案： 在监控卡顿时，首先需要打开 Sliver 的 trace 记录能力，Sliver 采样记录 trace 执行信息，对抓取到的堆栈进行 diff 聚合和缓存。 同时基于我们的需要设置相应的卡顿阈值，以 Message 的执行耗时为衡量。对主线程消息调度流程进行拦截，在消息开始分发执行时埋点，在消息执行结束时计算消息执行耗时，当消息执行耗时超过阈值，则认为产生了一次卡顿。 堆栈聚合策略： 当卡顿发生时，我们需要为此次卡顿准备数据，这部分工作是在端上子线程中完成的，主要是 dump trace 到文件以及过滤聚合要上报的堆栈。分为以下几步： 1.拿到缓存的主线程 trace 信息并 dump 到文件中。 2.然后从文件中读取 trace 信息，按照数据格式，从最近的方法栈向上追溯，找到当前 Message 包含的全部 trace 信息，并将当前 Message 的完整 trace 写入到待上传的 trace 文件中，删除其余 trace 信息。 3.遍历当前 Message trace，按照（Method 执行耗时 > Method 耗时阈值 & Method 耗时为该层堆栈中最耗时）为条件过滤出每一层函数调用堆栈的最长耗时函数，构成最后要上报的堆栈链路，这样特征堆栈中的每一步都是最耗时的，且最底层 Method 为最后的耗时大于阈值的 Method。 之后，将 trace 文件和堆栈一同上报，这样的特征堆栈提取策略保证了堆栈聚合的可靠性和准确性，保证了上报到平台后堆栈的正确合理聚合，同时提供了进一步分析问题的 trace 文件。 可以看到字节给的是一整套监控方案，和前面BlockCanary不同之处就在于，其是定时存储堆栈，缓存，然后使用diff去重的方式，并上传到服务器，可以最大限度的监控到可能发生比较耗时的方法。 开发中哪些习惯会影响卡顿的发生 1.布局太乱，层级太深。 1.1：通过减少冗余或者嵌套布局来降低视图层次结构。比如使用约束布局代替线性布局和相对布局。 1.2：用 ViewStub 替代在启动过程中不需要显示的 UI 控件。 1.3：使用自定义 View 替代复杂的 View 叠加。 2.主线程耗时操作 2.1：主线程中不要直接操作数据库，数据库的操作应该放在数据库线程中完成。 2.2：sharepreference尽量使用apply，少使用commit，可以使用MMKV框架来代替sharepreference。 2.3：网络请求回来的数据解析尽量放在子线程中，不要在主线程中进行复制的数据解析操作。 2.4：不要在activity的onResume和onCreate中进行耗时操作，比如大量的计算等。 2.5：不要在 draw 里面调用耗时函数，不能 new 对象 3.过度绘制 过度绘制是同一个像素点上被多次绘制，减少过度绘制一般减少布局背景叠加等方式，如下图所示右边是过度绘制的图片。 4.列表 RecyclerView使用优化，使用DiffUtil和notifyItemDataSetChanged进行局部更新等。 5.对象分配和回收优化 自从Android引入 ART 并且在Android 5.0上成为默认的运行时之后，对象分配和垃圾回收（GC）造成的卡顿已经显著降低了，但是由于对象分配和GC有额外的开销，它依然又可能使线程负载过重。 在一个调用不频繁的地方（比如按钮点击）分配对象是没有问题的，但如果在在一个被频繁调用的紧密的循环里，就需要避免对象分配来降低GC的压力。 减少小对象的频繁分配和回收操作。 好了，关于卡顿优化的问题就讲到这里，下篇文章会对卡顿中的ANR情况的处理，这里做个铺垫。 如果喜欢我的文章，欢迎关注我的公众号。 点击这看原文链接： 参考 Android卡顿检测及优化 一文读懂直播卡顿优化那些事儿 “终于懂了” 系列：Android屏幕刷新机制—VSync、Choreographer 全面理解！ 深入探索Android卡顿优化（上） 西瓜卡顿 & ANR 优化治理及监控体系建设 5376)] 参考 Android卡顿检测及优化 一文读懂直播卡顿优化那些事儿 “终于懂了” 系列：Android屏幕刷新机制—VSync、Choreographer 全面理解！ 深入探索Android卡顿优化（上） 西瓜卡顿 & ANR 优化治理及监控体系建设 本篇文章为转载内容。原文链接：https://blog.csdn.net/yuhaibing111/article/details/127682399。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...的功能 内建的高可用机制 使用外部机制实现高可能，如：Corosync/Pacemaker 有未来功能提升的空间 增加节点/重新分片数据（re-shard）的简便性 数据重分布（redistribution）期间会锁表 可采用预分片（pre-shard）方式解决，在同台物理服务器上建立多个数据节点，每个节点存储一个数据分片。数据重分布时，将一些数据节点迁出即可 某些外键、唯一性约束功能 Postgres-XL架构 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M9lFuEIP-1640133702200)(./assets/postgre-xl.jpg)] 基于开源项目Postgres-XC XL增加了MPP，允许数据节点间直接通讯，交换复杂跨节点关联查询相关数据信息，减少协调器负载。 多个协调器（Coordinator） 应用程序的数据库连入点 分析查询语句，生成执行计划 多个数据节点（DataNode） 实际的数据存储 数据自动打散分布到集群中各数据节点 本地执行查询 一个查询在所有相关节点上并行查询 全局事务管理器（GTM：Global Transaction Manager） 提供事务间一致性视图 部署GTM Proxy实例，以提高性能 Postgre-XL主要组件 GTM (Global Transaction Manager) - 全局事务管理器 GTM是Postgres-XL的一个关键组件，用于提供一致的事务管理和元组可见性控制。 GTM Standby GTM的备节点，在pgxc,pgxl中，GTM控制所有的全局事务分配，如果出现问题，就会导致整个集群不可用，为了增加可用性，增加该备用节点。当GTM出现问题时，GTM Standby可以升级为GTM，保证集群正常工作。 GTM-Proxy GTM需要与所有的Coordinators通信，为了降低压力，可以在每个Coordinator机器上部署一个GTM-Proxy。 Coordinator --协调器 协调器是应用程序到数据库的接口。它的作用类似于传统的PostgreSQL后台进程，但是协调器不存储任何实际数据。实际数据由数据节点存储。协调器接收SQL语句，根据需要获取全局事务Id和全局快照，确定涉及哪些数据节点，并要求它们执行(部分)语句。当向数据节点发出语句时，它与GXID和全局快照相关联，以便多版本并发控制(MVCC)属性扩展到集群范围。 Datanode --数据节点 用于实际存储数据。表可以分布在各个数据节点之间，也可以复制到所有数据节点。数据节点没有整个数据库的全局视图，它只负责本地存储的数据。接下来，协调器将检查传入语句，并制定子计划。然后，根据需要将这些数据连同GXID和全局快照一起传输到涉及的每个数据节点。数据节点可以在不同的会话中接收来自各个协调器的请求。但是，由于每个事务都是惟一标识的，并且与一致的(全局)快照相关联，所以每个数据节点都可以在其事务和快照上下文中正确执行。 Postgres-XL继承了PostgreSQL Postgres-XL是PostgreSQL的扩展并继承了其很多特性： 复杂查询 外键 触发器 视图 事务 MVCC(多版本控制) 此外，类似于PostgreSQL，用户可以通过多种方式扩展Postgres-XL，例如添加新的 数据类型 函数 操作 聚合函数 索引类型 过程语言 安装 环境说明 由于资源有限，gtm一台、另外两台身兼数职。 主机名 IP 角色 端口 nodename 数据目录 gtm 192.168.20.132 GTM 6666 gtm /nodes/gtm 协调器 5432 coord1 /nodes/coordinator xl1 192.168.20.133 数据节点 5433 node1 /nodes/pgdata gtm代理 6666 gtmpoxy01 /nodes/gtm_pxy1 协调器 5432 coord2 /nodes/coordinator xl2 192.168.20.134 数据节点 5433 node2 /nodes/pgdata gtm代理 6666 gtmpoxy02 /nodes/gtm_pxy2 要求 GNU make版本 3.8及以上版本 [root@pg ~] make --versionGNU Make 3.82Built for x86_64-redhat-linux-gnuCopyright (C) 2010 Free Software Foundation, Inc.License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>This is free software: you are free to change and redistribute it.There is NO WARRANTY, to the extent permitted by law. 需安装GCC包 需安装tar包 用于解压缩文件 默认需要GNU Readline library 其作用是可以让psql命令行记住执行过的命令，并且可以通过键盘上下键切换命令。但是可以通过--without-readline禁用这个特性，或者可以指定--withlibedit-preferred选项来使用libedit 默认使用zlib压缩库 可通过--without-zlib选项来禁用 配置hosts 所有主机上都配置 [root@xl2 11] cat /etc/hosts127.0.0.1 localhost192.168.20.132 gtm192.168.20.133 xl1192.168.20.134 xl2 关闭防火墙、Selinux 所有主机都执行 关闭防火墙： [root@gtm ~] systemctl stop firewalld.service[root@gtm ~] systemctl disable firewalld.service selinux设置: [root@gtm ~]vim /etc/selinux/config 设置SELINUX=disabled，保存退出。 This file controls the state of SELinux on the system. SELINUX= can take one of these three values: enforcing - SELinux security policy is enforced. permissive - SELinux prints warnings instead of enforcing. disabled - No SELinux policy is loaded.SELINUX=disabled SELINUXTYPE= can take one of three two values: targeted - Targeted processes are protected, minimum - Modification of targeted policy. Only selected processes are protected. mls - Multi Level Security protection. 安装依赖包 所有主机上都执行 yum install -y flex bison readline-devel zlib-devel openjade docbook-style-dsssl gcc 创建用户 所有主机上都执行 [root@gtm ~] useradd postgres[root@gtm ~] passwd postgres[root@gtm ~] su - postgres[root@gtm ~] mkdir ~/.ssh[root@gtm ~] chmod 700 ~/.ssh 配置SSH免密登录 仅仅在gtm节点配置如下操作： [root@gtm ~] su - postgres[postgres@gtm ~] ssh-keygen -t rsa[postgres@gtm ~] cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys[postgres@gtm ~] chmod 600 ~/.ssh/authorized_keys 将刚生成的认证文件拷贝到xl1到xl2中，使得gtm节点可以免密码登录xl1~xl2的任意一个节点： [postgres@gtm ~] scp ~/.ssh/authorized_keys postgres@xl1:~/.ssh/[postgres@gtm ~] scp ~/.ssh/authorized_keys postgres@xl2:~/.ssh/ 对所有提示都不要输入，直接enter下一步。直到最后，因为第一次要求输入目标机器的用户密码，输入即可。 下载源码 下载地址：https://www.postgres-xl.org/download/ [root@slave ~] ll postgres-xl-10r1.1.tar.gz-rw-r--r-- 1 root root 28121666 May 30 05:21 postgres-xl-10r1.1.tar.gz 编译、安装Postgres-XL 所有节点都安装，编译需要一点时间，最好同时进行编译。 [root@slave ~] tar xvf postgres-xl-10r1.1.tar.gz[root@slave ~] ./configure --prefix=/home/postgres/pgxl/[root@slave ~] make[root@slave ~] make install[root@slave ~] cd contrib/ --安装必要的工具,在gtm节点上安装即可[root@slave ~] make[root@slave ~] make install 配置环境变量 所有节点都要配置 进入postgres用户，修改其环境变量，开始编辑 [root@gtm ~]su - postgres[postgres@gtm ~]vi .bashrc --不是.bash_profile 在打开的文件末尾，新增如下变量配置： export PGHOME=/home/postgres/pgxlexport LD_LIBRARY_PATH=$PGHOME/lib:$LD_LIBRARY_PATHexport PATH=$PGHOME/bin:$PATH 按住esc，然后输入:wq!保存退出。输入以下命令对更改重启生效。 [postgres@gtm ~] source .bashrc --不是.bash_profile 输入以下语句，如果输出变量结果，代表生效 [postgres@gtm ~] echo $PGHOME 应该输出/home/postgres/pgxl代表生效 配置集群 生成pgxc_ctl.conf配置文件 [postgres@gtm ~] pgxc_ctl prepare/bin/bashInstalling pgxc_ctl_bash script as /home/postgres/pgxl/pgxc_ctl/pgxc_ctl_bash.ERROR: File "/home/postgres/pgxl/pgxc_ctl/pgxc_ctl.conf" not found or not a regular file. No such file or directoryInstalling pgxc_ctl_bash script as /home/postgres/pgxl/pgxc_ctl/pgxc_ctl_bash.Reading configuration using /home/postgres/pgxl/pgxc_ctl/pgxc_ctl_bash --home /home/postgres/pgxl/pgxc_ctl --configuration /home/postgres/pgxl/pgxc_ctl/pgxc_ctl.confFinished reading configuration. PGXC_CTL START Current directory: /home/postgres/pgxl/pgxc_ctl 配置pgxc_ctl.conf 新建/home/postgres/pgxc_ctl/pgxc_ctl.conf文件，编辑如下： 对着模板文件一个一个修改，否则会造成初始化过程出现各种神奇问题。 pgxcInstallDir=$PGHOMEpgxlDATA=$PGHOME/data pgxcOwner=postgres---- GTM Master -----------------------------------------gtmName=gtmgtmMasterServer=gtmgtmMasterPort=6666gtmMasterDir=$pgxlDATA/nodes/gtmgtmSlave=y Specify y if you configure GTM Slave. Otherwise, GTM slave will not be configured and all the following variables will be reset.gtmSlaveName=gtmSlavegtmSlaveServer=gtm value none means GTM slave is not available. Give none if you don't configure GTM Slave.gtmSlavePort=20001 Not used if you don't configure GTM slave.gtmSlaveDir=$pgxlDATA/nodes/gtmSlave Not used if you don't configure GTM slave.---- GTM-Proxy Master -------gtmProxyDir=$pgxlDATA/nodes/gtm_proxygtmProxy=y gtmProxyNames=(gtm_pxy1 gtm_pxy2) gtmProxyServers=(xl1 xl2) gtmProxyPorts=(6666 6666) gtmProxyDirs=($gtmProxyDir $gtmProxyDir) ---- Coordinators ---------coordMasterDir=$pgxlDATA/nodes/coordcoordNames=(coord1 coord2) coordPorts=(5432 5432) poolerPorts=(6667 6667) coordPgHbaEntries=(0.0.0.0/0)coordMasterServers=(xl1 xl2) coordMasterDirs=($coordMasterDir $coordMasterDir)coordMaxWALsernder=0 没设置备份节点，设置为0coordMaxWALSenders=($coordMaxWALsernder $coordMaxWALsernder) 数量保持和coordMasterServers一致coordSlave=n---- Datanodes ----------datanodeMasterDir=$pgxlDATA/nodes/dn_masterprimaryDatanode=xl1 主数据节点datanodeNames=(node1 node2)datanodePorts=(5433 5433) datanodePoolerPorts=(6668 6668) datanodePgHbaEntries=(0.0.0.0/0)datanodeMasterServers=(xl1 xl2)datanodeMasterDirs=($datanodeMasterDir $datanodeMasterDir)datanodeMaxWalSender=4datanodeMaxWALSenders=($datanodeMaxWalSender $datanodeMaxWalSender) 集群初始化，启动，停止 初始化 pgxc_ctl -c /home/postgres/pgxc_ctl/pgxc_ctl.conf init all 输出结果： /bin/bashInstalling pgxc_ctl_bash script as /home/postgres/pgxc_ctl/pgxc_ctl_bash.Installing pgxc_ctl_bash script as /home/postgres/pgxc_ctl/pgxc_ctl_bash.Reading configuration using /home/postgres/pgxc_ctl/pgxc_ctl_bash --home /home/postgres/pgxc_ctl --configuration /home/postgres/pgxc_ctl/pgxc_ctl.conf/home/postgres/pgxc_ctl/pgxc_ctl.conf: line 189: $coordExtraConfig: ambiguous redirectFinished reading configuration. PGXC_CTL START Current directory: /home/postgres/pgxc_ctlStopping all the coordinator masters.Stopping coordinator master coord1.Stopping coordinator master coord2.pg_ctl: directory "/home/postgres/pgxc/nodes/coord/coord1" does not existpg_ctl: directory "/home/postgres/pgxc/nodes/coord/coord2" does not existDone.Stopping all the datanode masters.Stopping datanode master datanode1.Stopping datanode master datanode2.pg_ctl: PID file "/home/postgres/pgxc/nodes/datanode/datanode1/postmaster.pid" does not existIs server running?Done.Stop GTM masterwaiting for server to shut down.... doneserver stopped[postgres@gtm ~]$ echo $PGHOME/home/postgres/pgxl[postgres@gtm ~]$ ll /home/postgres/pgxl/pgxc/nodes/gtm/gtm.^C[postgres@gtm ~]$ pgxc_ctl -c /home/postgres/pgxc_ctl/pgxc_ctl.conf init all/bin/bashInstalling pgxc_ctl_bash script as /home/postgres/pgxc_ctl/pgxc_ctl_bash.Installing pgxc_ctl_bash script as /home/postgres/pgxc_ctl/pgxc_ctl_bash.Reading configuration using /home/postgres/pgxc_ctl/pgxc_ctl_bash --home /home/postgres/pgxc_ctl --configuration /home/postgres/pgxc_ctl/pgxc_ctl.conf/home/postgres/pgxc_ctl/pgxc_ctl.conf: line 189: $coordExtraConfig: ambiguous redirectFinished reading configuration. PGXC_CTL START Current directory: /home/postgres/pgxc_ctlInitialize GTM masterERROR: target directory (/home/postgres/pgxc/nodes/gtm) exists and not empty. Skip GTM initilializationDone.Start GTM masterserver startingInitialize all the coordinator masters.Initialize coordinator master coord1.ERROR: target coordinator master coord1 is running now. Skip initilialization.Initialize coordinator master coord2.The files belonging to this database system will be owned by user "postgres".This user must also own the server process.The database cluster will be initialized with locale "en_US.UTF-8".The default database encoding has accordingly been set to "UTF8".The default text search configuration will be set to "english".Data page checksums are disabled.fixing permissions on existing directory /home/postgres/pgxc/nodes/coord/coord2 ... okcreating subdirectories ... okselecting default max_connections ... 100selecting default shared_buffers ... 128MBselecting dynamic shared memory implementation ... posixcreating configuration files ... okrunning bootstrap script ... okperforming post-bootstrap initialization ... creating cluster information ... oksyncing data to disk ... okfreezing database template0 ... okfreezing database template1 ... okfreezing database postgres ... okWARNING: enabling "trust" authentication for local connectionsYou can change this by editing pg_hba.conf or using the option -A, or--auth-local and --auth-host, the next time you run initdb.Success.Done.Starting coordinator master.Starting coordinator master coord1ERROR: target coordinator master coord1 is already running now. Skip initialization.Starting coordinator master coord22019-05-30 21:09:25.562 EDT [2148] LOG: listening on IPv4 address "0.0.0.0", port 54322019-05-30 21:09:25.562 EDT [2148] LOG: listening on IPv6 address "::", port 54322019-05-30 21:09:25.563 EDT [2148] LOG: listening on Unix socket "/tmp/.s.PGSQL.5432"2019-05-30 21:09:25.601 EDT [2149] LOG: database system was shut down at 2019-05-30 21:09:22 EDT2019-05-30 21:09:25.605 EDT [2148] LOG: database system is ready to accept connections2019-05-30 21:09:25.612 EDT [2156] LOG: cluster monitor startedDone.Initialize all the datanode masters.Initialize the datanode master datanode1.Initialize the datanode master datanode2.The files belonging to this database system will be owned by user "postgres".This user must also own the server process.The database cluster will be initialized with locale "en_US.UTF-8".The default database encoding has accordingly been set to "UTF8".The default text search configuration will be set to "english".Data page checksums are disabled.fixing permissions on existing directory /home/postgres/pgxc/nodes/datanode/datanode1 ... okcreating subdirectories ... okselecting default max_connections ... 100selecting default shared_buffers ... 128MBselecting dynamic shared memory implementation ... posixcreating configuration files ... okrunning bootstrap script ... okperforming post-bootstrap initialization ... creating cluster information ... oksyncing data to disk ... okfreezing database template0 ... okfreezing database template1 ... okfreezing database postgres ... okWARNING: enabling "trust" authentication for local connectionsYou can change this by editing pg_hba.conf or using the option -A, or--auth-local and --auth-host, the next time you run initdb.Success.The files belonging to this database system will be owned by user "postgres".This user must also own the server process.The database cluster will be initialized with locale "en_US.UTF-8".The default database encoding has accordingly been set to "UTF8".The default text search configuration will be set to "english".Data page checksums are disabled.fixing permissions on existing directory /home/postgres/pgxc/nodes/datanode/datanode2 ... okcreating subdirectories ... okselecting default max_connections ... 100selecting default shared_buffers ... 128MBselecting dynamic shared memory implementation ... posixcreating configuration files ... okrunning bootstrap script ... okperforming post-bootstrap initialization ... creating cluster information ... oksyncing data to disk ... okfreezing database template0 ... okfreezing database template1 ... okfreezing database postgres ... okWARNING: enabling "trust" authentication for local connectionsYou can change this by editing pg_hba.conf or using the option -A, or--auth-local and --auth-host, the next time you run initdb.Success.Done.Starting all the datanode masters.Starting datanode master datanode1.WARNING: datanode master datanode1 is running now. Skipping.Starting datanode master datanode2.2019-05-30 21:09:33.352 EDT [2404] LOG: listening on IPv4 address "0.0.0.0", port 154322019-05-30 21:09:33.352 EDT [2404] LOG: listening on IPv6 address "::", port 154322019-05-30 21:09:33.355 EDT [2404] LOG: listening on Unix socket "/tmp/.s.PGSQL.15432"2019-05-30 21:09:33.392 EDT [2404] LOG: redirecting log output to logging collector process2019-05-30 21:09:33.392 EDT [2404] HINT: Future log output will appear in directory "pg_log".Done.psql: FATAL: no pg_hba.conf entry for host "192.168.20.132", user "postgres", database "postgres"psql: FATAL: no pg_hba.conf entry for host "192.168.20.132", user "postgres", database "postgres"Done.psql: FATAL: no pg_hba.conf entry for host "192.168.20.132", user "postgres", database "postgres"psql: FATAL: no pg_hba.conf entry for host "192.168.20.132", user "postgres", database "postgres"Done.[postgres@gtm ~]$ pgxc_ctl -c /home/postgres/pgxc_ctl/pgxc_ctl.conf stop all/bin/bashInstalling pgxc_ctl_bash script as /home/postgres/pgxc_ctl/pgxc_ctl_bash.Installing pgxc_ctl_bash script as /home/postgres/pgxc_ctl/pgxc_ctl_bash.Reading configuration using /home/postgres/pgxc_ctl/pgxc_ctl_bash --home /home/postgres/pgxc_ctl --configuration /home/postgres/pgxc_ctl/pgxc_ctl.conf/home/postgres/pgxc_ctl/pgxc_ctl.conf: line 189: $coordExtraConfig: ambiguous redirectFinished reading configuration. PGXC_CTL START Current directory: /home/postgres/pgxc_ctlStopping all the coordinator masters.Stopping coordinator master coord1.Stopping coordinator master coord2.pg_ctl: directory "/home/postgres/pgxc/nodes/coord/coord1" does not existDone.Stopping all the datanode masters.Stopping datanode master datanode1.Stopping datanode master datanode2.pg_ctl: PID file "/home/postgres/pgxc/nodes/datanode/datanode1/postmaster.pid" does not existIs server running?Done.Stop GTM masterwaiting for server to shut down.... doneserver stopped[postgres@gtm ~]$ pgxc_ctl/bin/bashInstalling pgxc_ctl_bash script as /home/postgres/pgxc_ctl/pgxc_ctl_bash.Installing pgxc_ctl_bash script as /home/postgres/pgxc_ctl/pgxc_ctl_bash.Reading configuration using /home/postgres/pgxc_ctl/pgxc_ctl_bash --home /home/postgres/pgxc_ctl --configuration /home/postgres/pgxc_ctl/pgxc_ctl.conf/home/postgres/pgxc_ctl/pgxc_ctl.conf: line 189: $coordExtraConfig: ambiguous redirectFinished reading configuration. PGXC_CTL START Current directory: /home/postgres/pgxc_ctlPGXC monitor allNot running: gtm masterRunning: coordinator master coord1Not running: coordinator master coord2Running: datanode master datanode1Not running: datanode master datanode2PGXC stop coordinator master coord1Stopping coordinator master coord1.pg_ctl: directory "/home/postgres/pgxc/nodes/coord/coord1" does not existDone.PGXC stop datanode master datanode1Stopping datanode master datanode1.pg_ctl: PID file "/home/postgres/pgxc/nodes/datanode/datanode1/postmaster.pid" does not existIs server running?Done.PGXC monitor allNot running: gtm masterRunning: coordinator master coord1Not running: coordinator master coord2Running: datanode master datanode1Not running: datanode master datanode2PGXC monitor allNot running: gtm masterNot running: coordinator master coord1Not running: coordinator master coord2Not running: datanode master datanode1Not running: datanode master datanode2PGXC exit[postgres@gtm ~]$ pgxc_ctl -c /home/postgres/pgxc_ctl/pgxc_ctl.conf init all/bin/bashInstalling pgxc_ctl_bash script as /home/postgres/pgxc_ctl/pgxc_ctl_bash.Installing pgxc_ctl_bash script as /home/postgres/pgxc_ctl/pgxc_ctl_bash.Reading configuration using /home/postgres/pgxc_ctl/pgxc_ctl_bash --home /home/postgres/pgxc_ctl --configuration /home/postgres/pgxc_ctl/pgxc_ctl.conf/home/postgres/pgxc_ctl/pgxc_ctl.conf: line 189: $coordExtraConfig: ambiguous redirectFinished reading configuration. PGXC_CTL START Current directory: /home/postgres/pgxc_ctlInitialize GTM masterERROR: target directory (/home/postgres/pgxc/nodes/gtm) exists and not empty. Skip GTM initilializationDone.Start GTM masterserver startingInitialize all the coordinator masters.Initialize coordinator master coord1.Initialize coordinator master coord2.The files belonging to this database system will be owned by user "postgres".This user must also own the server process.The database cluster will be initialized with locale "en_US.UTF-8".The default database encoding has accordingly been set to "UTF8".The default text search configuration will be set to "english".Data page checksums are disabled.fixing permissions on existing directory /home/postgres/pgxc/nodes/coord/coord1 ... okcreating subdirectories ... okselecting default max_connections ... 100selecting default shared_buffers ... 128MBselecting dynamic shared memory implementation ... posixcreating configuration files ... okrunning bootstrap script ... okperforming post-bootstrap initialization ... creating cluster information ... oksyncing data to disk ... okfreezing database template0 ... okfreezing database template1 ... okfreezing database postgres ... okWARNING: enabling "trust" authentication for local connectionsYou can change this by editing pg_hba.conf or using the option -A, or--auth-local and --auth-host, the next time you run initdb.Success.The files belonging to this database system will be owned by user "postgres".This user must also own the server process.The database cluster will be initialized with locale "en_US.UTF-8".The default database encoding has accordingly been set to "UTF8".The default text search configuration will be set to "english".Data page checksums are disabled.fixing permissions on existing directory /home/postgres/pgxc/nodes/coord/coord2 ... okcreating subdirectories ... okselecting default max_connections ... 100selecting default shared_buffers ... 128MBselecting dynamic shared memory implementation ... posixcreating configuration files ... okrunning bootstrap script ... okperforming post-bootstrap initialization ... creating cluster information ... oksyncing data to disk ... okfreezing database template0 ... okfreezing database template1 ... okfreezing database postgres ... okWARNING: enabling "trust" authentication for local connectionsYou can change this by editing pg_hba.conf or using the option -A, or--auth-local and --auth-host, the next time you run initdb.Success.Done.Starting coordinator master.Starting coordinator master coord1Starting coordinator master coord22019-05-30 21:13:03.998 EDT [25137] LOG: listening on IPv4 address "0.0.0.0", port 54322019-05-30 21:13:03.998 EDT [25137] LOG: listening on IPv6 address "::", port 54322019-05-30 21:13:04.000 EDT [25137] LOG: listening on Unix socket "/tmp/.s.PGSQL.5432"2019-05-30 21:13:04.038 EDT [25138] LOG: database system was shut down at 2019-05-30 21:13:00 EDT2019-05-30 21:13:04.042 EDT [25137] LOG: database system is ready to accept connections2019-05-30 21:13:04.049 EDT [25145] LOG: cluster monitor started2019-05-30 21:13:04.020 EDT [2730] LOG: listening on IPv4 address "0.0.0.0", port 54322019-05-30 21:13:04.020 EDT [2730] LOG: listening on IPv6 address "::", port 54322019-05-30 21:13:04.021 EDT [2730] LOG: listening on Unix socket "/tmp/.s.PGSQL.5432"2019-05-30 21:13:04.057 EDT [2731] LOG: database system was shut down at 2019-05-30 21:13:00 EDT2019-05-30 21:13:04.061 EDT [2730] LOG: database system is ready to accept connections2019-05-30 21:13:04.062 EDT [2738] LOG: cluster monitor startedDone.Initialize all the datanode masters.Initialize the datanode master datanode1.Initialize the datanode master datanode2.The files belonging to this database system will be owned by user "postgres".This user must also own the server process.The database cluster will be initialized with locale "en_US.UTF-8".The default database encoding has accordingly been set to "UTF8".The default text search configuration will be set to "english".Data page checksums are disabled.fixing permissions on existing directory /home/postgres/pgxc/nodes/datanode/datanode1 ... okcreating subdirectories ... okselecting default max_connections ... 100selecting default shared_buffers ... 128MBselecting dynamic shared memory implementation ... posixcreating configuration files ... okrunning bootstrap script ... okperforming post-bootstrap initialization ... creating cluster information ... oksyncing data to disk ... okfreezing database template0 ... okfreezing database template1 ... okfreezing database postgres ... okWARNING: enabling "trust" authentication for local connectionsYou can change this by editing pg_hba.conf or using the option -A, or--auth-local and --auth-host, the next time you run initdb.Success.The files belonging to this database system will be owned by user "postgres".This user must also own the server process.The database cluster will be initialized with locale "en_US.UTF-8".The default database encoding has accordingly been set to "UTF8".The default text search configuration will be set to "english".Data page checksums are disabled.fixing permissions on existing directory /home/postgres/pgxc/nodes/datanode/datanode2 ... okcreating subdirectories ... okselecting default max_connections ... 100selecting default shared_buffers ... 128MBselecting dynamic shared memory implementation ... posixcreating configuration files ... okrunning bootstrap script ... okperforming post-bootstrap initialization ... creating cluster information ... oksyncing data to disk ... okfreezing database template0 ... okfreezing database template1 ... okfreezing database postgres ... okWARNING: enabling "trust" authentication for local connectionsYou can change this by editing pg_hba.conf or using the option -A, or--auth-local and --auth-host, the next time you run initdb.Success.Done.Starting all the datanode masters.Starting datanode master datanode1.Starting datanode master datanode2.2019-05-30 21:13:12.077 EDT [25392] LOG: listening on IPv4 address "0.0.0.0", port 154322019-05-30 21:13:12.077 EDT [25392] LOG: listening on IPv6 address "::", port 154322019-05-30 21:13:12.079 EDT [25392] LOG: listening on Unix socket "/tmp/.s.PGSQL.15432"2019-05-30 21:13:12.114 EDT [25392] LOG: redirecting log output to logging collector process2019-05-30 21:13:12.114 EDT [25392] HINT: Future log output will appear in directory "pg_log".2019-05-30 21:13:12.079 EDT [2985] LOG: listening on IPv4 address "0.0.0.0", port 154322019-05-30 21:13:12.079 EDT [2985] LOG: listening on IPv6 address "::", port 154322019-05-30 21:13:12.081 EDT [2985] LOG: listening on Unix socket "/tmp/.s.PGSQL.15432"2019-05-30 21:13:12.117 EDT [2985] LOG: redirecting log output to logging collector process2019-05-30 21:13:12.117 EDT [2985] HINT: Future log output will appear in directory "pg_log".Done.psql: FATAL: no pg_hba.conf entry for host "192.168.20.132", user "postgres", database "postgres"psql: FATAL: no pg_hba.conf entry for host "192.168.20.132", user "postgres", database "postgres"Done.psql: FATAL: no pg_hba.conf entry for host "192.168.20.132", user "postgres", database "postgres"psql: FATAL: no pg_hba.conf entry for host "192.168.20.132", user "postgres", database "postgres"Done. 启动 pgxc_ctl -c /home/postgres/pgxc_ctl/pgxc_ctl.conf start all 关闭 pgxc_ctl -c /home/postgres/pgxc_ctl/pgxc_ctl.conf stop all 查看集群状态 [postgres@gtm ~]$ pgxc_ctl monitor all/bin/bashInstalling pgxc_ctl_bash script as /home/postgres/pgxc_ctl/pgxc_ctl_bash.Installing pgxc_ctl_bash script as /home/postgres/pgxc_ctl/pgxc_ctl_bash.Reading configuration using /home/postgres/pgxc_ctl/pgxc_ctl_bash --home /home/postgres/pgxc_ctl --configuration /home/postgres/pgxc_ctl/pgxc_ctl.conf/home/postgres/pgxc_ctl/pgxc_ctl.conf: line 189: $coordExtraConfig: ambiguous redirectFinished reading configuration. PGXC_CTL START Current directory: /home/postgres/pgxc_ctlRunning: gtm masterRunning: coordinator master coord1Running: coordinator master coord2Running: datanode master datanode1Running: datanode master datanode2 配置集群信息 分别在数据节点、协调器节点上分别执行以下命令： 注：本节点只执行修改操作即可(alert node)，其他节点执行创建命令(create node)。因为本节点已经包含本节点的信息。 create node coord1 with (type=coordinator,host=xl1, port=5432);create node coord2 with (type=coordinator,host=xl2, port=5432);alter node coord1 with (type=coordinator,host=xl1, port=5432);alter node coord2 with (type=coordinator,host=xl2, port=5432);create node datanode1 with (type=datanode, host=xl1,port=15432,primary=true,PREFERRED);create node datanode2 with (type=datanode, host=xl2,port=15432);alter node datanode1 with (type=datanode, host=xl1,port=15432,primary=true,PREFERRED);alter node datanode2 with (type=datanode, host=xl2,port=15432);select pgxc_pool_reload(); 分别登陆数据节点、协调器节点验证 postgres= select from pgxc_node;node_name | node_type | node_port | node_host | nodeis_primary | nodeis_preferred | node_id-----------+-----------+-----------+-----------+----------------+------------------+-------------coord1 | C | 5432 | xl1 | f | f | 1885696643coord2 | C | 5432 | xl2 | f | f | -1197102633datanode2 | D | 15432 | xl2 | f | f | -905831925datanode1 | D | 15432 | xl1 | t | f | 888802358(4 rows) 测试 插入数据 在数据节点1，执行相关操作。 通过协调器端口登录PG [postgres@xl1 ~]$ psql -p 5432psql (PGXL 10r1.1, based on PG 10.6 (Postgres-XL 10r1.1))Type "help" for help.postgres= create database lei;CREATE DATABASEpostgres= \c lei;You are now connected to database "lei" as user "postgres".lei= create table test1(id int,name text);CREATE TABLElei= insert into test1(id,name) select generate_series(1,8),'测试';INSERT 0 8lei= select from test1;id | name----+------1 | 测试2 | 测试5 | 测试6 | 测试8 | 测试3 | 测试4 | 测试7 | 测试(8 rows) 注：默认创建的表为分布式表，也就是每个数据节点值存储表的部分数据。关于表类型具体说明，下面有说明。 通过15432端口登录数据节点，查看数据 有5条数据 [postgres@xl1 ~]$ psql -p 15432psql (PGXL 10r1.1, based on PG 10.6 (Postgres-XL 10r1.1))Type "help" for help.postgres= \c lei;You are now connected to database "lei" as user "postgres".lei= select from test1;id | name----+------1 | 测试2 | 测试5 | 测试6 | 测试8 | 测试(5 rows) 登录到节点2，查看数据 有3条数据 [postgres@xl2 ~]$ psql -p15432psql (PGXL 10r1.1, based on PG 10.6 (Postgres-XL 10r1.1))Type "help" for help.postgres= \c lei;You are now connected to database "lei" as user "postgres".lei= select from test1;id | name----+------3 | 测试4 | 测试7 | 测试(3 rows) 两个节点的数据加起来整个8条，没有问题。 至此Postgre-XL集群搭建完成。 创建数据库、表时可能会出现以下错误： ERROR: Failed to get pooled connections 是因为pg_hba.conf配置不对，所有节点加上host all all 192.168.20.0/0 trust并重启集群即可。 ERROR: No Datanode defined in cluster 首先确认是否创建了数据节点，也就是create node相关的命令。如果创建了则执行select pgxc_pool_reload();使其生效即可。 集群管理与应用 表类型说明 REPLICATION表：各个datanode节点中，表的数据完全相同，也就是说，插入数据时，会分别在每个datanode节点插入相同数据。读数据时，只需要读任意一个datanode节点上的数据。 建表语法： CREATE TABLE repltab (col1 int, col2 int) DISTRIBUTE BY REPLICATION; DISTRIBUTE ：会将插入的数据，按照拆分规则，分配到不同的datanode节点中存储，也就是sharding技术。每个datanode节点只保存了部分数据，通过coordinate节点可以查询完整的数据视图。 CREATE TABLE disttab(col1 int, col2 int, col3 text) DISTRIBUTE BY HASH(col1); 模拟数据插入 任意登录一个coordinate节点进行建表操作 [postgres@gtm ~]$ psql -h xl1 -p 5432 -U postgrespostgres= INSERT INTO disttab SELECT generate_series(1,100), generate_series(101, 200), 'foo';INSERT 0 100postgres= INSERT INTO repltab SELECT generate_series(1,100), generate_series(101, 200);INSERT 0 100 查看数据分布结果： DISTRIBUTE表分布结果 postgres= SELECT xc_node_id, count() FROM disttab GROUP BY xc_node_id;xc_node_id | count ------------+-------1148549230 | 42-927910690 | 58(2 rows) REPLICATION表分布结果 postgres= SELECT count() FROM repltab;count -------100(1 row) 查看另一个datanode2中repltab表结果 [postgres@datanode2 pgxl9.5]$ psql -p 15432psql (PGXL 10r1.1, based on PG 10.6 (Postgres-XL 10r1.1))Type "help" for help.postgres= SELECT count() FROM repltab;count -------100(1 row) 结论：REPLICATION表中，datanode1,datanode2中表是全部数据，一模一样。而DISTRIBUTE表，数据散落近乎平均分配到了datanode1,datanode2节点中。 新增数据节点与数据重分布 在线新增节点、并重新分布数据。 新增datanode节点 在gtm集群管理节点上执行pgxc_ctl命令 [postgres@gtm ~]$ pgxc_ctl/bin/bashInstalling pgxc_ctl_bash script as /home/postgres/pgxc_ctl/pgxc_ctl_bash.Installing pgxc_ctl_bash script as /home/postgres/pgxc_ctl/pgxc_ctl_bash.Reading configuration using /home/postgres/pgxc_ctl/pgxc_ctl_bash --home /home/postgres/pgxc_ctl --configuration /home/postgres/pgxc_ctl/pgxc_ctl.confFinished reading configuration. PGXC_CTL START Current directory: /home/postgres/pgxc_ctlPGXC 在服务器xl3上，新增一个master角色的datanode节点，名称是datanode3 端口号暂定5430，pool master暂定6669 ，指定好数据目录位置，从两个节点升级到3个节点，之后要写3个none none应该是datanodeSpecificExtraConfig或者datanodeSpecificExtraPgHba配置PGXC add datanode master datanode3 xl3 15432 6671 /home/postgres/pgxc/nodes/datanode/datanode3 none none none 等待新增完成后，查询集群节点状态： postgres= select from pgxc_node;node_name | node_type | node_port | node_host | nodeis_primary | nodeis_preferred | node_id-----------+-----------+-----------+-----------+----------------+------------------+-------------datanode1 | D | 15432 | xl1 | t | f | 888802358datanode2 | D | 15432 | xl2 | f | f | -905831925datanode3 | D | 15432 | xl3 | f | f | -705831925coord1 | C | 5432 | xl1 | f | f | 1885696643coord2 | C | 5432 | xl2 | f | f | -1197102633(4 rows) 节点新增完毕 数据重新分布 由于新增节点后无法自动完成数据重新分布，需要手动操作。 DISTRIBUTE表分布在了node1,node2节点上，如下： postgres= SELECT xc_node_id, count() FROM disttab GROUP BY xc_node_id;xc_node_id | count ------------+-------1148549230 | 42-927910690 | 58(2 rows) 新增一个节点后，将sharding表数据重新分配到三个节点上，将repl表复制到新节点 重分布sharding表postgres= ALTER TABLE disttab ADD NODE (datanode3);ALTER TABLE 复制数据到新节点postgres= ALTER TABLE repltab ADD NODE (datanode3);ALTER TABLE 查看新的数据分布： postgres= SELECT xc_node_id, count() FROM disttab GROUP BY xc_node_id;xc_node_id | count ------------+--------700122826 | 36-927910690 | 321148549230 | 32(3 rows) 登录datanode3(新增的时候，放在了xl3服务器上，端口15432)节点查看数据： [postgres@gtm ~]$ psql -h xl3 -p 15432 -U postgrespsql (PGXL 10r1.1, based on PG 10.6 (Postgres-XL 10r1.1))Type "help" for help.postgres= select count() from repltab;count -------100(1 row) 很明显,通过 ALTER TABLE tt ADD NODE (dn)命令，可以将DISTRIBUTE表数据重新分布到新节点，重分布过程中会中断所有事务。可以将REPLICATION表数据复制到新节点。 从datanode节点中回收数据 postgres= ALTER TABLE disttab DELETE NODE (datanode3);ALTER TABLEpostgres= ALTER TABLE repltab DELETE NODE (datanode3);ALTER TABLE 删除数据节点 Postgresql-XL并没有检查将被删除的datanode节点是否有replicated/distributed表的数据，为了数据安全，在删除之前需要检查下被删除节点上的数据，有数据的话，要回收掉分配到其他节点，然后才能安全删除。删除数据节点分为四步骤： 1.查询要删除节点dn3的oid postgres= SELECT oid, FROM pgxc_node;oid | node_name | node_type | node_port | node_host | nodeis_primary | nodeis_preferred | node_id -------+-----------+-----------+-----------+-----------+----------------+------------------+-------------11819 | coord1 | C | 5432 | datanode1 | f | f | 188569664316384 | coord2 | C | 5432 | datanode2 | f | f | -119710263316385 | node1 | D | 5433 | datanode1 | f | t | 114854923016386 | node2 | D | 5433 | datanode2 | f | f | -92791069016397 | dn3 | D | 5430 | datanode1 | f | f | -700122826(5 rows) 2.查询dn3对应的oid中是否有数据 testdb= SELECT FROM pgxc_class WHERE nodeoids::integer[] @> ARRAY[16397];pcrelid | pclocatortype | pcattnum | pchashalgorithm | pchashbuckets | nodeoids ---------+---------------+----------+-----------------+---------------+-------------------16388 | H | 1 | 1 | 4096 | 16397 16385 1638616394 | R | 0 | 0 | 0 | 16397 16385 16386(2 rows) 3.有数据的先回收数据 postgres= ALTER TABLE disttab DELETE NODE (dn3);ALTER TABLEpostgres= ALTER TABLE repltab DELETE NODE (dn3);ALTER TABLEpostgres= SELECT FROM pgxc_class WHERE nodeoids::integer[] @> ARRAY[16397];pcrelid | pclocatortype | pcattnum | pchashalgorithm | pchashbuckets | nodeoids ---------+---------------+----------+-----------------+---------------+----------(0 rows) 4.安全删除dn3 PGXC$ remove datanode master dn3 clean 故障节点FAILOVER 1.查看当前集群状态 [postgres@gtm ~]$ psql -h xl1 -p 5432psql (PGXL 10r1.1, based on PG 10.6 (Postgres-XL 10r1.1))Type "help" for help.postgres= SELECT oid, FROM pgxc_node;oid | node_name | node_type | node_port | node_host | nodeis_primary | nodeis_preferred | node_id-------+-----------+-----------+-----------+-----------+----------------+------------------+-------------11739 | coord1 | C | 5432 | xl1 | f | f | 188569664316384 | coord2 | C | 5432 | xl2 | f | f | -119710263316387 | datanode2 | D | 15432 | xl2 | f | f | -90583192516388 | datanode1 | D | 15432 | xl1 | t | t | 888802358(4 rows) 2.模拟datanode1节点故障 直接关闭即可 PGXC stop -m immediate datanode master datanode1Stopping datanode master datanode1.Done. 3.测试查询 只要查询涉及到datanode1上的数据，那么该查询就会报错 postgres= SELECT xc_node_id, count() FROM disttab GROUP BY xc_node_id;WARNING: failed to receive file descriptors for connectionsERROR: Failed to get pooled connectionsHINT: This may happen because one or more nodes are currently unreachable, either because of node or network failure.Its also possible that the target node may have hit the connection limit or the pooler is configured with low connections.Please check if all nodes are running fine and also review max_connections and max_pool_size configuration parameterspostgres= SELECT xc_node_id, FROM disttab WHERE col1 = 3;xc_node_id | col1 | col2 | col3------------+------+------+-------905831925 | 3 | 103 | foo(1 row) 测试发现，查询范围如果涉及到故障的node1节点，会报错，而查询的数据范围不在node1上的话，仍然可以查询。 4.手动切换 要想切换，必须要提前配置slave节点。 PGXC$ failover datanode node1 切换完成后，查询集群 postgres= SELECT oid, FROM pgxc_node;oid | node_name | node_type | node_port | node_host | nodeis_primary | nodeis_preferred | node_id -------+-----------+-----------+-----------+-----------+----------------+------------------+-------------11819 | coord1 | C | 5432 | datanode1 | f | f | 188569664316384 | coord2 | C | 5432 | datanode2 | f | f | -119710263316386 | node2 | D | 15432 | datanode2 | f | f | -92791069016385 | node1 | D | 15433 | datanode2 | f | t | 1148549230(4 rows) 发现datanode1节点的ip和端口都已经替换为配置的slave了。 本篇文章为转载内容。原文链接：https://blog.csdn.net/qianglei6077/article/details/94379331。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...解C中的委托和事件机制后，我们发现它们是.NET框架中实现灵活、解耦编程的核心工具。最近，随着.NET 5的发布以及对异步编程模式的持续优化，委托和事件在现代应用程序开发中的重要性更为凸显。例如，在构建大规模分布式系统或微服务架构时，通过事件驱动的方式进行组件间通信已成为一种最佳实践。 在实际应用中，.NET Core 3.0引入了源生成器(Source Generators)，这一特性使得开发者能够更高效地处理事件和委托，进一步提升代码质量和可维护性。通过自定义源生成器，可以动态创建委托实例并自动绑定相关事件，从而减少手动编写重复代码的工作量。 此外，委托还在并发和多线程编程场景下发挥关键作用，如Task类和async/await关键字背后就依赖于委托来实现异步方法的调用和状态管理。微软在.NET生态系统中提倡采用异步编程模型，利用C的事件和委托机制，能够简化异步操作的处理流程，提高程序性能和响应速度。 对于设计模式层面的理解，委托与观察者模式（Observer Pattern）紧密相连，它允许对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。结合最新的.NET技术趋势，诸如Reactive Extensions (Rx.NET)等库更是将这种模式发扬光大，借助LINQ风格的查询操作符和事件流处理，让委托在实时数据流处理领域展现出了强大的功能。 总之，深入掌握C中的委托和事件不仅有助于日常开发工作的效率提升，更能紧跟现代软件工程的发展潮流，充分利用最新的技术和框架优势，构建出高性能、高可维护性的应用程序。而不断跟进官方文档、社区讨论和技术博客，则是深化此类主题理解和实践运用的有效途径。

...l-selector机制实现的，也就是说，在创建pod之前，会由scheduler用matchNodeSelecto调度策略进行label标签的匹配，找出目标node，然后在将pod调度到目标node； 要实验NodeSelector，首先得给node节点加上label标签 kubectl label nodes node1 nodetag=node1 配置文件内容如下 apiVersion: v1 版本号kind: Pod 资源类型metadata: name: pod-namenamespace: devspec: containers: - image: nginx:1.17.1name: nginx-containernodeSelector: nodetag: node1 调度到具有nodetag=node1标签的节点上 本篇文章为转载内容。原文链接：https://blog.csdn.net/qq_27184497/article/details/121765387。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...achDB等也在索引机制上有所创新，例如支持多级分区索引、位图索引等高级特性，以满足现代企业对海量数据快速检索的需求。 总的来说，在当今数字化转型的大潮下，掌握数据库管理尤其是索引原理，并关注相关领域的前沿技术发展，将有助于企业不断提升MIS系统的效能，实现业务数据的价值最大化。同时，对于数据库管理员而言，持续学习和适应新技术变革，也是保持专业竞争力的关键所在。

...的所有权和有效的管理机制，而导致使用者倾向于过度消费和疏于维护，最终资源耗竭、环境破坏的现象。在开源软件生态系统的背景下，公地悲剧体现在众多组织利用开源项目资源却不进行相应的投入与贡献，导致开源项目依赖少数志愿者维护，长期发展受到威胁。如文中提到，如果所有用户都只索取而不付出，开源项目可能会因为过度使用和投入不足而逐渐崩溃。

...却没有其他方面的奖励机制。 孙勇自认为跳槽太过频繁,这样对自己技术能力的发展会产生较多的负面影响。在他看来,一个人薪资的高低终究取决于自己技术的核心竞争力,变动太大可能会造成技术上的不连续。所以孙勇说,未来五年内自己会沉浸于技术不考虑其它,目的只有一个,就是让自己更专业、更核心! 专家分析:眼光专业与核心竞争力是定位软件人层级的第一法码,其包含着很多的综合因素:专业背景、阅历、经验值、能力高下等等。趋势全球研发及资讯执行副总裁国屏认为,“技术很重要,但更重要的是市场和文化的配合。在个人的发展过程中,学习也会起到重要的作用。此外,还必须认同企业文化,具备技术、对工作、对解决问题的热情”。此外,学习能力和沟通能力也是专家们认为重要度很高的2个要素。当然,这其中,作为前提“最重要的还是兴趣,缘于自身对程序开发的热爱”,8848公司cto张研如是说。 角色大挪移 一级指标:cto、项目承包人 二级指标:架构师、部门主管/项目主管 三级指标:普通开发人员 从个人发展的角度和过程来看,这个指标应该是倒向。但从业界普遍的认识,无论是能力、阅历还是收入待遇,人们普遍对一级指标中的人员更多持赞赏态度。 被采访者:张齐生 个人背景:技术总监 起初,我只是在一家软件公司作java程序员,后来随着项目的进展以及工作时间的推移,自己的技术能力、项目管理能力也逐步加强,从最初的开发人员做到项目主管,2003年底的时候做到技术总监,工资范围也从最初的4000元到8000元,再到技术总监的万元,角色的改变确实带来了很多附加价值,当然,这个职位要求你带来的价值也会更多。 专家分析:出现这种工资结构是正常的。因为架构师、cto一般都是从普通开发人员过来的,具有深厚的业界开发经验和背景。联合信息集团移动应用开发部总经理熊军认为,开发人员必须“对自己能力的认识有一个准确的职业定位。认识自己,才能准确地职业定位,有了准确的职业定位,才能有短期、中期和长期的发展方向和动力。” 8848公司cto张研表示反对“学而优则士”、“不想当将军的士兵就不是好士兵”此类说法。同样,csdn网站、《程序员》杂志社总经理蒋涛也不建议所有程序员都向管理道路发展,因为相比之下,项目经理和cto必定具有一些独特的素质,比如沟通能力、项目管理能力,组织能力、计划能力以及产品和技术的眼光等,这些素质并不是每一个人都具备的。 公司对对碰 一级指标:外资、合资、民营大型it公司 二级指标:合资、中小软件公司 三级指标:国企、事业单位 采访中,有位叫王岩的资深开发人员一再强调,如果可能,一定要进外企。本次调查中,微软亚洲研究院,ibm研究院等外企几乎成了大部分开发人员所向往的圣地。 外企是我第一选择 被采访者:李文山 个人背景:技术支持 上海交大毕业的李文山,在校时就已经参与了很多社团活动,因此也见识了不少各种企业人员的做事风格与思想状态。外企大公司前沿的技术科研、严谨负责的处事态度都给他留下了深刻的印象。当然,丰富的培训、优厚的待遇、放心的福利也是必须考虑的因素。用他的话说,“身边全是一级的牛人,自己的发展自然就有了保障”。 中小软件企业机会多 被采访者:刘洋 个人背景:项目经理+程序员 天天加班加点,见到刘洋时他一脸的菜色,但心情不错。毕业不到一年,他就凭技术能力与管理能力当上了项目经理。虽然下面员工流动率高,但刘洋的薪水却是老板亲自钦点,比起毕业的同班同学绰绰有余。从项目最初的客户谈判、到中间执行,再到最后的交工,刘洋什么都做过,因此也锻炼得几乎成了全能手。对于未来,他希望公司业务做大后,能再规范一些,当然,随着公司的成长,自己上升的空间也很大。 三企走遍 被采访者:阿蒙(vchome.net) 个人背景:6年,通信行业,珠海 我很幸运,毕业时就进了美资软件公司,从事系统软件的开发工作,主要应用c/c++、x86汇编、mips汇编、ddk、sdk等技术,年薪四万多。在这家外企工作两年后,技术与处事能力大有提高,但开始心生厌倦,总觉得外面的世界很精彩。后来有一家从事通信软件产品开发的公司,答应年薪翻倍,一年后可走上管理层,怦然心动后就去新公司报到了。一年后,如愿以偿地走上管理层,两年后,技术管理能力以及行业业务能力有了质的飞跃,也越来越发现这个行业有前途,于是与朋友开始策划开公司,资金融到后就轰轰烈烈地创业了。没日没干了一年,由于资金与市场的原因,公司over,只好灰溜溜地去一家香港合资公司继续打工,仍做管理层。 我的感觉是,外企有一整套规章制度,薪金制度也较为完善,工作考评有客观的数值:月工作计划与总结、季度工作考核、上司的总体评价等,这些考核都很详细,细到完成的代码量、文档数、提过什么建议等等。国内企业也有计划与考核,但更多的是主观态度,而对工作的效果与过程并不具体细化,人际关系、表达能力等往往起着很微妙的关键作用。当然国内企业也有很多优点,比如制度灵活。 专家点评:人才的争夺,一方面是卯足了劲准备抢占有利地势和环境的个人开发者,另一方面,企业间的人才争夺战越演越烈。在此情况下,为了吸引国内的高素质人才,不少外企纷纷在中国开设研究院,走“曲线救国”道路。根据一份猎头资料,摩托罗拉研发中心、松下电器中国研究开发公司、ibm中国研究中心、朗讯公司贝尔实验室、微软中国研究院都是猎取高级科研、管理人才的大头。外企与外企、外企与国企、国企与民企,这个三角关系,虽然在早几年优劣非常明显,但现在,这种差距正在明显缩小。具体适合哪个企业,围城内外其实也并不是三重天(见下页表23)。 热点行业易淘金 一级推荐:移动开发、游戏开发 二级推荐:安全领域、企业信息化 三级推荐:通用软件、系统平台、项目开发等 专家点评:出现这种趋势主要是由市场对软件人才的供求决定的,因为目前在移动和游戏领域开发人员确实比较少,所以相对而言,他们的薪资较高,这就是所谓的“奇货可居”。但是,目前市场在成长,这些新兴或热点领域的开发人员数量也在逐渐增加,当达到一个平衡点时,他们的工资也会随之下降,这主要由市场对人才的供求关系决定。不建议开发人员轻易放弃自己原有的开发领域花大量时间和精力投向自己不熟悉的领域。 所以,熊军认为:这两个行业方向的长线发展看好,也需要更多的开发人员,但是年轻人都要根据自己的兴趣爱好、思维模式、技术能力选择更适合自己的行业方向,而且也有很多更有潜力的方向,建议年轻人从长远考虑。 地域火拼 一级指标:北京、上海 二级指标:深圳、杭州、广州 三级指标:成都、武汉、大连等 绝大多数的软件从业人员集中在北京、上海、广州和深圳四大城市,其中尤以北京的人数最为集中,但在另一项相关的调查中,上海却是程序员最向往的城市。在本次收入调查中,北京、上海的工资较高。武汉稍低于成都。 地域不同,薪资有别 被采访者:青润 个人背景:5年,电信行业、软件企业服务 我本人在北京、上海、深圳、成都四地都曾工作过。我基本上这样认为,对于刚刚大学毕业的软件人员,工资情况是这样:成都1500-2000元/月,上海2000元/月,深圳2000-2500元/月,北京2000-2500元/月。工作几年后,以成都系数为1来计,上海和其他地方为1.3-1.5倍于成都的收入。差异主要也是因为生活成本造成的。 相比而言,北京具有王者气氛,有着俯瞰全国的实力和影响力。上海是经济驱动的城市。深圳对人的友好度最好,它的优点是有各种各样的新技术公司,缺点是缺乏大公司的支撑。好山好水的成都,虽起步了很多软件公司,但大都在出川后倒下了,或者只是长居四川,足少出户,感觉比较舒适和懒散。 安逸的成都竞争的北京 被采访者:夏桅 个人背景:。net开发人员 夏桅毕业之后就来到北京从事软件开发工作。但他时常怀念起成都的生活,那里的山,那里的水,还有怡然自得的成都人都给他留下了深刻的印象。 但夏桅还是不后悔。一方面,安逸的环境对自己发展不利,适度的竞争可以发掘自身的潜力。而且,眼界开阔了,薪水也高不少。当然,在北京的生活绝对说不上舒服,但机会多,可有多种选择,极大地改观了自己的现状。 一眼可以看到头的武汉,但我喜欢 被采访者:刘如宁 个人背景:大学教师、项目主管 在武汉工作了10多年,刘如宁感觉还是比较惬意。比收入,武汉可能还不如成都,更别提北京和上海,但武汉的生活成本比较低,几块钱就够一天的伙食了。在高校担当大学教师的刘如宁,科研任务不重,而且还有足够的时间去外面承接项目,用自己喜欢的软件开发技术赚取外快。“我不是一个特别喜欢接受挑战的人,这种做自己喜欢的事情、宁静而富裕的生活,我还是比较满足”,有房、有车,生活安定富足的刘如宁如是说。 专家点评:比“营利”,必须是一个闭环。有收入比较,还得有支出比较,两者对比后才是最终收获。在地域这个问题上,大城市,确实收入比较高,但相对的,生活成本也较高。 趋势全球研发及资讯执行副总裁梁国屏表示,趋势的薪资结构体系在全世界都是一样的,具体数值要根据各地的市场来调整。比如一个经理,他的等级可能是10,那么不论在中国、日本还是美国,他的等级都是10.但这个等级的薪水具体是多少,就要看当地的市场了,趋势会和当地的薪资调查单位合作,来确定系数,然后计算出具体的薪水。 除薪水外,地域的附加价值会更重要一些。第一,对于技术发展比较迅速的it业,在大城市,整体的环境和氛围相对会好一些,例如在北京和上海等地,几乎每天都会有技术论坛、开发者大会、大厂商的开发日、各领域大师的巡回讲座等。其次,作的机会也会比较多,因为集中了各种类型的公司和企业,总会找到适合你条件的合适职位和选择。第三,可以参与比较大的技术团体,形成独特的生活与社交圈。用8848公司cto张研的话来说,“如果周围都是高手,你不是高手也难”,所以地域对人影响最大的是提供了一个环境,其次才是机会和薪水。 对此,telelogic公司北方区总经理任群力建议说,“如果开发人员能够善于利用互联网,并有决心多学习,这种地域差异会得到弱化。” 我拿青春赌明天 在本次专题组织中,大部分被采访人都明确表示,自己会在软件业领域一直奋斗下去,因为从中得到了很多的快乐与激情。但明天是否一定会更好,这需要从两个角度去考虑:一是从个人角度讲,年轻的软件人一定要有个人职业的规划,而且这种规划要从自己特点或专长出发,与当前业界相适应。另外,更重要的是,个人发展到什么程度,还需要同整个软件大环境和社会环境挂钩。 个人职业要规划 现在广州做了4年delphi/c行业开发、年薪10万的王旋说,“工作后所得到的收获就是,学习和工作要有相对明确的目标,不能因为一时心动而去学习某一技术。在真正下决定之前,我通常会考虑更多因素,包括长期的发展、个人路线的规划、需要付出的代价、可能遇到的困难以及解决的办法等等,在决定后还会制定更加明确的计划,包括短期、中期和长期的,身边可以利用到的资源,以及每一个阶段是怎么过渡到更高阶段的计划。” 现在,越来越多的在职人员意识到,未来的职业细分市场中,只有在某一领域确实比较深入、具有专长和资源的人会得到企业的重视,浪里淘沙勇者胜。 中国软件业面临困境 中国的软件业发展目前面临两难境地。上至国家,下至各城市都给予了相当的政策优惠,但整体软件业的发展却一直雷声大,雨点小。对此,北航软件学院院长孙伟忧心忡忡,“很多人从心里看不起印度,但印度的软件业却有数家2万、3万员工规模的大企业,放眼中国,规模最大的东软集团、用友公司,真正的软件开发者也不过两、三千人,这种差别太巨大了,我们一定要好好思考,中国的软件业究竟出了什么问题?” 对此,很多专家认为,中国软件业已经面临一个新的转折点,随着信息化在各行各业的深入运用,软件业有机会深度专业化,由边缘而进入核心,从而形成以深度专业化为特征的核心竞争力。无论个人还是公司,我们都有幸在第一时间站在了软件业这块前沿阵地,但明天是否会更好,还有待于中国软件业的整体发展,在这颇为沉闷的时刻,我们期望“让暴风雨来得更猛烈些吧”! 参考资料:http://www.w-training.com/viewc.asp?id=23922 ====================================================== 在最后，我邀请大家参加新浪APP，就是新浪免费送大家的一个空间，支持PHP+MySql，免费二级域名，免费域名绑定 这个是我邀请的地址，您通过这个链接注册即为我的好友，并获赠云豆500个，价值5元哦！短网址是http://t.cn/SXOiLh我创建的小站每天访客已经达到2000+了，每天挂广告赚50+元哦，呵呵，饭钱不愁了，\(^o^)/ 本篇文章为转载内容。原文链接：https://blog.csdn.net/javazhuanzai/article/details/7189396。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。