[大数据任务内存溢出解决方案 ]的搜索结果

...eaming：实时流数据分析 1. 引言 在数据爆炸的时代，实时流数据分析成为了解决海量数据处理的关键技术之一。哎呀，你听说过Mahout这个玩意儿没？这家伙可是个开源的机器学习宝库，专治大数据这事儿。它那分发式计算的能力啊，就像魔法一样，能让你的数据处理起来轻松又高效。用Mahout做分析，就像是给一堆乱糟糟的数据整了套华丽丽的整理术，让它们变得井井有条，还能从中找出各种有价值的信息和模式。这玩意儿一出手，数据处理界的难题就被它玩转得飞起，简直是个大数据时代的超级英雄呢！而Apache Spark Streaming，则是为实时数据流提供高性能处理的框架。哎呀，兄弟！把这两样技术给整到一块儿用，那效果简直不要太棒！不仅能快速消化那些源源不断的数据洪流，还能帮咱们做出超明智的决定，简直就是开挂的存在嘛！本文旨在探索Mahout与Spark Streaming如何协同工作，为实时流数据分析提供强大的解决方案。 2. Mahout概述 Mahout是一个基于Hadoop的机器学习库，旨在利用分布式计算资源来加速大规模数据集上的算法执行。哎呀，这个家伙可真厉害！它能用上各种各样的机器学习魔法，比如说分门别类的技巧（就是咱们说的分类）、把相似的东西归到一块儿的本事（聚类）还有能给咱们推荐超棒东西的神奇技能（推荐系统）。而且，它最擅长的就是对付那些海量的数据，就像大鱼吃小鱼一样，毫不费力就能搞定！通过Mahout，我们可以构建复杂的模型来挖掘数据中的模式和关系，从而驱动业务决策。 3. Spark Streaming简介 Apache Spark Streaming是Spark生态系统的一部分，专为实时数据流处理设计。哎呀，这个玩意儿简直就是程序员们的超级神器！它能让咱这些码农兄弟们轻松搞定那些超快速、高效率的实时应用，你懂的，就是那种分秒必争、数据飞速流转的那种。想象一下，一秒钟能处理几千条数据，那感觉简直不要太爽啊！就像是在玩转数据的魔法世界，每一次点击都是对速度与精准的极致追求。这不就是我们程序员的梦想吗？在数据的海洋里自由翱翔，每一刻都在创造奇迹！Spark Streaming的精髓就像个魔术师，能把连续不断的水流（数据流）变换成小段的小溪（微批次）。这小溪再通过Spark这个强大的分布式计算平台，就像是在魔法森林里跑的水车，一边转一边把水（数据）处理得干干净净。这样一来，咱们就能在实时中捕捉到信息的脉动，做出快速反应，既高效又灵活！ 4. Mahout与Spark Streaming的集成 为了将Mahout的机器学习能力与Spark Streaming的实时处理能力结合起来，我们需要创建一个流水线，使得Mahout可以在实时数据流上执行分析任务。这可以通过以下步骤实现： - 数据接入：首先，我们需要将实时数据流接入Spark Streaming。这可以通过定义一个DStream（Data Stream）对象来完成，该对象代表了数据流的抽象表示。 scala import org.apache.spark.streaming._ import org.apache.spark.streaming.dstream._ val sparkConf = new SparkConf().setAppName("RealtimeMahoutAnalysis").setMaster("local[2]") val sc = new SparkContext(sparkConf) valssc = new StreamingContext(sc, Seconds(1)) // 创建StreamingContext，时间间隔为1秒 val inputStream = TextFileStream("/path/to/your/data") // 假设数据来自文件系统 val dstream = inputStream foreachRDD { rdd => rdd.map { line => val fields = line.split(",") (fields(0), fields.slice(1, fields.length)) } } - Mahout模型训练：然后，我们可以使用Mahout中的算法对数据进行预处理和建模。例如，假设我们想要进行用户行为的聚类分析，可以使用Mahout的KMeans算法。 scala import org.apache.mahout.cf.taste.hadoop.recommender.KNNRecommender import org.apache.mahout.cf.taste.impl.model.file.FileDataModel import org.apache.mahout.cf.taste.impl.neighborhood.ThresholdUserNeighborhood import org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedRecommender import org.apache.mahout.cf.taste.impl.similarity.PearsonCorrelationSimilarity import org.apache.mahout.math.RandomAccessSparseVector import org.apache.hadoop.conf.Configuration val dataModel = new FileDataModel(new File("/path/to/your/data.csv")) val neighborhood = new ThresholdUserNeighborhood(0.5, dataModel, new Configuration()) val similarity = new PearsonCorrelationSimilarity(dataModel) val recommender = new GenericUserBasedRecommender(dataModel, neighborhood, similarity) val recommendations = dstream.map { (user, ratings) => val userVector = new RandomAccessSparseVector(ratings.size()) for ((itemId, rating) <- ratings) { userVector.setField(itemId.toInt, rating.toDouble) } val recommendation = recommender.recommend(user, userVector) (user, recommendation.map { (itemId, score) => (itemId, score) }) } - 结果输出：最后，我们可以将生成的推荐结果输出到合适的目标位置，如日志文件或数据库，以便后续分析和应用。 scala recommendations.foreachRDD { rdd => rdd.saveAsTextFile("/path/to/output") } 5. 总结与展望 通过将Mahout与Spark Streaming集成，我们能够构建一个强大的实时流数据分析平台，不仅能够实时处理大量数据，还能利用Mahout的高级机器学习功能进行深入分析。哎呀，这个融合啊，就像是给数据分析插上了翅膀，能即刻飞到你眼前，又准确得不得了！这样一来，咱们做决定的时候，心里那根弦就更紧了，因为有它在身后撑腰，决策那可是又稳又准，妥妥的！哎呀，随着科技车轮滚滚向前，咱们的Mahout和Spark Streaming这对好搭档，未来肯定会越来越默契，联手为我们做决策时，用上实时数据这个大宝贝，提供更牛逼哄哄的武器和方法！想象一下，就像你用一把锋利的剑，能更快更准地砍下胜利的果实，这俩家伙在数据战场上，就是那把超级厉害的宝剑，让你的决策快人一步，精准无比！ --- 以上内容是基于实际的编程实践和理论知识的融合，旨在提供一个从概念到实现的全面指南。哎呀，当真要将这个系统或者项目实际铺展开来的时候，咱们得根据手头的实际情况，比如数据的个性、业务的流程和咱们的技术底子，来灵活地调整策略，让一切都能无缝对接，发挥出最大的效用。就像是做菜，得看食材的新鲜度，再搭配合适的调料，才能做出让人满意的美味佳肴一样。所以，别死板地照搬方案，得因地制宜，因材施教，这样才能确保我们的工作既高效又有效。

...Sqoop作业在特定数据处理透明性下失败 一、Sqoop初体验 为什么我选择了它？ 嗨，朋友们！作为一个热爱折腾数据的技术爱好者，最近我在尝试用Sqoop来完成一些数据迁移任务。哈哈，Sqoop这个名字一听就觉得挺酷的，对不？它就像个超级厉害的“中间人”，一边连着Hadoop那个大数据的世界，另一边又搭在传统的数据库上，两边都能玩得转！ 说到Sqoop，它的主要功能就是从关系型数据库中抽取数据并导入到Hadoop生态系统中，或者反过来把Hadoop中的数据导出到关系型数据库里。对我来说，这简直就是个救星啊！毕竟我天天都要跟一堆 structured data（结构化数据）打交道，没有它，我的日子能过得下去才怪呢！ 不过呢，事情并没有想象中那么顺利。话说有一次我用 Sqoop 做数据迁移的时候，发现了个让人挠头的问题——只要碰到某些特别的数据处理任务，作业就突然“罢工”了，也不知道是啥原因。这事儿可把我给整郁闷了，我都觉得自己的水平挺过关的了，没想到被一个看起来超简单的题目给绊住了，真是有点糗啊！ 示例代码： bash sqoop import \ --connect jdbc:mysql://localhost:3306/mydatabase \ --username root \ --password mypassword \ --table employees \ --target-dir /user/hadoop/employees 这段代码看起来挺正常的，但我后来发现，当表中的数据量过大或者存在一些复杂的约束条件时，Sqoop就表现得不太友好。 --- 二、Sqoop作业失败的背后 接下来，让我们一起深入探讨一下这个问题。说实话，刚开始接触Sqoop那会儿，我对它是怎么工作的压根儿没弄明白，稀里糊涂的。我以为只要配置好连接信息，然后指定源表和目标路径就行了。但实际上，Sqoop并不是这么简单的工具。 当我第一次遇到作业失败的情况时，内心是崩溃的。屏幕上显示的错误信息密密麻麻，但仔细一看，其实都是些常见的问题。打个比方啊，Sqoop这家伙一碰到一些特别的符号，比如空格或者换行符，就容易“翻车”，直接给你整出点问题来。还有呢，有时候因为网络卡了一下，延迟太高，Sqoop就跟服务器说拜拜了，连接就这么断了，挺烦人的。 有一次，我在尝试将一张包含大量JSON字段的表导出到HDFS时，Sqoop直接报错了。我当时就在心里嘀咕：“为啥别的工具处理起来轻轻松松的事儿，到Sqoop这儿就变得这么棘手呢？”后来，我一咬牙，开始翻遍各种资料，想着一定要找出个解决办法来。 思考与尝试： 经过一番研究，我发现Sqoop默认情况下并不会对数据进行深度解析，这意味着如果数据本身存在问题，Sqoop可能无法正确处理。所以，为了验证这个假设，我又做了一次测试。 bash sqoop import \ --connect jdbc:mysql://localhost:3306/mydatabase \ --username root \ --password mypassword \ --table problematic_table \ --fields-terminated-by '\t' \ --lines-terminated-by '\n' 这次我特意指定了分隔符和换行符，希望能避免之前遇到的那些麻烦。嘿，没想到这次作业居然被我搞定了！中间经历了不少波折，不过好在最后算是弄懂了个中奥秘，也算没白费功夫。 --- 三、透明性的重要性 Sqoop到底懂不懂我的需求？ 说到Sqoop的透明性，我觉得这是一个非常重要的概念。所谓的透明性嘛，简单来说，就是Sqoop能不能明白咱们的心思，然后老老实实地按咱们想的去干活儿，不添乱、不出错！显然，在我遇到的这些问题中，Sqoop的表现并不能让人满意。 举个例子来说，假设你有一个包含多列的大表，其中某些列的数据类型比较复杂（例如数组、嵌套对象等）。在这种情况下，Sqoop可能会因为无法正确识别这些数据类型而失败。更糟糕的是，它并不会给出明确的提示，而是默默地报错，让你一头雾水。 为了更好地应对这种情况，我在后续的工作中加入了更多的调试步骤。比如说啊，你可以先用describe这个命令去看看表的结构，确保所有的字段都乖乖地被正确识别了；接着呢，再用--check-column这个选项去瞅一眼，看看有没有重复的记录藏在里面。这样一来，虽然增加了工作量，但至少能减少不必要的麻烦。 示例代码： bash sqoop job --create my_job \ -- import \ --connect jdbc:mysql://localhost:3306/mydatabase \ --username root \ --password mypassword \ --table employees \ --check-column id \ --incremental append \ --last-value 0 这段代码展示了如何创建一个增量作业，用于定期更新目标目录中的数据。通过这种方式，可以有效避免一次性加载过多数据带来的性能瓶颈。 --- 四、总结与展望 与Sqoop共舞 总的来说，尽管Sqoop在某些场景下表现得不尽人意，但它依然是一个强大的工具。通过不断学习和实践，我相信自己能够更加熟练地驾驭它。未来的计划里，我特别想试试一些更酷的功能，比如说用Sqoop直接搞出Avro文件，或者把Spark整进来做分布式计算，感觉会超级带劲！ 最后，我想说的是，技术这条路从来都不是一帆风顺的。遇到困难并不可怕，可怕的是我们因此放弃努力。正如那句话所说：“失败乃成功之母。”只要保持好奇心和求知欲，总有一天我们会找到属于自己的答案。 如果你也有类似的经历，欢迎随时交流！我们一起进步，一起成长！ --- 希望这篇文章对你有所帮助，如果有任何疑问或者想要了解更多细节，请随时告诉我哦！

...链路压测技术和分布式数据库解决方案，确保了包括腕表在内的各类商品交易系统的稳定运行。同时，针对用户个性化需求日益增强的趋势，大数据分析与AI推荐算法也被广泛应用在电商平台中，精准推送用户可能感兴趣的商品，优化购物体验。 另外，在法律层面，《个人信息保护法》等相关法律法规的出台，对电商交易系统收集、存储和使用用户信息提出了更严格的要求。开发者在设计腕表交易系统时，不仅要注重功能完备和技术先进，更要充分考虑数据安全与隐私保护，合规地处理用户数据，以满足法规要求并赢得用户的信任。 此外，对于交易系统的安全性问题，区块链技术也逐渐成为解决支付环节信任难题的新方案。一些创新型企业正尝试将区块链技术融入到腕表等奢侈品交易中，实现从源头到终端的全程追溯，确保商品的真实性，并为消费者提供更加透明、安全的交易环境。 综上所述，随着现代信息技术的快速发展，腕表交易系统的设计与实现需要紧跟时代步伐，不断吸收新技术、新理念，以适应市场变化及满足用户需求，同时也需时刻关注相关法律法规的更新，确保系统的合法性与合规性。

...供安全、可靠的计算和数据处理能力，让计算和人工智能成为普惠科技。阿里云服务着制造、金融、政务、交通、医疗、电信、能源等众多领域的领军企业，包括中国联通、12306、中石化、中石油、飞利浦、华大基因等大型企业客户，以及微博、知乎、锤子科技等明星互联网公司。在天猫双11全球狂欢节、12306春运购票等极富挑战的应用场景中，阿里云保持着良好的运行纪录 阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本 猿辅导、中泰证券、小米、媛福达、Soul和当贝，这些我们耳熟能详的APP或企业中，阿里云给他们提供了性能强大、安全、稳定的云产品与服务。 计算，容器，存储，网络与CDN，安全、中间件、数据库、大数据计算、人工智能与机器学习、媒体服务、企业服务与云通信、物联网、开发工具、迁移与运维管理和专有云等方面，阿里云都做的很不错。 2.2 证件照生成背景 传统做法：通常是人工进行P图，不仅费时费力，而且效果也很难保障，容易有瑕疵。 机器学习做法：通常利用边缘检测算法进行人物轮廓提取。 深度学习做法：通常使用分割算法进行人物分割。例如U-Net网络。 2.3 图像分割算法 《BiHand: Recovering Hand Mesh with Multi-stage Bisected Hourglass Networks》里的SeedNet网络是很经典的网络，它把分割任务转变成多个任务。作者的思想是：尽可能的通过多任务学习收拢语义，这样或许会分割的更好或姿态估计的更好。其实这个模型就是多阶段学习网络的一部分，作者想通过中间监督来提高网络的性能。 我提取bihand网络中的SeedNet与训练权重，进行分割结果展示如下 我是用的模型不是全程的，是第一阶段的。为了可视化出最好的效果，我把第一阶段也就是SeedNet网络的输出分别采用不同的方式可视化。 从左边数第一张图为原图，第二张图为sigmoid后利用plt.imshow(colored_mask, cmap=‘jet’)进行彩色映射。第三张图为网络输出的张量经过sigmoid后，二色分割图，阀闸值0.5。第四张为网络的直接输出，利用直接产生的张量图进行颜色映射。第五张为使用sigmoid处理张量后进行的颜色映射。第六张为使用sigmoid处理张量后进行0,1分割掩码映射。使用原模型和网络需要添加很多代码。下面为修改后的的代码： 下面为修改后的net_seedd代码： Copyright (c) Lixin YANG. All Rights Reserved.r"""Networks for heatmap estimation from RGB images using Hourglass Network"Stacked Hourglass Networks for Human Pose Estimation", Alejandro Newell, Kaiyu Yang, Jia Deng, ECCV 2016"""import numpy as npimport torchimport torch.nn as nnimport torch.nn.functional as Ffrom skimage import io,transform,utilfrom termcolor import colored, cprintfrom bihand.models.bases.bottleneck import BottleneckBlockfrom bihand.models.bases.hourglass import HourglassBisectedimport bihand.utils.func as funcimport matplotlib.pyplot as pltfrom bihand.utils import miscimport matplotlib.cm as cmdef color_mask(output_ok): 颜色映射cmap = plt.cm.get_cmap('jet') 将张量转换为numpy数组mask_array = output_ok.detach().numpy() 创建彩色图像cmap = cm.get_cmap('jet')colored_mask = cmap(mask_array)return colored_mask 可视化 plt.imshow(colored_mask, cmap='jet') plt.axis('off') plt.show()def two_color(mask_tensor): 将张量转换为numpy数组mask_array = mask_tensor.detach().numpy() 将0到1之间的值转换为二值化掩码threshold = 0.5 阈值，大于阈值的为白色，小于等于阈值的为黑色binary_mask = np.where(mask_array > threshold, 1, 0)return binary_mask 可视化 plt.imshow(binary_mask, cmap='gray') plt.axis('off') plt.show()class SeedNet(nn.Module):def __init__(self,nstacks=2,nblocks=1,njoints=21,block=BottleneckBlock,):super(SeedNet, self).__init__()self.njoints = njointsself.nstacks = nstacksself.in_planes = 64self.conv1 = nn.Conv2d(3, self.in_planes, kernel_size=7, stride=2, padding=3, bias=True)self.bn1 = nn.BatchNorm2d(self.in_planes)self.relu = nn.ReLU(inplace=True)self.maxpool = nn.MaxPool2d(2, stride=2)self.layer1 = self._make_residual(block, nblocks, self.in_planes, 2self.in_planes) current self.in_planes is 64 2 = 128self.layer2 = self._make_residual(block, nblocks, self.in_planes, 2self.in_planes) current self.in_planes is 128 2 = 256self.layer3 = self._make_residual(block, nblocks, self.in_planes, self.in_planes)ch = self.in_planes 256hg2b, res1, res2, fc1, _fc1, fc2, _fc2= [],[],[],[],[],[],[]hm, _hm, mask, _mask = [], [], [], []for i in range(nstacks): 2hg2b.append(HourglassBisected(block, nblocks, ch, depth=4))res1.append(self._make_residual(block, nblocks, ch, ch))res2.append(self._make_residual(block, nblocks, ch, ch))fc1.append(self._make_fc(ch, ch))fc2.append(self._make_fc(ch, ch))hm.append(nn.Conv2d(ch, njoints, kernel_size=1, bias=True))mask.append(nn.Conv2d(ch, 1, kernel_size=1, bias=True))if i < nstacks-1:_fc1.append(nn.Conv2d(ch, ch, kernel_size=1, bias=False))_fc2.append(nn.Conv2d(ch, ch, kernel_size=1, bias=False))_hm.append(nn.Conv2d(njoints, ch, kernel_size=1, bias=False))_mask.append(nn.Conv2d(1, ch, kernel_size=1, bias=False))self.hg2b = nn.ModuleList(hg2b) hgs: hourglass stackself.res1 = nn.ModuleList(res1)self.fc1 = nn.ModuleList(fc1)self._fc1 = nn.ModuleList(_fc1)self.res2 = nn.ModuleList(res2)self.fc2 = nn.ModuleList(fc2)self._fc2 = nn.ModuleList(_fc2)self.hm = nn.ModuleList(hm)self._hm = nn.ModuleList(_hm)self.mask = nn.ModuleList(mask)self._mask = nn.ModuleList(_mask)def _make_fc(self, in_planes, out_planes):bn = nn.BatchNorm2d(in_planes)conv = nn.Conv2d(in_planes, out_planes, kernel_size=1, bias=False)return nn.Sequential(conv, bn, self.relu)def _make_residual(self, block, nblocks, in_planes, out_planes):layers = []layers.append( block( in_planes, out_planes) )self.in_planes = out_planesfor i in range(1, nblocks):layers.append(block( self.in_planes, out_planes))return nn.Sequential(layers)def forward(self, x):l_hm, l_mask, l_enc = [], [], []x = self.conv1(x) x: (N,64,128,128)x = self.bn1(x)x = self.relu(x)x = self.layer1(x)x = self.maxpool(x) x: (N,128,64,64)x = self.layer2(x)x = self.layer3(x)for i in range(self.nstacks): 2y_1, y_2, _ = self.hg2b[i](x)y_1 = self.res1[i](y_1)y_1 = self.fc1[i](y_1)est_hm = self.hm[i](y_1)l_hm.append(est_hm)y_2 = self.res2[i](y_2)y_2 = self.fc2[i](y_2)est_mask = self.mask[i](y_2)l_mask.append(est_mask)if i < self.nstacks-1:_fc1 = self._fc1[i](y_1)_hm = self._hm[i](est_hm)_fc2 = self._fc2[i](y_2)_mask = self._mask[i](est_mask)x = x + _fc1 + _fc2 + _hm + _maskl_enc.append(x)else:l_enc.append(x + y_1 + y_2)assert len(l_hm) == self.nstacksreturn l_hm, l_mask, l_encif __name__ == '__main__':a = torch.randn(10, 3, 256, 256) SeedNetmodel = SeedNet() output1,output2,output3 = SeedNetmodel(a) print(output1,output2,output3)total_params = sum(p.numel() for p in SeedNetmodel.parameters())/1000000print("Total parameters: ", total_params)pretrained_weights_path = 'E:/bihand/released_checkpoints/ckp_seednet_all.pth.tar'img_rgb_path=r"E:\FreiHAND\training\rgb\00000153.jpg"img=io.imread(img_rgb_path)resized_img = transform.resize(img, (256, 256), anti_aliasing=True)img256=util.img_as_ubyte(resized_img)plt.imshow(resized_img)plt.axis('off') 关闭坐标轴plt.show()''' implicit HWC -> CHW, 255 -> 1 '''img1 = func.to_tensor(img256).float() 转换为张量并且进行标准化处理''' 0-mean, 1 std, [0,1] -> [-0.5, 0.5] '''img2 = func.normalize(img1, [0.5, 0.5, 0.5], [1, 1, 1])img3 = torch.unsqueeze(img2, 0)ok=img3print(img.shape)SeedNetmodel = SeedNet()misc.load_checkpoint(SeedNetmodel, pretrained_weights_path)加载权重output1, output2, output3 = SeedNetmodel(img3)mask_tensor = torch.rand(1, 64, 64)output=output2[1] 1,1,64,64output_1=output[0] 1,64,64output_ok=torch.sigmoid(output_1[0])output_real=output_1[0].detach().numpy()直接产生的张量图color_mask=color_mask(output_ok) 显示彩色分割图two_color=two_color(output_ok)显示黑白分割图see=output_ok.detach().numpy() 使用Matplotlib库显示分割掩码 plt.imshow(see, cmap='gray') plt.axis('off') plt.show() print(output1, output2, output3)images = [resized_img, color_mask, two_color,output_real,see,see]rows = 1cols = 4 创建子图并展示图像fig, axes = plt.subplots(1, 6, figsize=(30, 5)) 遍历图像列表，并在每个子图中显示图像for i, image in enumerate(images):ax = axes[i] if cols > 1 else axes 如果只有一列，则直接使用axesif i ==5:ax.imshow(image, cmap='gray')else:ax.imshow(image)ax.imshowax.axis('off') 调整子图之间的间距plt.subplots_adjust(wspace=0.1, hspace=0.1) 展示图像plt.show() 上述的代码文件是在bihand/models/net_seed.py中，全部代码链接在https://github.com/lixiny/bihand。 把bihand/models/net_seed.p中的代码修改为我提供的代码即可使用作者训练好的模型和进行各种可视化。（预训练模型根据作者代码提示下载） 3.调用阿里云API进行证件照生成实例 3.1 准备工作 1.找到接口 进入下面链接即可快速访问 link 2.购买试用包 3.查看APPcode 4.下载代码 5.参数说明 3.2 实验代码 !/usr/bin/python encoding: utf-8"""===========================证件照制作接口==========================="""import requestsimport jsonimport base64import hashlibclass Idphoto:def __init__(self, appcode, timeout=7):self.appcode = appcodeself.timeout = timeoutself.make_idphoto_url = 'https://idp2.market.alicloudapi.com/idphoto/make'self.headers = {'Authorization': 'APPCODE ' + appcode,}def get_md5_data(self, body):"""md5加密:param body_json::return:"""md5lib = hashlib.md5()md5lib.update(body.encode("utf-8"))body_md5 = md5lib.digest()body_md5 = base64.b64encode(body_md5)return body_md5def get_photo_base64(self, file_path):with open(file_path, 'rb') as fp:photo_base64 = base64.b64encode(fp.read())photo_base64 = photo_base64.decode('utf8')return photo_base64def aiseg_request(self, url, data, headers):resp = requests.post(url=url, data=data, headers=headers, timeout=self.timeout)res = {"status_code": resp.status_code}try:res["data"] = json.loads(resp.text)return resexcept Exception as e:print(e)def make_idphoto(self, file_path, bk, spec="2"):"""证件照制作接口:param file_path::param bk::param spec::return:"""photo_base64 = self.get_photo_base64(file_path)body_json = {"photo": photo_base64,"bk": bk,"with_photo_key": 1,"spec": spec,"type": "jpg"}body = json.dumps(body_json)body_md5 = self.get_md5_data(body=body)self.headers.update({'Content-MD5': body_md5})data = self.aiseg_request(url=self.make_idphoto_url, data=body, headers=self.headers)return dataif __name__ == "__main__":file_path = "图片地址"idphoto = Idphoto(appcode="你的appcode")d = idphoto.make_idphoto(file_path, "red", "2")print(d) 3.3 实验结果与分析 原图片 背景为红色生成的证件照 背景为蓝色生成的证件照 另外尝试了使用柴犬照片做实验，也生成了证件照 原图 背景为红色生成的证件照 参考（可供参考的链接和引用文献） 1.参考：BiHand: Recovering Hand Mesh with Multi-stage Bisected Hourglass Networks（BMVC2020） 论文链接：https://arxiv.org/pdf/2008.05079.pdf 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_37758063/article/details/131128967。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...。据比达咨询市场分析数据显示，2016年中国第三方餐饮外卖市场格局中，饿了么位居第一，市场份额为34.6%，美团外卖（33.6%）、百度外卖（18.5%）紧随其后，在“白领市场”、“社区市场”、“校园市场”的细分领域中，饿了么均占据榜首位置。截至2016年12月，饿了么业务覆盖1400多个城市，用户超过1亿，各地加盟餐厅超过100万家，日订单量突破900万，旗下“蜂鸟配送”日配送单量超过450万。 在 “独角兽”的成长道路上，饿了么面对人工成本高制约业务快速扩张、人工派单速度慢导致高峰期积压订单严重、人工派单随机性强引起订单配送时效性差等现实问题，而阿里云通过智能派单系统，基于海量历史订单数据、餐厅数据、骑手数据、用户数据等信息实现智能派单，逐步替代调度员的大部分工作。智能派单系统整体全面上线后将释放90%以上人工派单的人力，每年节省人力支出预计超过亿元。 饿了么的IT系统架构伴随业务量飙升，进行了三次重大升级。 1）起步期（2009至2013年）：饿了么由上海交通大学创始团队起家，发展至35人规模，日订单量维持在十万量级，由“IDC+Python”技术组合支撑业务运营，但面临Python人才难觅等困扰。 2）成长期（2014年至2015年）：14年8至9月短短2个月内日均订单量增长10倍，从10万迅猛飙升至100万，业务规模主攻全国200个城市，原有IT系统架构压力极大，依靠人肉运维举步维艰，故障波动影响业务，创始人与核心技术团队坚守机房运维一线，才勉强扛住100万量级业务订单。开始借鉴阿里淘宝架构模式，人员团队也涨至500人，技术生态从Python扩展至“Java+Python”开发体系，从“人肉”支撑百万订单运营到自动化运维，并筹备同城异地容灾体系。 3）规模期（2015年至2017年）：2015年7至8月，日均订单量从200万翻倍，以往积压的问题都暴露出来，技术架构面临大考验，坚定了架构上云的方案，团队扩展至1000人，架构要承载数百万量级业务时，出现峰值成本、灾备切换、IDC远程运维等种种挑战，全面战略转型采用“IDC+云计算”的混合云架构。在2016年12月25日圣诞节日订单量迎来前所未有的900万单，因此在技术架构上探索多活部署等创新性研发。 为什么选择架构转型上云？据饿了么CTO张雪峰先生所说，技术架构从IDC经典模式发展至混合云模式，主要原因是三个关键因素让管理层下定决心上云： 1） 脉冲计算：从技术架构配套业务发展分析，网络订餐业务具有明显的“脉冲计算”特征，在每日上午10:00至13:00、晚间16:00至19:00业务高峰值出现，而其他时间则业务量很低，暑假是业务高峰季，2016年5.17大促，饿了么第一次做“秒杀”，一秒订单15000笔，巨大的波峰波谷计算差异，引发了自建数据中心容量不可调和的两难处境，如果大规模投入服务器满足6小时的高峰业务量，则其余18个小时的业务低谷计算资源闲置，若满足平均业务量，则无法跟上业务快速发展节奏，落后于竞争对手；搞电商大促时，计算资源投入巨大，大促之后计算峰值下降，采用自建机房利用率仅10%，所以技术团队摸索出用云计算扛营销大促峰值的新模式，采用混合云架构满足 “潮汐业务”峰值计算，阿里云海量云计算资源弹性随需满足巨大的脉冲计算力缺口，这与每年“双11” 淘宝引入阿里云形成全球最大混合云架构具有异曲同工的创新价值。 2） 数据量爆炸：伴随饿了么近五年业务量呈几何级数的爆发式发展，数据量增速更加令人吃惊，是业务量增速的5倍，每日增量数据接近100TB，2015年短短2个月内业务量增长10倍，数据量增长了50倍，上海主生产机房不堪重负。30GB的DDoS攻击对业务系统造成较大风险，上云成为承载大数据、抗网络攻击的好方法。 3） 高可用性挑战：众所周知，IDC自建系统运维要承担从底层硬件到上层应用的“全栈运维”运营能力与维修能力，当2015年夏天上海数据中心故障发生，主核心交换机宕机时，备核心交换机Bug同时被触发，从事故发生到硬件厂商携维修设备打车赶往现场维修的整个过程中，饥饿的消费者无法订餐吃饭，技术团队第一次经历业务中断而束手无策，才下定决心大笔投入混合云灾备的建设，“吃一堑，长一智”，持续向淘宝学习电商云生产与灾备架构，以自动化运维替代人肉运维，从灾备向多活演进，成为饿了么企业架构转型的必经之路。 4） 大数据精益运营：不论网络打车还是网络订餐，共享服务平台脱颖而出的关键成功要素是智能调度算法，以大数据训练算法提升调度效率，饿了么在高峰时段内让百万“骑士”（送餐快递员）完成更多订单是算法持续优化的目标，而这背后隐藏着诸多复杂因素，包括考虑餐厅、骑士、消费者三者的实时动态位置关系，把新订单插入现有“骑士”的行进路线中，估计每家餐厅出餐时间，每个骑手的行进速度、道路熟悉程度各不相同，新老消费者获客成本、高价低价订单的优先级皆不相同。种种考量因素合并到一起，对于人类调度员来说，每天中午和晚上的高峰都是巨大的挑战。以上海商城路配送站为例，一个调度员每6秒钟就要调度1单，他需要考虑骑手已有订单量、路线熟悉度等。因此可以说，这份工作已经完全不适合人类。但对人工智能而言，阿里云ET则非常擅长处理这类超复杂、大规模、实时性要求高的“非人”问题。 饿了么是中国最大的在线外卖和即时配送平台，日订单量900万单、180万骑手、100万家餐饮店，既是史无前例的计算存储挑战，又是人无我有的战略发展机遇。饿了么携手阿里云人工智能团队，通过海量数据训练优化全球最大实时智能调度系统。在基础架构层，云计算解决弹性支撑业务量波动的基础生存问题，在数据智能层，利用大数据训练核心调度算法、提升餐饮店的商业价值，才是业务决胜的“技术神器”。 在针对大数据资源的“专家+机器”运营分析中，不断发现新的特征： 1） 区域差异性：饿了么与阿里云联合研发小组测试中发现有2个配送站点出现严重超时问题。后来才知道：2个站点均在成都，当地人民喜欢早、中餐一起吃，高峰从11点就开始了。习惯了北上广节奏的ET到成都就懵了。据阿里云人工智能专家闵万里分析：“不存在一套通用的算法可以适配所有站点，所以我们需要让ET自己学习或者向人类运营专家请教当地的风土人情、饮食习惯”。除此之外，饿了么覆盖的餐厅不仅有高大上的连锁店，还有大街小巷的各类难以琢磨的特色小吃，难度是其他智能调度业务的数倍。 2） 复杂路径规划：吃一口热饭有多难？送餐路径规划比驾车出行路径规划难度更高，要考虑“骑士”地图熟悉程度、天气状况、拼单效率、送餐顺序、时间对客户满意度影响、送达写字楼电梯等待时间等各种实际情况，究竟ET是如何实现智能派单并确保效率最优的呢？简单来说，ET会将配送站新接订单插入到每个骑手已有的任务中，重新规划一轮最短配送路径，对比哪个骑手新增时间最短。为了能够准确预估新增时间，ET需要知道全国100万家餐厅的出餐速度、超过180万骑手各自的骑行速度、每个顾客坐电梯下楼取餐的时间。一般来说，餐厅出餐等待时间占到了整个送餐时间的三分之一。ET要想提高骑手效率，必须准确预估出餐时间以减少骑手等待，但又不能让餐等人，最后饭凉了。饿了么旗下蜂鸟配送“准时达”服务单均配送时长缩短至30分钟以内。 3） 天气特殊影响：天气等环境因素对送餐响应时间影响显著，要想计算骑手的送餐路程时间，ET需要知道每个骑手在不同区域、不同天气下的送餐速度。如果北京雾霾，ET能看见吗？双方研发团队为ET内置了恶劣天气的算法模型。通常情况下，每逢恶劣天气，外卖订单将出现大涨，对应的餐厅出餐速度和骑手骑行速度都将受到影响，这些ET都会考虑在内。如果顾客在下雪天点个火锅呢？ET也知道，将自动识别其为大单，锁定某一个骑手专门完成配送。 4） 餐饮营销顾问：饿了么整体业务涉及C端（消费者）、B端（餐饮商户）、D端（物流配送）、BD端（地推营销），以往区域业务开拓考核新店数量，现在会重点关注餐饮外卖“健康度”，对于营业额忽高忽低、在线排名变化的餐饮店，都需要BD专家根据大数据帮助餐饮店经营者找出原因并给出解决建议，避免新店外卖刚开始就淹没在区域竞争中，销量平平的新店会离开平台，通过机器学习把餐饮运营专家的经验、以及人看不到的隐含规律固化下来，以数据决策来发现餐饮店经营问题、产品差异定位，让餐饮商户尝到甜头，才愿意继续经营。举个例子，饿了么员工都喜欢楼下一家鸡排店的午餐，但大数据发现这家店的外卖营收并不如实体店那么火爆，9元“鸡排+酸梅汁”是所有人都喜欢的爆款产品，可为什么同样菜品遭遇“线下火、线上冷”呢？数据预警后，BD顾问指出线上外卖鸡排产品没有写明“含免费酸梅汁一杯”的关键促销内容，导致大多数外卖消费者订一份鸡排一杯酸梅汁，却收到一份鸡排两杯酸梅汁，体验自然不好。 饿了么是数据驱动、智能算法调度的自动化生活服务平台，通过O2O数据的在线实时分析，与阿里云人工智能团队不断改进算法，以“全局最优”取代“局部最优”，保证平台上所有餐饮商户都能享受到数据智能的科技红利。 “上云用数”的外部价值诸多，从饿了么内部反馈来看，上云不仅没有让运维团队失去价值，反而带来了“云原生应用”(Cloud Native Application)、“云上多活”、“CDN云端压测”、“安全风控一体化”等创新路径与方案，通过敏捷基础设施(IaaS)、微服务架构(PaaS和SaaS)、持续交付管理、DevOps等云最佳实践，摆脱“人肉”支撑的种种困境，进而实现更快的上线速度、细致的故障探测和发现、故障时能自动隔离、故障时能够自动恢复、方便的水平扩容。饿了么CTO张雪峰先生说：“互联网平台型组织，业务量涨数倍，企业人数稳定降低，才是技术驱动的正确商业模式。” 在不久的将来，你每天订餐、出行、娱乐、工作留下的大数据，会“驯养”出无处不在、无所不能的智能机器人管家，家庭助理帮你点菜，无人机为你送餐，聊天机器人接受你的投诉……当然这个无比美妙的“未来世界”背后，皆有阿里云的数据智能母体“ET”。 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_34126557/article/details/90592502。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...问你如何避免oom，内存泄露导致的原因，以及如何处理大图片等等，其实都是 如何优化内存。 可以按照我自己总结的回答，你可以说，这个问题 ，跟 oom以及 内存泄露，其实是一样的，关键 就是 如何 优化内存，避免不必要的 内存泄露， 而 内存泄露 的原因 ，我总结了 4点， 1. 匿名内部类，和非静态内部类， 举个栗子：我们用handler 进行线程间　假如 我们在activity中这样定义 handler ： [java] view plain copy print ? Handler mHandler = new Handler() { @Override public void handleMessage(Message msg) { mImageView.setImageBitmap(mBitmap); } } 然后，我们用 右键 选中工程 运行 lint工具 ， android tools---run lint ,就会提示我们这样一个warning： In Android, Handler classes should be static or leaks might occur.。 就是 ，推荐我们 把handler 定义成static，具体 看这里解释的很详细：http://www.linuxidc.com/Linux/2013-12/94065.htm 类似的还有 匿名子线程。 2.还是 拿网上的 栗子来说， [java] view plain copy print ? Vector v = new Vector( 10 ); for ( int i = 1 ;i < 100 ; i ++ ){ Object o = new Object(); v.add(o); o = null ; } 即便是 我们把 o 对象 置为 null,但是 vector 集合中还有有o的引用，所以 集合 没有被清空，这一部分内存 还是不能被释放，这就导致了内存泄露。 3， 当我们操作数据库的时候，我们在执行完 相应的crud 方法后，我们没有关闭 cursor .close()或者 db.close()，也同样会占用内存、因为只有关闭连接后，才会被GC 回收。 4.继续举个栗子 [java] view plain copy print ? Set<Person> set = new HashSet<Person>(); Person p1 = new Person("唐僧","pwd1",25); Person p2 = new Person("孙悟空","pwd2",26); Person p3 = new Person("猪八戒","pwd3",27); set.add(p1); set.add(p2); set.add(p3); System.out.println("总共有:"+set.size()+" 个元素!"); //结果：总共有:3 个元素! p3.setAge(2); //修改p3的年龄,此时p3元素对应的hashcode值发生改变 set.remove(p3); //此时remove不掉，造成内存泄漏 set.add(p3); //重新添加，居然添加成功 System.out.println("总共有:"+set.size()+" 个元素!"); //结果：总共有:4 个元素! Ｊ哥　亲自　实践了下，发现问题了，这个网上的栗子　是错的。实际上是可以ｒｅｍｏｖｅ掉得、真是个悲伤地故事。这个栗子是不正确的。。网上好有一片这样的文章，都是这个栗子。。 这里　看下其他网站上的总结吧　：强烈推荐http://developer.51cto.com/art/201111/302465.htm。很详细。 ＯＫ。还有最后一点，就是关于图片的，ｂｉｔｍａｐ对象的及时释放，这里　就不细说了，等在图片三级缓存一起去总结。 此时　感觉　对面的ａｎｄｒｏｉｄ　小哥　已经被我吸引了。好像很认真的在听我讲课一样。 然后，　他问我问题。我大体总结了一下。 面试官01问：有没有自定义过ｖｉｅｗ。 Ｊ哥回答：这个很常见，我自己定义过很多，比如　下拉刷新，上拉加载更多数据的listview,类似github 上面的pulltorefreshlistview。 还有图片轮询播放的viewpager，也是 继承viewpager，然后自己开启一个线程，去控制 切换的。还比如，跑马灯效果的textview ，scrollview与 listview 相互嵌套 导致 listview 高度计算不正确，我也是 自定义listview，复写了 onmeaure方法，然后解决冲突的。在比如 一些开源的 可以放大缩小的图片，我也是做过，主要是对onmeasure 方法，onlayout方法，ondraw 方法的复写。以及复写一下 view 自己的 touch事件等等，奥 对了，我们公司当时有需求 做一个 锁屏软件，侧滑解锁的，我也是自己定义的，然后展示给他看了一下，当时 那篇文章在这里。传送门http://blog.csdn.net/u011733020/article/details/41863861。 面试官01问：listview的优化、 Ｊ哥回答：(PS：这种问题，基本上 都快被问烂了，但是没办法 还是要回答。）listview作为最常见的 用来显示数据的view ，一般 从四个方面 去优化。 1 ，复用convertview， 不然假如有1000条数据，那么我们滑动，就会 产生1000个convertview ，这对内存是很大的浪费，所以 我们一定要复用。 2. 减少 findviewbyid 的次数， 因为 每次 去 执行 findviewbyid 也是要消耗资源的，我们要尽可能的减少，通常 我们定义一个viewholder，去管理 这些id ，然后通过tag 去直接拿到 id。 3， 分页加载，延迟加载 预加载。 这个在我们以前项目，有一个榜单，数据量很大，一次请求过来的数据量很大，这样有两个问题，一个是请求网络 时间可能会很长，另一个展示数据 上面 体验对不是很好，所以 我们做了 第一次加载 20条，然后每次请求 再去 加载10条新数据。 4.就是 对 listview 中一些 类似头像， 图片的 优化。这里 类似 三级缓存，推荐大家看一下 开源 的universal-image-loader 的源码。或者 这篇文章http://www.jb51.net/article/38162.htm，J哥有时间 专门写一篇过于 图片缓存的。 面试官01问： 看你简历上面 做过 社交，通信这块是怎么做的。 Ｊ哥回答：我看 咱们公司 也用到了 聊天，咱们公司是 自己做的 还是 用的第三方的类似 环信的。结果被J哥猜中，他说 是集成的环信（但是 有丢包现象，所以打算自己做通信）。 OK，Ｊ哥说　，我们　项目中聊天　是基于ｘｍｐｐ协议的做的，在没有android以前　，java有个开源的 smack ，android 上 现在有一个asmack ,其实 就是移植到android 中来了， 服务端是基于 openfire的 ,我们就是做的 openfire+asmack 的 聊天，这个原理主要 就是 绑定 ip 拿到 connection 然后 connect ，然后进行通信，我说，这个　跟ｈｔｔｐ请求　其实原理上一样，都是　绑定ｉｐ，然后　设置一些ｐｒｏｐｅｒｔｙ，然后通过类似流进行通信的，　asmack，其实底层 就是xml通信的。 面试官01问： touch 事件的传递机制，还特意画了，一个 就是 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。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...的动力，是遇到问题是解决问题的方向指引，最重要的是让决策者认同商业目标，并能了解到支持商业目标的技术原理，上下目标对齐才好办事。 商业目标确定之后，需要确定容器相关的技术选型，容器是一种轻量化的虚拟化技术，与传统虚拟机比较有优点也有缺点，要找出这些差异点识别出对基础设施与应用的影响，提前识别风险并采取应对措施。 技术选型明确之后，在公司或部门内部推广与评审，让开发人员、架构师、测试人员、运维人员相关人员与团队理解与认同方案，听取他们意见，他们是直接使用容器的客户，不要让他们有抱怨。 最后是落地策略，一般是选取一些辅助业务先试点，在实践过程中不断总结经验。 商业目标 容器技术是以应用为中心的轻量级虚拟化技术，而传统的Xen与KVM是以资源为中心的虚拟化技术，这是两者的本质差异。以应用为中心是容器技术演进的指导原则，正是在这个原则指导下，容器技术相对于传统虚拟化有几个特点：打包既部署、镜像分层、应用资源调度。 打包即部署：打包即部署是指在容器镜像制作过程包含了传统软件包部署的过程（安装依赖的操作系统库或工具、创建用户、创建运行目录、解压、设置文件权限等等），这么做的好处是把应用及其依赖封装到了一个相对封闭的环境，减少了应用对外部环境的依赖，增强了应用在各种不同环境下的行为一致性，同时也减少了应用部署时间。 镜像分层：容器镜像包是分层结构，同一个主机上的镜像层是可以在多个容器之间共享的，这个机制可以极大减少镜像更新时候拉取镜像包的时间，通常应用程序更新升级都只是更新业务层（如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。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...是什么?为了取得真实数据,本刊用了2个月的时间进行深入调查与采访,希望这篇文章能在岁末年初之际,为大家带来深入的思考。 细分市场,其实软件从业人员除了程序员外,还囊括了很多的相关职业和角色,例如技术推广人、项目负责人、技术总监等,因此,凡与软件技术相关的工作或职业,都属于本专题关注之列。 程序员薪资调查报告 “软件人,今天薪资值多少?”大型网络调查活动从2004年10月初开始,在各大软件门户站点都开展了热点调查,截止11月底,在两个月的时间里,有近13000人参与并积极讨论了这个话题。 2004年,软件业人员结构处于什么分层? 2004年,开发人员实际收入多少? 2004年,开发人员使用最多的技术是什么? 2004年,影响收入的决定性因素到底是什么? …… 围绕以上种种问题,本刊设计了相关的调查与采访题目,在分析与统计开发者基本薪资情况下,还针对被调查者的专业背景、技术、软技能、公司福利以及影响薪资的关键因素做了相应的调查。 下面就让我们进入此次调查的数据现场。 2004年中国开发者平均月薪3500元 49%的开发者月薪不足3000,54%年薪不足4万(见表1、表2)。经历软件泡沫的投资家、管理者在对待员工的薪水上更为谨慎,但对开发者而言心理上却产生比较大的落差,在大环境如此的情况下,处于弱势的开发群体需要学会如何去适应环境,调整心态。 程序员占据大壁江山,升任技术总监者凤毛麟角 从本次的调查数据来看,程序员在所有调查者中占据主流,人数为一半还多,高级程序员也占了20%,这也是为什么开发者薪资普遍不高的主要原因之一。曾经业界大为盛行的国内缺乏高层次的软件人才的说法,这里似乎可以提供实在而有力的数据支持(见表3、表4)。 另外,从本次调查还得到了一个趋势:在做了3-5年的程序开发工作后,开始产生一定的人员分流现象。从有一定技术能力的程序员开始,到根据自己兴趣与爱好的二次择业,有相当部分的人员脱离编码一线,开始跨入技术主管、项目经理、技术支持、市场推广等角色。 不满者过半,普遍认为薪水太低 调查显示只有4%的人对薪水比较满意,近64%的人认为自己的薪水与社会同等能力开发人员相比偏低,这可以看出软件泡沫对开发人员造成的心理落差依然存在。人们普遍认为,软件业比较浮燥,所处其中的人也比较浮燥,但现在软件产业的发展越来越趋于理性和平和,只有先调整好自己的心态,平和地从基本功练起,薪水的价值才可能越来越得到不断提升。 软件开发,让女性走开 表5数据表明,开发者世界是一块绝对属于男性的天地,被调查者中有97%的人员属于男性。记者在采访中不止一次地发现,在软件公司中工作的女性很少,而从事一线编码工作的女性则是少之更少。一方面,软件开发这种技术创新与高挑战性、高压力的工作,男性更易于取得成果。另一方面,也有一部分中小企业对女性程序员不重视,甚至同工不同酬,也让一些希望就职此行业的女性永远地离开了这块阵地。 北京、上海、深圳、杭州成为程序员的最爱 地域对软件人员的薪资有很大的影响。北京以其政治、文化的优势集中了近19%的软件开发者,上海、深圳各占13%、10%,而杭州,以其良好的自然环境、人文环境及政府环境也吸引了5%的软件人才(见表6)。数据表明,拥有高校资源的城市先天性地占据着开发人才的绝对优势。而且,各项调查数据显示,地域也已不再是限制开发者流动的主要因素,尤其对于技术高手,他们几乎可以自由地在各大城市间来来往往。 情人虽好,糟糠之妻难下堂 哪些人在投资it企业,被调查者所在公司的规模如何?根据采访,几乎绝大多数的被调查者都将外企列在了第一选择,青睐之情溢于言表,但毕竟高高的门坎以及各种复杂因素,致使这些意愿大部分都难以实现。反而是那些遭到诸多抱怨的民营企业,尤其是占据31%的最高市场份额、员工数不足50人、管理不规范的中小软件公司,容纳了52%的开发者队伍。 c/c++、java成为翘楚,c实力强劲 调查显示,c/c++、java已是中国开发者的最爱,delphi依然延续着它的传奇之路,而c表现出了强大的后劲,相信这个微软公司推崇备至的开发利器在未来几年会如vb一样赢得开发者的信赖。 人气最旺的2大领域——企业信息化、通信 企业信息化、通信、通用软件开发、系统集成四大领域集中了目前开发者的大多数。加入wto之后,中国企业要与世界接轨,e化是必然的趋势,况且通信这个新兴行业以其门槛高、薪水高也吸引了许多开发者。企业信息化作为传统行业向网络化迈进的必然过程,容纳着很多软件人。另外,从市场角度看,移动、游戏开发、信息全三大热点领域对开发者也同样有极强诱惑力。 本科、计算机专业、部属院校大学毕业者成为中流砥柱 软件开发,并非只有计算机专业的人才能胜任,调查显示,有近40%的开发者是从其它相关或无关专业转行而来,但不可否认的是,占据60%者仍然为科班出身者。另外,尽管从来就崇尚高中毕业生就能成为软件天才,但这样的神话毕竟只是少数,支撑中国软件业的仍然是大学教育程度以上者。参与调查者中86%具有大专以上学历,另有8%的人具有硕士学历,数据表明中国开发者的整体教育水平较高。 综合实力的三大法宝:阅历、技术与沟通 59%的开发者从业期间做过的项目不超过5个,61%的人沟通能力较差,而近76%的开发者对自己比较自信,认为自己能力不弱于公司其它人员甚至更强。根据调查,在影响软件人薪资的因素中,阅历、技术强弱是决定性因素。另外,信息化时代普遍重视团队与项目整体实力,沟通能力成为影响程序员个人发展的一个重要因素。 软件人主体正处青春期 “程序员是吃青春饭的”,这个论断在本次调查中从另外一个角度得到验证。58%的软件开发者年龄不到25岁,48%的人在本领域工作时间不到3年,这些软件生力军未来5年必将成为引导中国软件发展潮流的主力军(见表18、表19)。另外,根据调查与采访,年龄在35岁左右的第二代软件人,现在已经成长为企业或项目的管理者,在各大软件公司担当着成熟、理性、有主见的软件开发带头人的角色。 待遇与福利走向正规化 有63%的公司会根据员工表现主动加薪(见表20),近80%的公司会为员工提供基本福利,如养老、医疗保险、住房补助、午餐补助等(见表21)。培训作为提升开发人员专业技能和实力的直接手段,越来越得到更多公司的重视。根据调查,项目奖金和固定假期基本成为以项目方式运作的公司的固定法宝,以鼓励和保障员工的士气和工作积极性。越来越多的中国软件企业,开始迈向规范化管理之路。 技术与眼光是决定薪水的至关要素 绝大部分被调查者都认为技术能力是决定薪资的最关键因素。但在采访过程中,却有更多的技术总监甚至公司总经理一级,认为短期内决定一个开发者薪水的因素中技术能力确实非常关键,但从长期来看,能对开发者的薪水带来长期且持久影响的,却不只是技术能力,更多的则是他本人对业界的了解度,即眼光是否开阔。这是一个很重要的信号,如果只在技术点上打转的人,除非是技术天才型,决大多数必须从综合能力等各方面来加强,而绝非技术这一点。可以说,在加强自身技术实力的前提下,开阔的视野、一定的沟通能力、自我管理与团队管理能力都对个人的发展起到至关重要的作用。(见表22) 现状解析:五维度立体定位开发者的薪资水平 结合以上调查结果以及本刊记者的深入采访,从宏观角度来看,有五个要素立体性地将软件人定位在了一定的薪资水平上。 这五个要素分别是:眼光技术、角色定位、公司性质、行业领域、地域因素。除第一、二要素是以个体原因占主体外,其他三个关键要素都取决于社会、产业、企业或公司本身的发展情况,但这些要素也不是一成不变的,在一定程度上,都是双向选择。 眼光技术是关键 一级:眼光与阅历 二级:核心技术 三级:专业与沟通 眼光开阔者得高薪 被采访者:王永刚 个人背景:软件公司cto 对于“决定薪资的最关键因素是什么”这个问题,王永刚用“是否适合职位”来回答,这一点与很多认为技术能力强就可以拿高薪的观点很不一样。他认为,多数职位分工不同,即便技术能力强但不适合职位,一样拿不到理想的薪水。他们公司在给员工定职定薪时,会与权威的咨询公司合作,从分析职位工作职责,到该职位所要求的人员素质,再到应聘员工对该职位的理解以及实际的工作情况,进行综合考虑。 专业与技术产生核心竞争力 被采访者:孙勇 个人背景:高级程序员,linux下c/c++开发 工作四年来,孙勇一直从事linux下使用c/c++进行的嵌入式开发,四年中跳过两次槽。跳槽前后的薪水变化很有意思,跳槽前月薪低年薪高,跳槽后月薪高但年薪却降了很多,原因是第一家公司项目奖金、年终分红很多,而第二家公司却没有其他方面的奖励机制。 孙勇自认为跳槽太过频繁,这样对自己技术能力的发展会产生较多的负面影响。在他看来,一个人薪资的高低终究取决于自己技术的核心竞争力,变动太大可能会造成技术上的不连续。所以孙勇说,未来五年内自己会沉浸于技术不考虑其它,目的只有一个,就是让自己更专业、更核心! 专家分析:眼光专业与核心竞争力是定位软件人层级的第一法码,其包含着很多的综合因素:专业背景、阅历、经验值、能力高下等等。趋势全球研发及资讯执行副总裁国屏认为,“技术很重要,但更重要的是市场和文化的配合。在个人的发展过程中,学习也会起到重要的作用。此外,还必须认同企业文化,具备技术、对工作、对解决问题的热情”。此外,学习能力和沟通能力也是专家们认为重要度很高的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。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...精确驱动打印机，不仅解决了长期以来因ActiveX禁用导致的报表打印难题，更实现了毫米级精度的模板设计和自动化打印流程，极大提升了企业数据可视化及报告输出效率。 此款报表系统的创新之处在于其强大的兼容性与灵活性，支持市面上绝大多数主流浏览器，包括但不限于IE6以上版本、Chrome 4.0以上版本、Firefox 4.0以上版本等，并且不受操作系统限制，即拷即用，不污染系统环境。同时，该系统提供了可视化的模板设计器，用户通过简单的拖拽操作即可完成复杂报表格式的设计，尤其对于发票、快递面单、支票等要求精准套打的场景，轻松实现一键打印。 此外，该报表系统还具备智能化的数据处理能力，采用Json格式进行数据交互，能够根据预设的模板自动填充并精确控制打印内容，同时支持从简单报表到嵌套报表、交叉报表等多种类型，以及一维二维条形码生成和脚本功能扩展。值得一提的是，它能灵活部署打印模板至客户端或服务端，并可根据实际需求动态指定打印机，实现专机专用，为各类业务场景提供高效便捷的解决方案。 在云计算、大数据快速发展的今天，报表系统的技术革新对于提升企业信息管理水平至关重要。这款基于现代浏览器技术和JSON数据交换标准的新型报表打印系统，无疑为企业信息化建设开辟了新的可能，也为行业标准的制定和完善提供了有力支撑。随着更多企业和机构开始重视数据驱动决策的重要性，类似这样的高效、易用且具有前瞻性的报表工具将迎来更为广阔的应用前景。

...ist 会占用大量的内存。 2、消息的实时性降低。 list 还提供了一个阻塞的命令:blpop，没有任何元素可以弹出的时候，连接会被阻塞。 基于 list 实现的消息队列，不支持一对多的消息分发。 1.2 发布订阅模式 除了通过 list 实现消息队列之外，Redis 还提供了一组命令实现发布/订阅模式。 这种方式，发送者和接收者没有直接关联(实现了解耦)，接收者也不需要持续尝试获取消息。 1.2.1 订阅频道 首先，我们有很多的频道(channel)，我们也可以把这个频道理解成 queue。订阅者可以订阅一个或者多个频道。消息的发布者(生产者)可以给指定的频道发布消息。只要有消息到达了频道，所有订阅了这个频道的订阅者都会收到这条消息。 需要注意的注意是，发出去的消息不会被持久化，因为它已经从队列里面移除了，所以消费者只能收到它开始订阅这个频道之后发布的消息。 下面我们来看一下发布订阅命令的使用方法。 订阅者订阅频道：可以一次订阅多个，比如这个客户端订阅了 3 个频道。 subscribe channel-1 channel-2 channel-3 发布者可以向指定频道发布消息(并不支持一次向多个频道发送消息): publish channel-1 2673 取消订阅(不能在订阅状态下使用): unsubscribe channel-1 1.2.2 按规则(Pattern)订阅频道 支持 ?和 占位符。? 代表一个字符， 代表 0 个或者多个字符。 消费端 1，关注运动信息: psubscribe sport 消费端 2，关注所有新闻: psubscribe news 消费端 3，关注天气新闻: psubscribe news-weather 生产者，发布 3 条信息 publish news-sport yaoming publish news-music jaychou publish news-weather rain 2、Redis 事务 2.1 为什么要用事务 我们知道 Redis 的单个命令是原子性的(比如 get set mget mset)，如果涉及到多个命令的时候，需要把多个命令作为一个不可分割的处理序列，就需要用到事务。 例如我们之前说的用 setnx 实现分布式锁，我们先 set，然后设置对 key 设置 expire， 防止 del 发生异常的时候锁不会被释放，业务处理完了以后再 del，这三个动作我们就希望它们作为一组命令执行。 Redis 的事务有两个特点: 1、按进入队列的顺序执行。 2、不会受到其他客户端的请求的影响。 Redis 的事务涉及到四个命令:multi(开启事务)，exec(执行事务)，discard (取消事务)，watch(监视) 2.2 事务的用法 案例场景:tom 和 mic 各有 1000 元，tom 需要向 mic 转账 100 元。tom 的账户余额减少 100 元，mic 的账户余额增加 100 元。 通过 multi 的命令开启事务。事务不能嵌套，多个 multi 命令效果一样。 multi 执行后，客户端可以继续向服务器发送任意多条命令，这些命令不会立即被执行，而是被放到一个队列中，当 exec 命令被调用时，所有队列中的命令才会被执行。 通过 exec 的命令执行事务。如果没有执行 exec，所有的命令都不会被执行。如果中途不想执行事务了，怎么办? 可以调用 discard 可以清空事务队列，放弃执行。 2.3 watch命令 在 Redis 中还提供了一个 watch 命令。 它可以为 Redis 事务提供 CAS 乐观锁行为(Check and Set / Compare and Swap)，也就是多个线程更新变量的时候，会跟原值做比较，只有它没有被其他线程修改的情况下，才更新成新的值。 我们可以用 watch 监视一个或者多个 key，如果开启事务之后，至少有一个被监视 key 键在 exec 执行之前被修改了，那么整个事务都会被取消(key 提前过期除外)。可以用 unwatch 取消。 2.4 事务可能遇到的问题 我们把事务执行遇到的问题分成两种，一种是在执行 exec 之前发生错误，一种是在执行 exec 之后发生错误。 2.4.1 在执行 exec 之前发生错误 比如：入队的命令存在语法错误，包括参数数量，参数名等等(编译器错误)。 在这种情况下事务会被拒绝执行，也就是队列中所有的命令都不会得到执行。 2.4.2 在执行 exec 之后发生错误 比如，类型错误，比如对 String 使用了 Hash 的命令，这是一种运行时错误。 最后我们发现 set k1 1 的命令是成功的，也就是在这种发生了运行时异常的情况下， 只有错误的命令没有被执行，但是其他命令没有受到影响。 这个显然不符合我们对原子性的定义，也就是我们没办法用 Redis 的这种事务机制来实现原子性，保证数据的一致。 3、Lua脚本 Lua/ˈluə/是一种轻量级脚本语言，它是用 C 语言编写的，跟数据的存储过程有点类似。 使用 Lua 脚本来执行 Redis 命令的好处: 1、一次发送多个命令，减少网络开销。 2、Redis 会将整个脚本作为一个整体执行，不会被其他请求打断，保持原子性。 3、对于复杂的组合命令，我们可以放在文件中，可以实现程序之间的命令集复用。 3.1 在Redis中调用Lua脚本 使用 eval /ɪ’væl/ 方法，语法格式: redis> eval lua-script key-num [key1 key2 key3 ....] [value1 value2 value3 ....] eval代表执行Lua语言的命令。 lua-script代表Lua语言脚本内容。 key-num表示参数中有多少个key，需要注意的是Redis中key是从1开始的，如果没有key的参数，那么写0。 [key1key2key3…]是key作为参数传递给Lua语言，也可以不填，但是需要和key-num的个数对应起来。 [value1 value2 value3 …]这些参数传递给 Lua 语言，它们是可填可不填的。 示例，返回一个字符串，0 个参数: redis> eval "return 'Hello World'" 0 3.2 在Lua脚本中调用Redis命令 使用 redis.call(command, key [param1, param2…])进行操作。语法格式: redis> eval "redis.call('set',KEYS[1],ARGV[1])" 1 lua-key lua-value command是命令，包括set、get、del等。 key是被操作的键。 param1,param2…代表给key的参数。 注意跟 Java 不一样，定义只有形参，调用只有实参。 Lua 是在调用时用 key 表示形参，argv 表示参数值(实参)。 3.2.1 设置键值对 在 Redis 中调用 Lua 脚本执行 Redis 命令 redis> eval "return redis.call('set',KEYS[1],ARGV[1])" 1 gupao 2673 redis> get gupao 以上命令等价于 set gupao 2673。 在 redis-cli 中直接写 Lua 脚本不够方便，也不能实现编辑和复用，通常我们会把脚本放在文件里面，然后执行这个文件。 3.2.2 在 Redis 中调用 Lua 脚本文件中的命令，操作 Redis 创建 Lua 脚本文件: cd /usr/local/soft/redis5.0.5/src vim gupao.lua Lua 脚本内容，先设置，再取值: cd /usr/local/soft/redis5.0.5/src redis-cli --eval gupao.lua 0 得到返回值: root@localhost src] redis-cli --eval gupao.lua 0 "lua666" 3.2.3 案例:对 IP 进行限流 需求：在 X 秒内只能访问 Y 次。 设计思路：用 key 记录 IP，用 value 记录访问次数。 拿到 IP 以后，对 IP+1。如果是第一次访问，对 key 设置过期时间(参数 1)。否则判断次数，超过限定的次数(参数 2)，返回 0。如果没有超过次数则返回 1。超过时间， key 过期之后，可以再次访问。 KEY[1]是 IP， ARGV[1]是过期时间 X，ARGV[2]是限制访问的次数 Y。 -- ip_limit.lua-- IP 限流，对某个 IP 频率进行限制 ，6 秒钟访问 10 次 local num=redis.call('incr',KEYS[1])if tonumber(num)==1 thenredis.call('expire',KEYS[1],ARGV[1])return 1elseif tonumber(num)>tonumber(ARGV[2]) thenreturn 0 elsereturn 1 end 6 秒钟内限制访问 10 次，调用测试(连续调用 10 次): ./redis-cli --eval "ip_limit.lua" app:ip:limit:192.168.8.111 , 6 10 app:ip:limit:192.168.8.111 是 key 值 ，后面是参数值，中间要加上一个空格和一个逗号，再加上一个空格 。 即:./redis-cli –eval [lua 脚本] [key…]空格,空格[args…] 多个参数之间用一个空格分割 。 代码:LuaTest.java 3.2.4 缓存 Lua 脚本 为什么要缓存 在脚本比较长的情况下，如果每次调用脚本都需要把整个脚本传给 Redis 服务端， 会产生比较大的网络开销。为了解决这个问题，Redis 提供了 EVALSHA 命令，允许开发者通过脚本内容的 SHA1 摘要来执行脚本。 如何缓存 Redis 在执行 script load 命令时会计算脚本的 SHA1 摘要并记录在脚本缓存中，执行 EVALSHA 命令时 Redis 会根据提供的摘要从脚本缓存中查找对应的脚本内容，如果找到了则执行脚本，否则会返回错误:“NOSCRIPT No matching script. Please use EVAL.” 127.0.0.1:6379> script load "return 'Hello World'" "470877a599ac74fbfda41caa908de682c5fc7d4b"127.0.0.1:6379> evalsha "470877a599ac74fbfda41caa908de682c5fc7d4b" 0 "Hello World" 3.2.5 自乘案例 Redis 有 incrby 这样的自增命令，但是没有自乘，比如乘以 3，乘以 5。我们可以写一个自乘的运算，让它乘以后面的参数： local curVal = redis.call("get", KEYS[1]) if curVal == false thencurVal = 0 elsecurVal = tonumber(curVal)endcurVal = curVal tonumber(ARGV[1]) redis.call("set", KEYS[1], curVal) return curVal 把这个脚本变成单行，语句之间使用分号隔开 local curVal = redis.call("get", KEYS[1]); if curVal == false then curVal = 0 else curVal = tonumber(curVal) end; curVal = curVal tonumber(ARGV[1]); redis.call("set", KEYS[1], curVal); return curVal script load ‘命令’ 127.0.0.1:6379> script load 'local curVal = redis.call("get", KEYS[1]); if curVal == false then curVal = 0 else curVal = tonumber(curVal) end; curVal = curVal tonumber(ARGV[1]); redis.call("set", KEYS[1], curVal); return curVal' "be4f93d8a5379e5e5b768a74e77c8a4eb0434441" 调用: 127.0.0.1:6379> set num 2OK127.0.0.1:6379> evalsha be4f93d8a5379e5e5b768a74e77c8a4eb0434441 1 num 6 (integer) 12 3.2.6 脚本超时 Redis 的指令执行本身是单线程的，这个线程还要执行客户端的 Lua 脚本，如果 Lua 脚本执行超时或者陷入了死循环，是不是没有办法为客户端提供服务了呢? eval 'while(true) do end' 0 为了防止某个脚本执行时间过长导致 Redis 无法提供服务，Redis 提供了 lua-time-limit 参数限制脚本的最长运行时间，默认为 5 秒钟。 lua-time-limit 5000(redis.conf 配置文件中) 当脚本运行时间超过这一限制后，Redis 将开始接受其他命令但不会执行(以确保脚本的原子性，因为此时脚本并没有被终止)，而是会返回“BUSY”错误。 Redis 提供了一个 script kill 的命令来中止脚本的执行。新开一个客户端: script kill 如果当前执行的 Lua 脚本对 Redis 的数据进行了修改(SET、DEL 等)，那么通过 script kill 命令是不能终止脚本运行的。 127.0.0.1:6379> eval "redis.call('set','gupao','666') while true do end" 0 因为要保证脚本运行的原子性，如果脚本执行了一部分终止，那就违背了脚本原子性的要求。最终要保证脚本要么都执行，要么都不执行。 127.0.0.1:6379> script kill(error) UNKILLABLE Sorry the script already executed write commands against the dataset. You can either wait the scripttermination or kill the server in a hard way using the SHUTDOWN NOSAVE command. 遇到这种情况，只能通过 shutdown nosave 命令来强行终止 redis。 shutdown nosave 和 shutdown 的区别在于 shutdown nosave 不会进行持久化操作，意味着发生在上一次快照后的数据库修改都会丢失。 4、Redis 为什么这么快? 4.1 Redis到底有多快？ 根据官方的数据，Redis 的 QPS 可以达到 10 万左右(每秒请求数)。 4.2 Redis为什么这么快? 总结:1)纯内存结构、2)单线程、3)多路复用 4.2.1 内存 KV 结构的内存数据库，时间复杂度 O(1)。 第二个，要实现这么高的并发性能，是不是要创建非常多的线程? 恰恰相反，Redis 是单线程的。 4.2.2 单线程 单线程有什么好处呢? 1、没有创建线程、销毁线程带来的消耗 2、避免了上线文切换导致的 CPU 消耗 3、避免了线程之间带来的竞争问题，例如加锁释放锁死锁等等 4.2.3 异步非阻塞 异步非阻塞 I/O，多路复用处理并发连接。 4.3 Redis为什么是单线程的? 不是白白浪费了 CPU 的资源吗? 因为单线程已经够用了，CPU 不是 redis 的瓶颈。Redis 的瓶颈最有可能是机器内存或者网络带宽。既然单线程容易实现，而且 CPU 不会成为瓶颈，那就顺理成章地采用单线程的方案了。 4.4 单线程为什么这么快? 因为 Redis 是基于内存的操作，我们先从内存开始说起。 4.4.1 虚拟存储器(虚拟内存 Vitual Memory) 名词解释:主存:内存;辅存:磁盘(硬盘) 计算机主存(内存)可看作一个由 M 个连续的字节大小的单元组成的数组，每个字节有一个唯一的地址，这个地址叫做物理地址(PA)。早期的计算机中，如果 CPU 需要内存，使用物理寻址，直接访问主存储器。 这种方式有几个弊端: 1、在多用户多任务操作系统中，所有的进程共享主存，如果每个进程都独占一块物理地址空间，主存很快就会被用完。我们希望在不同的时刻，不同的进程可以共用同一块物理地址空间。 2、如果所有进程都是直接访问物理内存，那么一个进程就可以修改其他进程的内存数据，导致物理地址空间被破坏，程序运行就会出现异常。 为了解决这些问题，我们就想了一个办法，在 CPU 和主存之间增加一个中间层。CPU 不再使用物理地址访问，而是访问一个虚拟地址，由这个中间层把地址转换成物理地址，最终获得数据。这个中间层就叫做虚拟存储器(Virtual Memory)。 具体的操作如下所示: 在每一个进程开始创建的时候，都会分配一段虚拟地址，然后通过虚拟地址和物理地址的映射来获取真实数据，这样进程就不会直接接触到物理地址，甚至不知道自己调用的哪块物理地址的数据。 目前，大多数操作系统都使用了虚拟内存，如 Windows 系统的虚拟内存、Linux 系统的交换空间等等。Windows 的虚拟内存(pagefile.sys)是磁盘空间的一部分。 在 32 位的系统上，虚拟地址空间大小是 2^32bit=4G。在 64 位系统上，最大虚拟地址空间大小是多少? 是不是 2^64bit=10241014TB=1024PB=16EB?实际上没有用到 64 位，因为用不到这么大的空间，而且会造成很大的系统开销。Linux 一般用低 48 位来表示虚拟地址空间，也就是 2^48bit=256T。 cat /proc/cpuinfo address sizes : 40 bits physical, 48 bits virtual 实际的物理内存可能远远小于虚拟内存的大小。 总结：引入虚拟内存，可以提供更大的地址空间，并且地址空间是连续的，使得程序编写、链接更加简单。并且可以对物理内存进行隔离，不同的进程操作互不影响。还可以通过把同一块物理内存映射到不同的虚拟地址空间实现内存共享。 4.4.2 用户空间和内核空间 为了避免用户进程直接操作内核，保证内核安全，操作系统将虚拟内存划分为两部分，一部分是内核空间(Kernel-space)/ˈkɜːnl /，一部分是用户空间(User-space)。 内核是操作系统的核心，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的权限。 内核空间中存放的是内核代码和数据，而进程的用户空间中存放的是用户程序的代码和数据。不管是内核空间还是用户空间，它们都处于虚拟空间中，都是对物理地址的映射。 在 Linux 系统中, 内核进程和用户进程所占的虚拟内存比例是 1:3。 当进程运行在内核空间时就处于内核态，而进程运行在用户空间时则处于用户态。 进程在内核空间以执行任意命令，调用系统的一切资源;在用户空间只能执行简单的运算，不能直接调用系统资源，必须通过系统接口(又称 system call)，才能向内核发出指令。 top 命令: us 代表 CPU 消耗在 User space 的时间百分比; sy 代表 CPU 消耗在 Kernel space 的时间百分比。 4.4.3 进程切换(上下文切换) 多任务操作系统是怎么实现运行远大于 CPU 数量的任务个数的? 当然，这些任务实际上并不是真的在同时运行，而是因为系统通过时间片分片算法，在很短的时间内，将 CPU 轮流分配给它们，造成多任务同时运行的错觉。 为了控制进程的执行，内核必须有能力挂起正在 CPU 上运行的进程，并恢复以前挂起的某个进程的执行。这种行为被称为进程切换。 什么叫上下文? 在每个任务运行前，CPU 都需要知道任务从哪里加载、又从哪里开始运行，也就是说，需要系统事先帮它设置好 CPU 寄存器和程序计数器(ProgramCounter)，这个叫做 CPU 的上下文。 而这些保存下来的上下文，会存储在系统内核中，并在任务重新调度执行时再次加载进来。这样就能保证任务原来的状态不受影响，让任务看起来还是连续运行。 在切换上下文的时候，需要完成一系列的工作，这是一个很消耗资源的操作。 4.4.4 进程的阻塞 正在运行的进程由于提出系统服务请求(如 I/O 操作)，但因为某种原因未得到操作系统的立即响应，该进程只能把自己变成阻塞状态，等待相应的事件出现后才被唤醒。 进程在阻塞状态不占用 CPU 资源。 4.4.5 文件描述符 FD Linux 系统将所有设备都当作文件来处理，而 Linux 用文件描述符来标识每个文件对象。 文件描述符(File Descriptor)是内核为了高效管理已被打开的文件所创建的索引，用于指向被打开的文件，所有执行 I/O 操作的系统调用都通过文件描述符;文件描述符是一个简单的非负整数，用以表明每个被进程打开的文件。 Linux 系统里面有三个标准文件描述符。 0:标准输入(键盘); 1:标准输出(显示器); 2:标准错误输出(显示器)。 4.4.6 传统 I/O 数据拷贝 以读操作为例: 当应用程序执行 read 系统调用读取文件描述符(FD)的时候，如果这块数据已经存在于用户进程的页内存中，就直接从内存中读取数据。如果数据不存在，则先将数据从磁盘加载数据到内核缓冲区中，再从内核缓冲区拷贝到用户进程的页内存中。(两次拷贝，两次 user 和 kernel 的上下文切换)。 I/O 的阻塞到底阻塞在哪里? 4.4.7 Blocking I/O 当使用 read 或 write 对某个文件描述符进行过读写时，如果当前 FD 不可读，系统就不会对其他的操作做出响应。从设备复制数据到内核缓冲区是阻塞的，从内核缓冲区拷贝到用户空间，也是阻塞的，直到 copy complete，内核返回结果，用户进程才解除 block 的状态。 为了解决阻塞的问题，我们有几个思路。 1、在服务端创建多个线程或者使用线程池，但是在高并发的情况下需要的线程会很多，系统无法承受，而且创建和释放线程都需要消耗资源。 2、由请求方定期轮询，在数据准备完毕后再从内核缓存缓冲区复制数据到用户空间 (非阻塞式 I/O)，这种方式会存在一定的延迟。 能不能用一个线程处理多个客户端请求? 4.4.8 I/O 多路复用(I/O Multiplexing) I/O 指的是网络 I/O。 多路指的是多个 TCP 连接(Socket 或 Channel)。 复用指的是复用一个或多个线程。它的基本原理就是不再由应用程序自己监视连接，而是由内核替应用程序监视文件描述符。 客户端在操作的时候，会产生具有不同事件类型的 socket。在服务端，I/O 多路复用程序(I/O Multiplexing Module)会把消息放入队列中，然后通过文件事件分派器(File event Dispatcher)，转发到不同的事件处理器中。 多路复用有很多的实现，以 select 为例，当用户进程调用了多路复用器，进程会被阻塞。内核会监视多路复用器负责的所有 socket，当任何一个 socket 的数据准备好了，多路复用器就会返回。这时候用户进程再调用 read 操作，把数据从内核缓冲区拷贝到用户空间。 所以，I/O 多路复用的特点是通过一种机制一个进程能同时等待多个文件描述符，而这些文件描述符(套接字描述符)其中的任意一个进入读就绪(readable)状态，select() 函数就可以返回。 Redis 的多路复用， 提供了 select, epoll, evport, kqueue 几种选择，在编译的时 候来选择一种。 evport 是 Solaris 系统内核提供支持的; epoll 是 LINUX 系统内核提供支持的; kqueue 是 Mac 系统提供支持的; select 是 POSIX 提供的，一般的操作系统都有支撑(保底方案); 源码 ae_epoll.c、ae_select.c、ae_kqueue.c、ae_evport.c 5、内存回收 Reids 所有的数据都是存储在内存中的，在某些情况下需要对占用的内存空间进行回 收。内存回收主要分为两类，一类是 key 过期，一类是内存使用达到上限(max_memory) 触发内存淘汰。 5.1 过期策略 要实现 key 过期，我们有几种思路。 5.1.1 定时过期(主动淘汰) 每个设置过期时间的 key 都需要创建一个定时器，到过期时间就会立即清除。该策略可以立即清除过期的数据，对内存很友好;但是会占用大量的 CPU 资源去处理过期的 数据，从而影响缓存的响应时间和吞吐量。 5.1.2 惰性过期(被动淘汰) 只有当访问一个 key 时，才会判断该 key 是否已过期，过期则清除。该策略可以最大化地节省 CPU 资源，却对内存非常不友好。极端情况可能出现大量的过期 key 没有再次被访问，从而不会被清除，占用大量内存。 例如 String，在 getCommand 里面会调用 expireIfNeeded server.c expireIfNeeded(redisDb db, robj key) 第二种情况，每次写入 key 时，发现内存不够，调用 activeExpireCycle 释放一部分内存。 expire.c activeExpireCycle(int type) 5.1.3 定期过期 源码:server.h typedef struct redisDb { dict dict; / 所有的键值对 /dict expires; / 设置了过期时间的键值对 /dict blocking_keys; dict ready_keys; dict watched_keys; int id;long long avg_ttl;list defrag_later; } redisDb; 每隔一定的时间，会扫描一定数量的数据库的 expires 字典中一定数量的 key，并清除其中已过期的 key。该策略是前两者的一个折中方案。通过调整定时扫描的时间间隔和每次扫描的限定耗时，可以在不同情况下使得 CPU 和内存资源达到最优的平衡效果。 Redis 中同时使用了惰性过期和定期过期两种过期策略。 5.2 淘汰策略 Redis 的内存淘汰策略，是指当内存使用达到最大内存极限时，需要使用淘汰算法来决定清理掉哪些数据，以保证新数据的存入。 5.2.1 最大内存设置 redis.conf 参数配置: maxmemory <bytes> 如果不设置 maxmemory 或者设置为 0，64 位系统不限制内存，32 位系统最多使用 3GB 内存。 动态修改: redis> config set maxmemory 2GB 到达最大内存以后怎么办? 5.2.2 淘汰策略 https://redis.io/topics/lru-cache redis.conf maxmemory-policy noeviction 先从算法来看: LRU，Least Recently Used:最近最少使用。判断最近被使用的时间，目前最远的数据优先被淘汰。 LFU，Least Frequently Used，最不常用，4.0 版本新增。 random，随机删除。 如果没有符合前提条件的 key 被淘汰，那么 volatile-lru、volatile-random、 volatile-ttl 相当于 noeviction(不做内存回收)。 动态修改淘汰策略: redis> config set maxmemory-policy volatile-lru 建议使用 volatile-lru，在保证正常服务的情况下，优先删除最近最少使用的 key。 5.2.3 LRU 淘汰原理 问题：如果基于传统 LRU 算法实现 Redis LRU 会有什么问题? 需要额外的数据结构存储，消耗内存。 Redis LRU 对传统的 LRU 算法进行了改良，通过随机采样来调整算法的精度。如果淘汰策略是 LRU，则根据配置的采样值 maxmemory_samples(默认是 5 个), 随机从数据库中选择 m 个 key, 淘汰其中热度最低的 key 对应的缓存数据。所以采样参数m配置的数值越大, 就越能精确的查找到待淘汰的缓存数据,但是也消耗更多的CPU计算,执行效率降低。 问题：如何找出热度最低的数据? Redis 中所有对象结构都有一个 lru 字段, 且使用了 unsigned 的低 24 位，这个字段用来记录对象的热度。对象被创建时会记录 lru 值。在被访问的时候也会更新 lru 的值。 但是不是获取系统当前的时间戳，而是设置为全局变量 server.lruclock 的值。 源码：server.h typedef struct redisObject {unsigned type:4;unsigned encoding:4;unsigned lru:LRU_BITS;int refcount;void ptr; } robj; server.lruclock 的值怎么来的? Redis 中有个定时处理的函数 serverCron，默认每 100 毫秒调用函数 updateCachedTime 更新一次全局变量的 server.lruclock 的值，它记录的是当前 unix 时间戳。 源码:server.c void updateCachedTime(void) { time_t unixtime = time(NULL); atomicSet(server.unixtime,unixtime); server.mstime = mstime();​struct tm tm; localtime_r(&server.unixtime,&tm);server.daylight_active = tm.tm_isdst; } 问题:为什么不获取精确的时间而是放在全局变量中?不会有延迟的问题吗? 这样函数 lookupKey 中更新数据的 lru 热度值时,就不用每次调用系统函数 time，可以提高执行效率。 OK，当对象里面已经有了 LRU 字段的值，就可以评估对象的热度了。 函数 estimateObjectIdleTime 评估指定对象的 lru 热度，思想就是对象的 lru 值和全局的 server.lruclock 的差值越大(越久没有得到更新)，该对象热度越低。 源码 evict.c / Given an object returns the min number of milliseconds the object was never requested, using an approximated LRU algorithm. /unsigned long long estimateObjectIdleTime(robj o) {unsigned long long lruclock = LRU_CLOCK(); if (lruclock >= o->lru) {return (lruclock - o->lru) LRU_CLOCK_RESOLUTION; } else {return (lruclock + (LRU_CLOCK_MAX - o->lru)) LRU_CLOCK_RESOLUTION;} } server.lruclock 只有 24 位，按秒为单位来表示才能存储 194 天。当超过 24bit 能表 示的最大时间的时候，它会从头开始计算。 server.h define LRU_CLOCK_MAX ((1<<LRU_BITS)-1) / Max value of obj->lru / 在这种情况下，可能会出现对象的 lru 大于 server.lruclock 的情况，如果这种情况 出现那么就两个相加而不是相减来求最久的 key。 为什么不用常规的哈希表+双向链表的方式实现?需要额外的数据结构，消耗资源。而 Redis LRU 算法在 sample 为 10 的情况下，已经能接近传统 LRU 算法了。 问题:除了消耗资源之外，传统 LRU 还有什么问题? 如图，假设 A 在 10 秒内被访问了 5 次，而 B 在 10 秒内被访问了 3 次。因为 B 最后一次被访问的时间比 A 要晚，在同等的情况下，A 反而先被回收。 问题:要实现基于访问频率的淘汰机制，怎么做? 5.2.4 LFU server.h typedef struct redisObject {unsigned type:4;unsigned encoding:4;unsigned lru:LRU_BITS;int refcount;void ptr; } robj; 当这 24 bits 用作 LFU 时，其被分为两部分: 高 16 位用来记录访问时间(单位为分钟，ldt，last decrement time) 低 8 位用来记录访问频率，简称 counter(logc，logistic counter) counter 是用基于概率的对数计数器实现的，8 位可以表示百万次的访问频率。 对象被读写的时候，lfu 的值会被更新。 db.c——lookupKey void updateLFU(robj val) {unsigned long counter = LFUDecrAndReturn(val); counter = LFULogIncr(counter);val->lru = (LFUGetTimeInMinutes()<<8) | counter;} 增长的速率由，lfu-log-factor 越大，counter 增长的越慢 redis.conf 配置文件。 lfu-log-factor 10 如果计数器只会递增不会递减，也不能体现对象的热度。没有被访问的时候，计数器怎么递减呢? 减少的值由衰减因子 lfu-decay-time(分钟)来控制，如果值是 1 的话，N 分钟没有访问就要减少 N。 redis.conf 配置文件 lfu-decay-time 1 6、持久化机制 https://redis.io/topics/persistence Redis 速度快，很大一部分原因是因为它所有的数据都存储在内存中。如果断电或者宕机，都会导致内存中的数据丢失。为了实现重启后数据不丢失，Redis 提供了两种持久化的方案，一种是 RDB 快照(Redis DataBase)，一种是 AOF(Append Only File)。 6.1 RDB RDB 是 Redis 默认的持久化方案。当满足一定条件的时候，会把当前内存中的数据写入磁盘，生成一个快照文件 dump.rdb。Redis 重启会通过加载 dump.rdb 文件恢复数据。 什么时候写入 rdb 文件? 6.1.1 RDB 触发 1、自动触发 a)配置规则触发。 redis.conf， SNAPSHOTTING，其中定义了触发把数据保存到磁盘的触发频率。 如果不需要 RDB 方案，注释 save 或者配置成空字符串""。 save 900 1 900 秒内至少有一个 key 被修改(包括添加) save 300 10 400 秒内至少有 10 个 key 被修改save 60 10000 60 秒内至少有 10000 个 key 被修改 注意上面的配置是不冲突的，只要满足任意一个都会触发。 RDB 文件位置和目录: 文件路径，dir ./ 文件名称dbfilename dump.rdb 是否是LZF压缩rdb文件 rdbcompression yes 开启数据校验 rdbchecksum yes 问题：为什么停止 Redis 服务的时候没有 save，重启数据还在? RDB 还有两种触发方式: b)shutdown 触发，保证服务器正常关闭。 c)flushall，RDB 文件是空的，没什么意义(删掉 dump.rdb 演示一下)。 2、手动触发 如果我们需要重启服务或者迁移数据，这个时候就需要手动触 RDB 快照保存。Redis 提供了两条命令: a)save save 在生成快照的时候会阻塞当前 Redis 服务器， Redis 不能处理其他命令。如果内存中的数据比较多，会造成 Redis 长时间的阻塞。生产环境不建议使用这个命令。 为了解决这个问题，Redis 提供了第二种方式。 执行 bgsave 时，Redis 会在后台异步进行快照操作，快照同时还可以响应客户端请求。 具体操作是 Redis 进程执行 fork 操作创建子进程(copy-on-write)，RDB 持久化过程由子进程负责，完成后自动结束。它不会记录 fork 之后后续的命令。阻塞只发生在 fork 阶段，一般时间很短。 用 lastsave 命令可以查看最近一次成功生成快照的时间。 6.1.2 RDB 数据的恢复(演示) 1、shutdown 持久化添加键值 添加键值 redis> set k1 1 redis> set k2 2 redis> set k3 3 redis> set k4 4 redis> set k5 5 停服务器，触发 save redis> shutdown 备份 dump.rdb 文件 cp dump.rdb dump.rdb.bak 启动服务器 /usr/local/soft/redis-5.0.5/src/redis-server /usr/local/soft/redis-5.0.5/redis.conf 啥都没有: redis> keys 3、通过备份文件恢复数据停服务器 redis> shutdown 重命名备份文件 mv dump.rdb.bak dump.rdb 启动服务器 /usr/local/soft/redis-5.0.5/src/redis-server /usr/local/soft/redis-5.0.5/redis.conf 查看数据 redis> keys 6.1.3 RDB 文件的优势和劣势 一、优势 1.RDB 是一个非常紧凑(compact)的文件，它保存了 redis 在某个时间点上的数据集。这种文件非常适合用于进行备份和灾难恢复。 2.生成 RDB 文件的时候，redis 主进程会 fork()一个子进程来处理所有保存工作，主进程不需要进行任何磁盘 IO 操作。 3.RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快。 二、劣势 1、RDB 方式数据没办法做到实时持久化/秒级持久化。因为 bgsave 每次运行都要执行 fork 操作创建子进程，频繁执行成本过高。 2、在一定间隔时间做一次备份，所以如果 redis 意外 down 掉的话，就会丢失最后一次快照之后的所有修改(数据有丢失)。 如果数据相对来说比较重要，希望将损失降到最小，则可以使用 AOF 方式进行持久化。 6.2 AOF Append Only File AOF:Redis 默认不开启。AOF 采用日志的形式来记录每个写操作，并追加到文件中。开启后，执行更改 Redis 数据的命令时，就会把命令写入到 AOF 文件中。 Redis 重启时会根据日志文件的内容把写指令从前到后执行一次以完成数据的恢复工作。 6.2.1 AOF 配置 配置文件 redis.conf 开关appendonly no 文件名appendfilename "appendonly.aof" AOF 文件的内容(vim 查看): 问题：数据都是实时持久化到磁盘吗? 由于操作系统的缓存机制，AOF 数据并没有真正地写入硬盘，而是进入了系统的硬盘缓存。什么时候把缓冲区的内容写入到 AOF 文件? 问题:文件越来越大，怎么办? 由于 AOF 持久化是 Redis 不断将写命令记录到 AOF 文件中，随着 Redis 不断的进行，AOF 的文件会越来越大，文件越大，占用服务器内存越大以及 AOF 恢复要求时间越长。 例如 set xxx 666，执行 1000 次，结果都是 xxx=666。 为了解决这个问题，Redis 新增了重写机制，当 AOF 文件的大小超过所设定的阈值时，Redis 就会启动 AOF 文件的内容压缩，只保留可以恢复数据的最小指令集。 可以使用命令 bgrewriteaof 来重写。 AOF 文件重写并不是对原文件进行重新整理，而是直接读取服务器现有的键值对，然后用一条命令去代替之前记录这个键值对的多条命令，生成一个新的文件后去替换原来的 AOF 文件。 重写触发机制 auto-aof-rewrite-percentage 100 auto-aof-rewrite-min-size 64mb 问题:重写过程中，AOF 文件被更改了怎么办? 另外有两个与 AOF 相关的参数: 6.2.2 AOF 数据恢复 重启 Redis 之后就会进行 AOF 文件的恢复。 6.2.3 AOF 优势与劣势 优点: 1、AOF 持久化的方法提供了多种的同步频率，即使使用默认的同步频率每秒同步一次，Redis 最多也就丢失 1 秒的数据而已。 缺点: 1、对于具有相同数据的的 Redis，AOF 文件通常会比 RDB 文件体积更大(RDB 存的是数据快照)。 2、虽然 AOF 提供了多种同步的频率，默认情况下，每秒同步一次的频率也具有较高的性能。在高并发的情况下，RDB 比 AOF 具好更好的性能保证。 6.3 两种方案比较 那么对于 AOF 和 RDB 两种持久化方式，我们应该如何选择呢? 如果可以忍受一小段时间内数据的丢失，毫无疑问使用 RDB 是最好的，定时生成 RDB 快照(snapshot)非常便于进行数据库备份， 并且 RDB 恢复数据集的速度也要比 AOF 恢复的速度要快。 否则就使用 AOF 重写。但是一般情况下建议不要单独使用某一种持久化机制，而是应该两种一起用，在这种情况下,当 redis 重启的时候会优先载入 AOF 文件来恢复原始的数据，因为在通常情况下 AOF 文件保存的数据集要比 RDB 文件保存的数据集要完整。 本篇文章为转载内容。原文链接：https://blog.csdn.net/zhoutaochun/article/details/120075092。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...它旨在提供一种优雅的解决方案，帮助开发者在用户等待内容加载时，展示一个视觉上的反馈。这个插件的核心特性是实现指示器的绝对居中，无论是在特定的容器内还是在整个页面视窗中，都能确保用户看到的Loading动画始终位于中心位置，不会因为屏幕大小变化而偏离。Center-Loader支持多种定制选项，包括使用图片或者流行的font-awesome字体图标作为Loading动画，这使得设计者可以根据品牌形象和风格选择合适的视觉元素。无论是简单的线条旋转，还是复杂的图形动画，都能轻松适配并保持良好的视觉效果。使用这款插件，开发者可以快速且轻松地提升用户体验，无需深入理解复杂的CSS定位技巧，只需几行简洁的代码，就能让网站在加载过程中更具互动性和专业感。无论是在处理大数据请求、异步加载内容，还是进行页面刷新时，Center-Loader都能为你的用户提供一个平滑且友好的等待体验。 点我下载 文件大小：87.04 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...求调整外观、行为以及数据源，确保与现有UI风格无缝融合。由于其轻量化特性，Awesomplete对性能影响极小，即使在处理大量数据时也能保持流畅。这使得它在处理大数据集或实时搜索场景中表现优异。此外，由于其开源的本质，开发者社区活跃，意味着能得到及时的技术支持和持续的更新。总之，Awesomplete是一款理想的自动完成解决方案，它以简约的设计和强大的功能性，简化了前端开发中常见的输入框自动补全功能，是提升网站交互体验的理想选择。无论你是新手还是经验丰富的前端开发者，都能在Awesomplete中找到价值。 点我下载 文件大小：54.09 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...PI接口设计、前后端数据交互、实时通信等多个核心环节。近期，随着前端框架Vue3和React hooks等现代技术的发展，JSON数组的动态处理与渲染效率得到了显著提升。例如，开发者可以通过Vue3的reactive特性或React Hooks中的useState和useEffect对JSON数组进行高效的状态管理，并实时反映在用户界面上。 同时，随着大数据和云计算技术的普及，JSON数组在处理大规模、非结构化数据时的作用也日益凸显。如Apache Spark等分布式计算框架已支持原生JSON数据类型，使得JSON数组能在海量数据场景下实现快速解析与处理。 此外，在安全性和隐私保护方面，业界正针对JSON数组的数据传输安全推出一系列新标准和解决方案。例如，通过JSON Web Tokens（JWT）进行身份验证时，如何安全地封装和解码包含敏感信息的JSON数组成为了研究热点。 综上所述，JSON数组在现代Web开发中不仅扮演着数据交换的关键角色，而且随着技术发展不断拓展其应用场景。从提高性能优化到强化数据安全性，JSON数组的相关实践和研究都在与时俱进，为构建高效、安全的Web应用提供有力支撑。

...r指令可以方便地遍历数据并生成列表项，同时利用v-on或@指令进行事件绑定，即使面对动态生成的元素，也能借助于依赖追踪和异步更新队列实现事件委托的效果。 值得注意的是，尽管这些新兴框架带来了许多优势，但JQuery仍因其广泛兼容性和易用性，在不少项目尤其是对旧版浏览器支持有要求的场景下继续发挥着重要作用。因此，深入理解和掌握JQuery及其它JavaScript库和框架在DOM操作和事件处理方面的差异与共通之处，对于提升Web开发效率和代码质量至关重要。 此外，随着Web Components标准的推进和发展，未来可能会出现更多基于原生API实现的解决方案，这也将改变我们对动态生成元素和事件绑定的传统认知。对此，持续关注相关技术动态，适时调整和优化开发策略，无疑有助于保持技术水平与时俱进。

...我们还可以进一步探讨数据库在游戏开发中的核心作用以及数据库优化对提升玩家体验的影响。近期，《游戏开发者》杂志的一篇文章揭示了某知名网络游戏通过优化数据库架构，成功减少了游戏内交易的延迟，显著提升了元宝充值、消耗等操作的实时性，从而提高了用户满意度和留存率。 同时，随着云计算和大数据技术的发展，许多游戏公司开始采用分布式数据库来应对高并发场景下的数据处理需求。例如，阿里云发布的最新解决方案中就详细介绍了如何借助云数据库实现动态扩容，有效支撑了大型网游在高峰期的海量元宝数值更新与查询请求。 此外，针对游戏经济系统的安全问题，也有专家提出应当强化数据库权限管理，采用加密传输技术和二次验证机制确保元宝等虚拟财产的安全存储与变更。最近一起因数据库漏洞导致的游戏元宝被盗事件，再次敲响了游戏数据安全的警钟，促使业界加大对数据库防护措施的研究和投入。 总的来说，从基本的MySQL操作到复杂的数据库架构设计与优化，再到数据安全防护，游戏开发过程中对于数据库技术的应用和探索是一个持续且深入的过程，它不仅影响着游戏功能的实现，更是关乎游戏生态健康与用户体验的关键因素。

...个基于Vue.js的数据表格组件，支持排序、过滤、分页等功能，同时可以通过row-click事件监听行的点击事件。 然后，我们需要明白，要实现行的展开/收起效果，需要两个关键点：一是获取当前被点击的行数据；二是修改该行的状态，使其可以展示子内容。 三、解决方案 1. 获取当前被点击的行数据 通过el-table提供的row-click事件，我们可以轻松地获取到当前被点击的行数据。以下是一个简单的示例： html 2. 修改该行的状态，使其可以展示子内容 对于这个问题，我们需要自己添加一个状态变量，并且在row-click事件触发时更新这个状态变量。下面是一个简单的示例： html 四、总结 通过上述方法，我们成功实现了在Vue.js项目中使用Element-UI的el-table组件时，点击行任意位置都能实现展开/收起的效果。要特别留意的是，这里的“展开/收起”可不只是简单的藏起来露出来那么简单，关键得保证表头、表体这些部分都整整齐齐的，不能让人瞅见有啥突兀的蹦跶情况发生哈。如果对这个问题感兴趣，欢迎留言讨论，一起学习进步！

...he Lucene：解决NoSuchDirectoryException找不到目录异常 引言 在进行大规模数据处理时，可能会遇到各种各样的问题，其中一个常见的问题是NoSuchDirectoryException找不到目录异常。这个异常通常会在我们尝试访问一个不存在的文件或目录时抛出。今天呢，咱们就来一起唠唠嗑，探讨一下如何借助这个超牛的搜索引擎工具——Apache Lucene，来把这个问题给妥妥地解决了哈！ 什么是Apache Lucene？ Apache Lucene是一个开源的全文搜索库，主要用于对文本进行索引和搜索。它支持多种语言，并且可以运行在多个操作系统上。Lucene的性能非常高，可以快速地对大量文本进行搜索。 NoSuchDirectoryException找不到目录异常 当我们在使用Lucene时，如果试图访问一个不存在的目录，就会抛出NoSuchDirectoryException异常。这是因为Lucene在启动的时候，得先建一个文件目录来存放索引和其它相关的那些文件啦。要是这个目录没影儿了，那就没法继续给Lucene走初始化流程了，这时候就得抛出个异常来提醒你。 例如，下面的代码尝试初始化一个名为test的Lucene实例： java Directory directory = FSDirectory.open(new File("test")); Analyzer analyzer = new StandardAnalyzer(); IndexWriterConfig config = new IndexWriterConfig(analyzer); IndexWriter writer = new IndexWriter(directory, config); 如果test目录不存在，这段代码就会抛出NoSuchDirectoryException异常。 解决NoSuchDirectoryException找不到目录异常的方法 为了解决这个问题，我们需要在初始化Lucene之前，先创建这个目录。我们可以使用Java的File类来创建这个目录。以下是一个示例： java try { File dir = new File("test"); if (!dir.exists()) { boolean success = dir.mkdir(); if (!success) { throw new RuntimeException("Failed to create directory."); } } Directory directory = FSDirectory.open(dir); Analyzer analyzer = new StandardAnalyzer(); IndexWriterConfig config = new IndexWriterConfig(analyzer); IndexWriter writer = new IndexWriter(directory, config); } catch (IOException e) { // Handle IOExceptions here. } 在这个示例中，我们首先检查test目录是否已经存在。如果不存在，我们就尝试创建它。如果创建失败，我们就抛出一个运行时异常。如果创建成功，我们就使用这个目录来初始化Lucene。 这样，即使test目录不存在，我们的代码也可以正常运行，并且能够创建一个新的目录。 结论 总的来说，NoSuchDirectoryException找不到目录异常是我们在使用Lucene时经常会遇到的问题。但是，只要我们掌握了正确的解决方案，就可以轻松地解决这个问题。在我们动手初始化Lucene之前，有个小窍门可以确保目录已经准备就绪，那就是用Java里的File类来亲手创建这个目录，这样一来，一切就能稳妥进行啦！这样一来，哪怕目录压根不存在，我们的代码也能稳稳地运行起来，并且顺手就把新的目录给创建了。

...va开发中，处理图像数据并将其转换为适合网络传输和文件上传的格式是一项常见任务。如上所述，我们可以通过将BufferedImage对象转换为MultipartFile实现二维码图片的上传功能。然而，在实际应用中，这一过程可能涉及到更复杂的场景和技术点。 近期，随着微服务架构的普及以及云存储服务的广泛应用，高效、安全地上传和管理各类文件资源的需求日益凸显。例如，某公司近日推出了全新的图片处理中间件，它不仅可以生成高质量的二维码，还内置了丰富的图像转换工具，包括将BufferedImage无缝转换为多种文件格式（如MultipartFile），以便直接与Spring Boot框架的文件上传接口集成。 同时，开发者需要注意的是，虽然上述流程能够完成基本的转换操作，但在大数据量或高并发环境下，还需要考虑内存优化、流式处理及异步上传等策略。例如，通过使用Java NIO（非阻塞I/O）技术提高大文件上传效率，或者利用多线程技术进行并发处理，减少单个请求的响应时间。 此外，对于安全性要求较高的场景，还可以结合现代加密算法对图像数据进行加密处理，确保在流转过程中不被篡改或泄露敏感信息。一些前沿研究甚至探讨了如何在保证数据安全的同时，实现对图像内容的部分模糊处理以保护用户隐私。 总之，从BufferedImage到MultipartFile的转换仅仅是Java图形处理及文件上传功能中的一个环节，深入理解和掌握相关的底层原理和技术方案，有助于开发者应对更多复杂的应用需求，并在实际项目中提供更加稳定、高效的服务。

... 在这个互联网时代，数据的重要性不言而喻。通过分析数据，我们可以了解用户的喜好，优化我们的产品和服务。这篇文章将教你如何在输出用户列表的同时，统计并输出每个用户推荐用户的人数。 二、需求分析 假设我们有一个用户推荐系统，每个用户都有一个推荐用户列表，我们需要在显示用户列表的时候，同时显示每个用户推荐的人数。 三、解决方案 解决这个问题的关键在于如何遍历用户列表，并对每个用户进行推荐人数的统计。这里我们将使用PHP来实现这个功能。 首先，我们需要创建一个用户类，这个类需要包含用户ID，用户名，推荐用户列表等信息。 php class User { public $id; public $name; public $recommendedUsers; public function __construct($id, $name, $recommendedUsers) { $this->id = $id; $this->name = $name; $this->recommendedUsers = $recommendedUsers; } } 然后，我们可以创建一个函数，接收一个用户列表作为参数，遍历这个列表，统计每个用户的推荐人数，并将结果存储在一个关联数组中。 php function countRecommendedUsers($users) { $countMap = array(); foreach ($users as $user) { if (!isset($countMap[$user->id])) { $countMap[$user->id] = 0; } $countMap[$user->id] += count($user->recommendedUsers); } return $countMap; } 最后，我们可以调用这个函数，获取每个用户的推荐人数，并打印出来。 php $userList = array( new User(1, 'Alice', array('Bob')), new User(2, 'Bob', array('Charlie')), new User(3, 'Charlie', array()) ); $countMap = countRecommendedUsers($userList); foreach ($countMap as $userId => $count) { echo "User ID: {$userId}, Recommended Users: {$count}\n"; } 四、总结 通过上述步骤，我们成功地实现了在输出用户列表的同时，统计并输出每个用户推荐用户的人数的功能。这个过程既涉及到面向对象编程的知识，也涉及到了数组操作的知识。理解这些知识，对于学习和使用PHP都是非常重要的。 在这个过程中，我们还思考了一些问题，比如如何设计和使用类，如何编写高效的代码等。这些可都是我们在实际编程开发过程中，经常会碰到的头疼问题，也是我们不得不持续学习、不断摸索、努力攻破的难关！希望这篇文章能对你有所帮助，也希望你能从中得到一些启发。

...了Datax如何实现数据过滤处理之后，我们可以关注当前大数据领域中数据清洗与过滤技术的最新进展。近日，阿里云宣布对DataX进行了重大升级，新增了一系列高效的数据预处理功能，其中就包括更强大的条件过滤和复杂业务逻辑处理能力，使得用户能够更加灵活、精准地进行数据筛选。 与此同时，业界对于数据质量的关注度也在不断提升。国际知名数据分析机构Gartner发布报告强调，在AI和机器学习应用愈发广泛的今天，高质量的数据输入是保证模型准确性和稳定性的基石，而有效且智能化的数据过滤技术正是提升数据质量的关键一环。 此外，针对企业级数据处理场景，一些开源项目如Apache Beam和Kafka Streams也提供了丰富且可扩展的数据过滤解决方案，通过支持SQL-like查询语句或自定义函数，实现了与Datax相似甚至更为复杂的数据过滤需求。 因此，深入研究并掌握各类数据过滤工具和技术不仅有助于优化日常的数据管理工作，更能为企业利用大数据进行智能决策提供强大支撑，从而更好地应对数字化转型中的挑战。

...的元素，无需暴露底层数据结构的具体实现。通过调用集合对象的iterator()方法获取迭代器实例后，可以使用hasNext()、next()和remove()等方法按顺序访问和操作集合内的每个元素。 设计模式 , 设计模式是在软件设计中反复出现且经过验证的最佳实践解决方案。在本文语境中，迭代器就是一种设计模式，它定义了在特定情况下，如何解决通用编程问题的标准模板，使得代码更易于理解、复用和维护。 ArrayList , ArrayList是Java集合框架中的一种动态数组实现，它是实现了List接口的类，允许在列表的中间进行高效地插入和删除操作，并且可以通过索引访问元素。在本文中，ArrayList作为示例集合对象，通过调用其iterator()方法创建迭代器，进而遍历和处理其中的元素。

...存储、快速查找到海量数据，并且还能麻溜儿地处理这些数据。 二、什么是ElasticSearch？ 简单来说，ElasticSearch是一个基于Lucene的开源搜索引擎，能够进行全文搜索、实时分析和索引管理。它的设计理念是提供一种易于扩展、高性能且实时的搜索解决方案。 三、Painless scripting编程实践 在ElasticSearch中，我们可以通过脚本语言进行各种复杂的操作。这就是我要详细介绍的Painless scripting。 四、Painless scripting的基本概念 Painless是ElasticSearch的一种新的脚本语言，它被设计成一种易学易用的语言，可以方便地与ElasticSearch的数据模型集成。 五、Painless scripting的优势 1. 简单易学 Painless script语言的设计目标就是使用户能够快速上手，并且其语法也尽可能接近Java。 2. 高性能 Painless script语言是在JVM上运行的，因此它的性能非常优秀。 3. 安全性 ElasticSearch对Painless script语言进行了严格的安全检查，防止恶意攻击。 六、Painless scripting的应用场景 1. 数据过滤 我们可以使用Painless脚本来过滤出我们需要的数据。 2. 数据转换 如果我们需要对数据进行一些特殊的处理，例如计算某个字段的平均值或者总和，也可以使用Painless脚本来实现。 3. 数据聚合 Painless脚本可以帮助我们对大量的数据进行聚合操作，例如计算某段时间内的日均访问量。 七、Painless scripting的基本语法 1. 变量定义 在Painless脚本中，我们可以使用var关键字来定义变量。 2. 控制结构 Painless脚本支持if/else、for等控制结构。 3. 函数调用 我们可以直接调用ElasticSearch中的函数，例如avg()、sum()等。 4. 异常处理 在Painless脚本中，我们可以使用try/catch来捕获并处理异常。 八、Painless scripting的示例代码 java GET my-index/_search { "script_fields": { "average_price": { "script": { "source": """ Double total = doc['price'].value(); int count = doc['count'].value(); return total / count; """, "lang": "painless" } } } } 在这段代码中，我们使用了Painless脚本来计算文档中价格的平均值。 九、结论 总的来说，Painless scripting是一种强大而灵活的工具，它可以让我们在ElasticSearch中实现许多复杂的功能。学习并熟练掌握Painless scripting这项技能后，我真心相信咱们的工作效率绝对会蹭蹭往上涨，效果显著到让你惊讶。