背景音：

Sir，收到線報啦，今日喺生產環境用戶訪問網頁嘅時候，竟然感受到咁卡卡地！完全冇得爽啊！已經導致唔少用戶投訴。根據推斷，昨日更新咗埋點SDK...

昨日，一位前端程序员在优化公司的埋点SDK使用方式后，出了一些小插曲。不知道是什么原因，更新之后就开始有用户反馈说网页卡卡地，走得比蜗牛还慢。

六点二十分，第一个用户提交了投诉工单，但这只是个开始。

今天早上九点十分，公司的运维团队已经接到了一大堆反馈工单，许多用户都遭受到了同样的问题。这是一个巨大的问题，一旦得不到解决，可能导致数万的用户受到影响。运维人员立即开始了排查工作，想要找出问题所在。

经过一个小时的紧急排查，他们终于想到了昨日的这名前端程序员，一经沟通发现是SDK版本更新引起的问题。在新的版本中，有一些不稳定的代码导致了性能问题。

然而，这不仅仅是个技术问题，因为接下来，他们要开始着手写事故报告，准备给上层领导交代。

接下来，进入正题：

一、问题排查定位

根据更新的版本体量，可以缩小和快速定位问题源于新引入埋点SDK。

1. 打开 开发者工具-性能分析，开始记录


2. 刷新页面，重现问题


3. 停止记录，排查分析性能问题

如上图，按照耗时排序，可以快速定位找到对应的代码问题。

首先把编译压缩后的代码整理一下，接下来，深入代码一探究竟。

⏸️暂停一下，不妨猜猜看这里是为了干嘛？

🍵喝口茶，让我们沿着事件路径，反向继续摸清它的意图吧。

这里列举了231个字体名称，调用上文的 detect() 来分析。

⏸️暂停一下，那么这个操作为什么会耗时且阻塞页面渲染呢？

...

休息一下，让我们去看看这段代码的来龙去脉。

上面我们大概猜到代码是用于获取用户浏览器字体，那就简单检索一下 js get browser font。

证据确凿，错在对岸。

二、解决问题

相信大家也看出来了，我不是埋点SDK，我也不是甲方爸爸，我只能是一位前端开发。

联系反馈至SDK方，需要走工单，流程，而这一切要多少时间？

我唔知啊！领导也不接受啊！

👐没办法，只能自己缝补缝补了。

那么如何解决呢？

1. 尝试修复 getFonts detect 字体检测逻辑，避免多次重绘。


2. 缩短待检测字体目录。

人生苦短，我选方案3，直接修改返回值，跳过检测。

getFonts () { return 'custom_font' }

那么让我们继续搬砖吧。

1. 寻根

首先找到 SDK 加载对应 JS 的加载方式，看看能不能动点手脚。
这里可以看到，是采用很常见的 通过 appendScript loadJs 的方案，那么就可以复写拦截一下 appendChild 函数。

2. 正源

通过拦截 appendChild，将SDK加载的JS改为加载修复后的JS文件。

核心代码如下：

var tempCAppend = document.head.appendChild

document.head.appendChild = function (t) {

    if (t.tagName === 'SCRIPT' && t.src.includes('xxx.js')) {

          t.src = 'custom_fix_xxx.js'

    }

    return tempCAppend.bind(this)(t)

}

三、后续

这件事情发生在21年底，今天为什么拿出来分享一下呢？

近期排查 qiankun 部分子应用路由加载异常的时候，定位到与 document.head.appendChild 被复写有关，于是去看SDK方是否修复，结果纹丝未动....

结合近期境遇，不得不感慨，业务能不能活下去，真的和代码、技术什么的毫无关系。

其他

❄️下雪了，简单看了几眼文心一言的发布会，更凉了。

【随想录】我尽然突然焦虑，并且迷茫了

「随想录」

这是师叔对自我现状的剖析和寻找了一些 “新的方向” “新的视角” 来重新审视自我的思想录，希望我的家银们在文章中得到思想启发或以我为鉴，不去做无谓思想内耗！

最近是怎么了

最近几个朋友，突然询问我，现在应该怎么学习，将来才会更好的找工作，怕毕业以后没有饭吃，我说我其实也不太清楚，我目前三段实习我都没有找到一份真正意义的好工作，就是那种我喜欢这门领域，并且喜欢公司的氛围，并且到老了还能保持竞争力（莫有35岁危机）。

所以说我真的没有一个准确的答案回复。但是我以为目前的眼光来看一份好工作必备的条件就是，我在这个领域学的越多，我的工资和个人发展瓶颈越高，这份工作是一个持续学习的过程，并且回报和提高是肉眼可见的！

回忆那个时候

其实说实话，这个疑惑我上大一就开始有，但是那个时候是从高考的失落中寻找升学的路径，开始无脑的刷那种考研短视频

（看过可能都知道真的一下子励志的心就有了，但是回到现实生活中，看到身边人的状态~~~没错人就是一个从众的种群，你可能会问你会不会因为大一没有那么努力学习而后悔，但是其实我不会，因为那一年我的经历也是我最开心大学生活，虽然也干了很多被室友做成梗的糗事，但是想一想那不就是青春嘛，要是从小就会很有尺度的为人处世，想一想活着也很累嘛，害，浅浅致敬一下充满快乐和遗憾的青春呀！）

个人看法

哈哈，跑题了。给大家点力量把！前面满满的焦虑。其实我感觉我们都应该感谢我们来到计算机类的专业，从事这方面的学习和研究。

因为计算机的扩展性，不得不说各行各业都开始越来越喜欢我们计算机毕业的大学生（就业方向更加广），我也因为自己会计算机，成功进入一个一本高校以上的教育类公司实习（同时也是这个时候知道了更多优秀学校的毕业年轻人，真正认识到学校的层次带给人的很多东西真正的有差距）；

虽然我是二本的学生，但是在亲戚朋友眼里，虽然学校比不上他们的孩子，但是计算机专业也能获得浅浅的也是唯一一点可以骄傲的东西（活在别人嘴这种思考方式肯定不是对的，但是现实就是在父母那里，我们考上什么大学和进入了哪里工作真的是他们在外人的脸面，这种比较情况在大家族或者说农村尤为严重）；

技术论打败学校论，计算机专业是在“广义”上为数不多能打破学校出身论的学科，在公司上只要你能干活，公司就愿意要你，这个时候肯定有人diss我，现在培训班出来的很多都找不到工作呀，我的回答只能是：的确，因为这个行业的红利期展示达到了瓶颈期，加上大环境的不理想，会受到一些影响，但是我还是相信会好的，一切都会好的。

做技术既然这样了

关于最近论坛上说“前段已死”“后端当牛做马”“公司磨刀霍霍向测试”......

这个东西怎么说，我想大部分人看到这个都会被这个方向劝退，我从两个角度分析一下，上面说了，真滴卷，简历真滴多，存在过饱和；第二点，希望这个领域新人就不要来了，就是直接劝退，被让人来卷，狭义上少卷一些......

现在就是导致我也不敢给朋友做建议了，因为当他看到这些的时候，和进入工作环境真的不好，我真的怕被喷死

包括现在我的实习，大家看我的朋友圈看出工作环境不错很好，但是和工作的另一面，是不能发的呀，有时候我都笑称自己是“产业工人”（这个词是一个朋友调侃我的）

不行了，在传播焦虑思想，我该被喷死了，现在我给建议都变得很含蓄，因为时代红利期真的看不透，我也不敢说能维持多少年，而且我工作也一般，我不敢耽误大家（哈哈哈，突然想起一句话，一生清贫怎敢入繁华，二袖清风怎敢误佳人，又是emo小文案，都给我开E）

个人总结

本文就是调侃一下现在的环境啊，下面才是重点，只有干活和真话放在后面（印证一个道理：看到最后的才是真朋友才敢给真建议，我也不怕被骂）

心态方面：我们这个年纪就是迷茫的年纪，迷茫是一种正常的状态，因为作为一名成年人你真正在思考你的个人发展的状态，所以请把心放大，放轻松，你迷茫了已经比身边的人强太多了，如果真正焦虑的不能去学习了，去找个朋友聊一聊，实在不行，drink个两三瓶，好好睡一觉，第二天继续干，这摸想，这些都算个啥，没事你还有我，实在不行微我聊一聊，我永远都在，我的朋友！

工作方面：俗话说：女怕入错行，男怕娶错人！（突然发现引用没什么用，哈哈）我们可以多去实践，没错就是去实习，比如你想做前端的工作，你就可以直接去所在的城市（推荐省会去找实习）但是朋友其实实习很难，作为过来人，我能理解你，一个人在陌生的城市而且薪资很可怜，面对大城市的租房和吃饭有很多大坑，你要一一面对，但是在外面我们真要学会保护自己，而且实习生活中经济方面肯定要父母支持，所以一定要和父母好好沟通，其实你会发现我们越长大，和父母相处的时光越短。（我今年小年和十五都没在家过，害，那种心理苦的滋味很不好受）

升学方面：不是每一个都适合考研，不要盲从考研。但是这句话又是矛盾的，在我的实习生涯中，学历问题是一个很重要的问题，我们的工作类型真的不同，还是那句话，学历只是一个门槛，只要你迈入以后看的是你的个人能力。说一句悄悄话，我每天工作，最想的事情就是上学，心想老子考上研，不在干这活了，比你们都强。所以你要想考研，请此刻拿出你的笔，在纸上写下你要考研主要三个理由，你会更好的认识自己，更好选择。

好吧，今天的随想录就这摸多，只是对最近看文章有了灵感写下自己的看法，仅供参考哦！

回答问题

回应个问题：很多朋友问我为什么给这摸无私的建议，这是你经历了很多才得到的，要是分享出去，不是很亏？

（你要这摸问，的确你有卷到我的可能性，快给我爬。哈哈哈）可能是博客圈给的思想把，其实我说不上开源的思想，但是我遇到的人对我都是无私分享自己的经验和自己走过的坑，就是你懂吗，他们对我帮助都很大，他们在我眼里就是伟大的人，所以我也想要跟随他们，做追光的人！（上价值了哦，哈哈）

写在最后

最后一句话，迷茫这个东西，走着走着就清晰了，迷茫的时候，搞一点学习总是没错的。

前言

hello，大家好，我是小江。前段时间我发了一篇我在培训java感受的文章，大家都挺感兴趣的，也问了很多问题。这段时间我们刚好在写项目，昨天项目已经结束验收，现在有空在写一篇文章解答你们问的各种问题。首先说明，文章仅代表我个人观点，我个人的真实感受，而且我不会指明说出任何一个培训机构名，上篇文章大家要是看了应该知道，我全篇没有说任何一个培训机构名，我自己所在的也不会说。好了不多说，开始解答常见的问题吧。

1、行情不好了，还能入这行吗？

说实话，这个问题我也不知道怎么回答。确实现在行情越来越差了，要求越来越高了，学完找不到工作的肯定是有的，但我觉得吧，海投一直找不到工作的，要么就是技术太差，要么就是要求高了。可能前几年这技术和学历可以轻松找到1w的，现在技术要求高了点还只给6k，落差太大，就会不想去，然后发现其他的都是这样了，就抱怨起来了贩卖焦虑了。

为什么之前那些年好找工作，要求又低工资又高，只是躺在了时代的红利上。人都不是傻子，知道什么行业赚钱，必然会往这行拥入。人多了，那肯定是这样的结果。那到底现在能不能入这行呢？我个人觉得吧，你需要满足：

①学历要达到大专以上，最好是本科；

②年龄不要超过28岁，最好是26岁以下；

③自己能坚持，如果学技术要学好，能放下游戏等各种娱乐；

这是我个人看法，不知道大家有没有不同的意见，我认为一个24岁左右本科学历的刻苦学完编程，技术也可以，找个开发工作问题不大的。

2、入行是自学还是报班？

这个问题我不会提到任何一个培训机构名字，以免大家认为我是托。我来说说我的看法，我认为自制力强的、学习力OK的、时间充足的，完全可以自学的，我身边也有自学朋友。我入这行还是受我那朋友的启发和推荐的，我和我那朋友之前是在一个公司上班，不是it，干了大半年，他辞职了，说要搞编程，我没在意，觉得编程离我太远和我没有交集，又是将近半年过去了，我和他联系，他说他已经上班干开发了税后除去社保7K，我才开始和他聊这行，我也心动了。他说他自己就是自学的，大学专业搭点边，学了一点编程，但都忘了。他说他辞职后在家天天学习，除了吃饭就是学习，这点我是相信的，之前和他一个公司他也确实做事很认真。我后来不是也准备入行编程，我也想着学他自学，真正开始后，才知道人和人是有差距的，我心静不下，学一个小时就看不下去，所以我后来报了班。

这个问题，我的总结就是：

①自学可以也可行，关键看你有没有那毅力，每天能学8小时以上，并且是真正有效率的学了8小时，那你可以自学，网上资料都全，不会的可以查资料百度，或者花点小钱让别的大神帮你看看。

②自制力不行，又想入这行的，培训班也是一个选择，只是学费不便宜，成本大。培训班肯定是有用的，能学到东西，系统化都给你规划好了，资源齐全，讲的也细，也会讲很多企业实际开发需要注意的东西，练习题和项目都恰到好处的提升自己，不会不懂的可以随时问老师，最后模拟面试、指导简历什么都安排好了，确实能做到速成。不然也不会这么多培训出来的占满了这行业，使这行越来越卷。

③如果报班了，最好选个靠外那座位坐，不要坐里面，我就是坐里面靠墙，问老师问题都不好问，很坑。如果同桌是个技术很好的，那你就很幸运了，一个技术好的同桌太重要了。还有就是多问老师问题，你是花钱的，有问题就问，不要怕。

3、我在培训这两个多月后现在学的咋样？

我这一共四个阶段，我现在刚好学完第二个阶段，第一阶段基础javase，第二阶段javaweb，刚刚结束第二阶段做完项目，每个阶段结束都会有将近一个星期写项目。这次项目是小组一起开发，使用SVN工具小组一起自己分工一个写一个模块，最后整合，模拟企业开发。项目还可以，刚开始觉得很难，熟悉后就好了，难点不多，大都是crud，我感觉思路很重要，不要一上来就噼里啪啦开始写，先分析好，后面会越来越顺。等写完真的有成就感，项目确实很能锻炼自己，升华自己，查漏补缺。放几张照片看看我写的项目吧

页面显示效果截选：

后端代码截选：

前端代码截选：

结束语

我相信大家入行这个的，应该都和我一样，觉得工资还可以，工作看起来还体面。但入这行越久了解越深，就知道也有很多不容易，要付出很大的努力。如果刚踏入这行开始学的，一定要好好学，基础蛮重要，可能学着学着会迷茫，不要怀疑自己，多学多敲多思考，没有学不会的。最后送大家一句诗：路漫漫其修远兮，吾将上下而求索。

闲言碎语

今天回了趟家里，陪父母一起吃了个饭。父母照例是在唠叨，这个年纪了还不结婚，也没个稳定的工作，巴拉巴拉的一大堆。吃完饭我匆匆的就回到了我租住的地方。在现阶段，其实我对于父母所诉说的很多东西，我都是认同的。

但在我这个年纪，这个阶段，看似有很多选择，但其实我没有选择。能做的也只是多挣点钱。

在这个信息爆炸的时代，我们知道更高的地方在哪里。但当你想要再往上走一步的时候，你发现你的上限，其实从出生或从你毕业的那一刻就已经注定了。可能少部分人通过自身的努力，的确能突破壁垒达到理想的高度。但这只是小概率事件罢了。在我看来整个社会的发展，其实早就已经陷入了一种怪圈。

在我，早些年刚刚进入社会的时候。那时的想法特别简单。就想着努力工作，努力提升自身的专业素养。被老板赏识，升职加薪成为一名管理者。如果，被淘汰了那应该是自己不够优秀，不够努力，专业技能不过硬，自己为人处事不够圆滑啥的。

当内卷这个词语引爆网络的时候；当35岁被裁员成为常态的时候。再回头看我以前的那些想法那真的是一个笑话。（我觉得我可能是在为自己被淘汰找借口）

当前的状态

游戏工作室的项目，目前基本处于停滞的状态。我不敢加机器也不敢关机。有时候我都在想，是不是全中国那3-4亿的人都在搞这个？一个国外的游戏，金价直接拉成这个逼样。

汽配这边的话，只能说喝口稀饭。（我花了太多精力在游戏工作室上了）

梦想破灭咯

其实按照正常情况来说，游戏工作室最开始的阶段，我应该是能够稍微挣点钱的。我感觉我天时、地利、人和。我都占的。现在来看的话，其实我只占了人和。我自己可以编码，脚本还是从驱动层模拟键鼠，写的一套脚本。这样我都没赚钱，我擦勒。

接下来干嘛

接下来准备进厂打螺丝。（开玩笑的）
还是老老实实跟着我弟学着做生意吧。老老实实做汽配吧！在这个时代，好像有一技之长（尤其是IT）的人，好像并不能活得很好。除非，你这一技之长，特别特别长。（当下的中国不需要太多的这类专业技术人员吧。）

我感受到的大环境

我身边有蛮多的大牛。从他们的口中和我自己看到的。我感觉在IT这个领域，国内的环境太恶劣了。在前端，除开UI库，我用到的很多多的库全是老外的。为什么没有国人开源呢？因为，国人都忙着996了。我们可以在什么都不知道的情况下，通过复制粘贴，全局搜索解决大部分问题。 机械视觉、大数据分析、人工智能 等很多东西。这一切的基石很多年前就有了，为什么没人去研究他？为什么我们这波人，不断的在学习：这样、那样的框架。搭积木虽然很好玩。但创造一个积木，不应该也是一件更有挑战性的事情么？

在招聘网站还有一个特别奇怪的现象。看起来这家公司是在招人，但其实是培训机构。 看起来这家公司正儿八经是在招聘兼职，但其实只想骗你去办什么兼职卡。看起来是在招送快递，送外卖的，招聘司机的，但其实只是想套路你买车。我擦勒。这是怎样的一个恶劣的生存环境。这些个B人就不能干点，正经事？

卖菜的、拉车的、搞电商的、搞短视频、搞贷款的、卖保险的、这些个公司市值几百亿。很难看到一些靠创新，靠创造，靠产品质量，发展起来的公司。

作者：wjt
来源：juejin.cn/post/7144770465741946894

问题背景

最近在群里看到群友在讨论app保活的问题，回想之前做应用(运动类)开发时也遇到过类似的需求，于是便又来了兴趣，果断加入其中，和群友展开了激烈的讨论

不少群友的想法和我当初的想法一样，这特么保活不是看系统的心情么，系统想让谁活谁才能活，作为app开发者，根本无能为力，可真的是这样的吗？

保活方案

首先，我整理了从古到今，app开发者所使用过的以及当前还在使用的保活方式，主要思路有两个：保活和复活

保活的方案有：

• 
  

  1像素惨案

  
  


• 
  

  后台无声音乐

  
  


• 
  

  前台service

  
  


• 
  

  心跳机制

  
  


• 
  

  socket长连接

  
  


• 
  

  无障碍服务

  
  


• 
  

  ......

  
  

复活的方案有：

• 双进程守护(java层和native层)


• JobScheduler定时任务


• 推送/相互唤醒


• ......

不难看出，app开发者为了能让自己的应用多存活一会儿，可谓是绞尽脑汁，但即使这样，随着Android系统升级，尤其是进入8.0之后，系统对应用的限制越来越高，传统的保活方式已经不生效，这让Android开发者手足无措，于是乎，出现了一种比较和谐的保活方式：

• 引导用户开启手机白名单

这也是目前绝大多数应用所采用的的方式，相对于传统黑科技而言，此方式显得不那么流氓，比较容易被用户所接受。

但跟微信这样的国民级应用比起来，保活效果还是差了一大截，那么微信是怎么实现保活的呢？或者回到我们开头的问题，应用的生死真的只能靠系统调度吗？开发者能否干预控制呢？

进程调度原则

解开这个疑问之前，我们需要了解一下Android系统进程调度原则，主要介绍framework中承载四大组件的进程是如何根据组件状态而动态调节自身状态的。进程有两个比较重要的状态值：

• 
  

  oom_adj，定义在frameworks/base/services/core/java/com/android/server/am/ProcessList.java当中

  
  


• 
  

  procState，定义在frameworks/base/core/java/android/app/ActivityManager.java当中

  
  

OOM_ADJ

以Android10的源码为例，oom_adj划分为20级，取值范围[-10000,1001]，Android6.0以前的取值范围是[-17,16]

• 
  

  oom_adj值越大，优先级越低

  
  


• 
  

  oom_adj<0的进程都是系统进程。

  
  

public final class ProcessList {

    static final String TAG = TAG_WITH_CLASS_NAME ? "ProcessList" : TAG_AM;



    // The minimum time we allow between crashes, for us to consider this

    // application to be bad and stop and its services and reject broadcasts.

    static final int MIN_CRASH_INTERVAL = 60 * 1000;



    // OOM adjustments for processes in various states:



    // Uninitialized value for any major or minor adj fields

    static final int INVALID_ADJ = -10000;



    // Adjustment used in certain places where we don't know it yet.

    // (Generally this is something that is going to be cached, but we

    // don't know the exact value in the cached range to assign yet.)

    static final int UNKNOWN_ADJ = 1001;



    // This is a process only hosting activities that are not visible,

    // so it can be killed without any disruption.

    static final int CACHED_APP_MAX_ADJ = 999;

    static final int CACHED_APP_MIN_ADJ = 900;



    // This is the oom_adj level that we allow to die first. This cannot be equal to

    // CACHED_APP_MAX_ADJ unless processes are actively being assigned an oom_score_adj of

    // CACHED_APP_MAX_ADJ.

    static final int CACHED_APP_LMK_FIRST_ADJ = 950;



    // Number of levels we have available for different service connection group importance

    // levels.

    static final int CACHED_APP_IMPORTANCE_LEVELS = 5;



    // The B list of SERVICE_ADJ -- these are the old and decrepit

    // services that aren't as shiny and interesting as the ones in the A list.

    static final int SERVICE_B_ADJ = 800;



    // This is the process of the previous application that the user was in.

    // This process is kept above other things, because it is very common to

    // switch back to the previous app.  This is important both for recent

    // task switch (toggling between the two top recent apps) as well as normal

    // UI flow such as clicking on a URI in the e-mail app to view in the browser,

    // and then pressing back to return to e-mail.

    static final int PREVIOUS_APP_ADJ = 700;



    // This is a process holding the home application -- we want to try

    // avoiding killing it, even if it would normally be in the background,

    // because the user interacts with it so much.

    static final int HOME_APP_ADJ = 600;



    // This is a process holding an application service -- killing it will not

    // have much of an impact as far as the user is concerned.

    static final int SERVICE_ADJ = 500;



    // This is a process with a heavy-weight application.  It is in the

    // background, but we want to try to avoid killing it.  Value set in

    // system/rootdir/init.rc on startup.

    static final int HEAVY_WEIGHT_APP_ADJ = 400;



    // This is a process currently hosting a backup operation.  Killing it

    // is not entirely fatal but is generally a bad idea.

    static final int BACKUP_APP_ADJ = 300;



    // This is a process bound by the system (or other app) that's more important than services but

    // not so perceptible that it affects the user immediately if killed.

    static final int PERCEPTIBLE_LOW_APP_ADJ = 250;



    // This is a process only hosting components that are perceptible to the

    // user, and we really want to avoid killing them, but they are not

    // immediately visible. An example is background music playback.

    static final int PERCEPTIBLE_APP_ADJ = 200;



    // This is a process only hosting activities that are visible to the

    // user, so we'd prefer they don't disappear.

    static final int VISIBLE_APP_ADJ = 100;

    static final int VISIBLE_APP_LAYER_MAX = PERCEPTIBLE_APP_ADJ - VISIBLE_APP_ADJ - 1;



    // This is a process that was recently TOP and moved to FGS. Continue to treat it almost

    // like a foreground app for a while.

    // @see TOP_TO_FGS_GRACE_PERIOD

    static final int PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ = 50;



    // This is the process running the current foreground app.  We'd really

    // rather not kill it!

    static final int FOREGROUND_APP_ADJ = 0;



    // This is a process that the system or a persistent process has bound to,

    // and indicated it is important.

    static final int PERSISTENT_SERVICE_ADJ = -700;



    // This is a system persistent process, such as telephony.  Definitely

    // don't want to kill it, but doing so is not completely fatal.

    static final int PERSISTENT_PROC_ADJ = -800;



    // The system process runs at the default adjustment.

    static final int SYSTEM_ADJ = -900;



    // Special code for native processes that are not being managed by the system (so

    // don't have an oom adj assigned by the system).

    static final int NATIVE_ADJ = -1000;



    // Memory pages are 4K.

    static final int PAGE_SIZE = 4 * 1024;

    

    //省略部分代码

}

可以通过cat /proc/进程id/oom_score_adj查看目标进程的oom_adj值，例如我们查看电话的adj

值为935，处于不可见进程的范围内，当我启动电话app，再次查看

此时adj值为0，也就是正在与用户交互的进程

ProcessState

process_state划分为23类，取值范围为[-1,21]

@SystemService(Context.ACTIVITY_SERVICE)

public class ActivityManager {

    //省略部分代码

    /** @hide Not a real process state. */

    public static final int PROCESS_STATE_UNKNOWN = -1;



    /** @hide Process is a persistent system process. */

    public static final int PROCESS_STATE_PERSISTENT = 0;



    /** @hide Process is a persistent system process and is doing UI. */

    public static final int PROCESS_STATE_PERSISTENT_UI = 1;



    /** @hide Process is hosting the current top activities.  Note that this covers

     * all activities that are visible to the user. */

    @UnsupportedAppUsage

    public static final int PROCESS_STATE_TOP = 2;



    /** @hide Process is hosting a foreground service with location type. */

    public static final int PROCESS_STATE_FOREGROUND_SERVICE_LOCATION = 3;



    /** @hide Process is bound to a TOP app. This is ranked below SERVICE_LOCATION so that

     * it doesn't get the capability of location access while-in-use. */

    public static final int PROCESS_STATE_BOUND_TOP = 4;



    /** @hide Process is hosting a foreground service. */

    @UnsupportedAppUsage

    public static final int PROCESS_STATE_FOREGROUND_SERVICE = 5;



    /** @hide Process is hosting a foreground service due to a system binding. */

    @UnsupportedAppUsage

    public static final int PROCESS_STATE_BOUND_FOREGROUND_SERVICE = 6;



    /** @hide Process is important to the user, and something they are aware of. */

    public static final int PROCESS_STATE_IMPORTANT_FOREGROUND = 7;



    /** @hide Process is important to the user, but not something they are aware of. */

    @UnsupportedAppUsage

    public static final int PROCESS_STATE_IMPORTANT_BACKGROUND = 8;



    /** @hide Process is in the background transient so we will try to keep running. */

    public static final int PROCESS_STATE_TRANSIENT_BACKGROUND = 9;



    /** @hide Process is in the background running a backup/restore operation. */

    public static final int PROCESS_STATE_BACKUP = 10;



    /** @hide Process is in the background running a service.  Unlike oom_adj, this level

     * is used for both the normal running in background state and the executing

     * operations state. */

    @UnsupportedAppUsage

    public static final int PROCESS_STATE_SERVICE = 11;



    /** @hide Process is in the background running a receiver.   Note that from the

     * perspective of oom_adj, receivers run at a higher foreground level, but for our

     * prioritization here that is not necessary and putting them below services means

     * many fewer changes in some process states as they receive broadcasts. */

    @UnsupportedAppUsage

    public static final int PROCESS_STATE_RECEIVER = 12;



    /** @hide Same as {@link #PROCESS_STATE_TOP} but while device is sleeping. */

    public static final int PROCESS_STATE_TOP_SLEEPING = 13;



    /** @hide Process is in the background, but it can't restore its state so we want

     * to try to avoid killing it. */

    public static final int PROCESS_STATE_HEAVY_WEIGHT = 14;



    /** @hide Process is in the background but hosts the home activity. */

    @UnsupportedAppUsage

    public static final int PROCESS_STATE_HOME = 15;



    /** @hide Process is in the background but hosts the last shown activity. */

    public static final int PROCESS_STATE_LAST_ACTIVITY = 16;



    /** @hide Process is being cached for later use and contains activities. */

    @UnsupportedAppUsage

    public static final int PROCESS_STATE_CACHED_ACTIVITY = 17;



    /** @hide Process is being cached for later use and is a client of another cached

     * process that contains activities. */

    public static final int PROCESS_STATE_CACHED_ACTIVITY_CLIENT = 18;



    /** @hide Process is being cached for later use and has an activity that corresponds

     * to an existing recent task. */

    public static final int PROCESS_STATE_CACHED_RECENT = 19;



    /** @hide Process is being cached for later use and is empty. */

    public static final int PROCESS_STATE_CACHED_EMPTY = 20;



    /** @hide Process does not exist. */

    public static final int PROCESS_STATE_NONEXISTENT = 21;

    //省略部分代码

}

进程调度算法

在frameworks/base/services/core/java/com/android/server/am/OomAdjuster.java中，有三个核心方法用于计算和更新进程的oom_adj值

• updateOomAdjLocked()：更新adj，当目标进程为空，或者被杀则返回false，否则返回true。


• computeOomAdjLocked()：计算adj，计算成功返回true，否则返回false。


• applyOomAdjLocked()：应用adj，当需要杀掉目标进程则返回false，否则返回true。

adj更新时机

也就是updateOomAdjLocked()被调用的时机。通俗的说，只要四大组件被创建或者状态发生变化，或者当前进程绑定了其他进程，都会触发adj更新，具体可在源码中查看此方法被调用的地方，比较多，这里就不列举了

adj的计算过程

computeOomAdjLocked()计算过程相当复杂，将近1000行代码，这里就不贴了，有兴趣可自行查看，总体思路就是根据当前进程的状态，设置对应的adj值，因为状态值很多，所以会有很多个if来判断每个状态是否符合，最终计算出当前进程属于哪种状态。

adj的应用

计算得出的adj值将发送给lowmemorykiller(简称lmk)，由lmk来决定进程的生死，不同的厂商，lmk的算法略有不同，下面是源码中对lmk的介绍

/* drivers/misc/lowmemorykiller.c

 *

 * The lowmemorykiller driver lets user-space specify a set of memory thresholds

 * where processes with a range of oom_score_adj values will get killed. Specify

 * the minimum oom_score_adj values in

 * /sys/module/lowmemorykiller/parameters/adj and the number of free pages in

 * /sys/module/lowmemorykiller/parameters/minfree. Both files take a comma

 * separated list of numbers in ascending order.

 *

 * For example, write "0,8" to /sys/module/lowmemorykiller/parameters/adj and

 * "1024,4096" to /sys/module/lowmemorykiller/parameters/minfree to kill

 * processes with a oom_score_adj value of 8 or higher when the free memory

 * drops below 4096 pages and kill processes with a oom_score_adj value of 0 or

 * higher when the free memory drops below 1024 pages.

 *

 * The driver considers memory used for caches to be free, but if a large

 * percentage of the cached memory is locked this can be very inaccurate

 * and processes may not get killed until the normal oom killer is triggered.

 *

 * Copyright (C) 2007-2008 Google, Inc.

 *

 * This software is licensed under the terms of the GNU General Public

 * License version 2, as published by the Free Software Foundation, and

 * may be copied, distributed, and modified under those terms.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 */

保活核心思路

根据上面的Android进程调度原则得知，我们需要尽可能降低app进程的adj值，从而减少被lmk杀掉的可能性，而我们传统的保活方式最终目的也是降低adj值。而根据adj等级分类可以看出，通过应用层的方式最多能将adj降到100~200之间，我分别测试了微信、支付宝、酷狗音乐，启动后返回桌面并息屏，测试结果如下

微信测试结果：

微信创建了两个进程，查看这两个进程的adj值均为100，对应为adj等级表中的VISIBLE_APP_ADJ，此结果为测试机上微信未登录状态测试结果，当换成我的小米8测试后发现，登录状态下的微信有三个进程在运行

后查阅资料得知，进程名为com.tencent.soter.soterserver的进程是微信指纹支付，此进程的adj值居然为-800，上面我们说过，adj小于0的进程为系统进程，那么微信是如何做到创建一个系统进程的，我和我的小伙伴都惊呆了o.o，为此，我对比了一下支付宝的测试结果

支付宝测试结果：

支付宝创建了六个进程，查看这六个进程的adj值，除了一个为915，其余均为0，怎么肥事，0就意味着正在与用户交互的前台进程啊，我的世界要崩塌了，只有一种可能，支付宝通过未知的黑科技降低了adj值。

酷狗测试结果：

酷狗创建了两个进程，查看这两个进程的adj值分别为700、200，对应为adj等级表中的PREVIOUS_APP_ADJ和PERCEPTIBLE_APP_ADJ，还好，这个在意料之中。

测试思考

通过上面三个app的测试结果可以看出，微信和支付宝一定是使用了某种保活手段，让自身的adj降到最低，尤其是微信，居然可以创建系统进程，简直太逆天了，这是应用层绝对做不到的，一定是在native层完成的，但具体什么黑科技就不得而知了，毕竟反编译技术不是我的强项。

正当我郁郁寡欢之时，我想起了前两天看过的一篇文章《当 App 有了系统权限，真的可以为所欲为？》，文章讲述了第三方App如何利用CVE漏洞获取到系统权限，然后神不知鬼不觉的干一些匪夷所思的事儿，这让我茅塞顿开，或许这些大厂的app就是利用了系统漏洞来保活的，不然真的就说不通了，既然都能获取到系统权限了，那创建个系统进程不是分分钟的事儿吗，还需要啥厂商白名单。

总结

进程保活是一把双刃剑，增加app存活时间的同时牺牲的是用户手机的电量，内存，cpu等资源，甚至还有用户的忍耐度，作为开发者一定要合理取舍，不要为了保活而保活，即使需要保活，也尽量采用白色保活手段，别让用户手机变板砖，然后再来哭爹骂娘。

参考资料：

探讨Android6.0及以上系统APP常驻内存(保活)实现-争宠篇

探讨Android6.0及以上系统APP常驻内存(保活)实现-复活篇

探讨一种新型的双进程守护应用保活

史上最强Android保活思路：深入剖析腾讯TIM的进程永生技术

当 App 有了系统权限，真的可以为所欲为？

「 深蓝洞察 」2022 年度最“不可赦”漏洞

需求

我们要做一个前端需求：需要一个输入框，支持 KQL 语法，支持智能匹配，前提条件纯前端实现。

该功能详见 kibana es7版本。有条件的可以去使用一下，感受一番。

需求分析

使用了一下该功能，感觉还是挺复杂的。不好实现啊，我，我，我。。。

不过因为 kibana 是开源的，我就去 github 上看了一下源码。

• 首先人家是 React 版本，我的项目是 Vue 版本，我不能行使拿来主义。


• 一个 input 框的核心代码写了一千多行，不包括一些工具函数，公共组件之类。

方案

1. 
   

   我先研究源码，再把研究好的源码转成 vue 版本输出？

   
   

   该方案短时间内看不到效果，需要好好梳理其源码。是一个 0 或者 1 的问题，如果研究好了并实现转化出来，那就是 1，如果期间遇到问题阻塞了，那就是短时间看不到产出效果。不敢冒险。

   
   


2. 
   

   创建一个 React 项目，把相关的这部分代码拆分出来，以微前端的方式内嵌到我的项目中？

   
   

   不知道在拆分代码和组装代码的过程中会遇到什么问题？未知，不敢冒险去耽误时间，也是一个 0 或者 1 的问题。

   
   


3. 
   

   自己研究 KQL 语法，自己摸索规则，自己实现其逻辑？

   
   

   由于项目排期紧张，不敢太过冒险，就选择了自研。起码 ld 能看到进度。😁

   
   

我最后选择的是方案3：自研。但是如果有时间，我更倾向的想去尝试方案1 和方案2。

针对自研方案，我们就开干吧！撸起袖子加油干！😄

准备

首先，我们需要一些准备工作，我需要了解 KQL 语法是什么？然后使用它，研究其规则，梳理其逻辑。

Kibana 查询语言 (Kibana Query Language、简称 KQL) 是一种使用自由文本搜索或基于字段的搜索过滤 Elasticsearch 数据的简单语法。 KQL 仅用于过滤数据，并没有对数据进行排序或聚合的作用。

KQL 能够在您键入时建议字段名称、值和运算符。 建议的性能由 Kibana 设置控制。

KQL 能够查询嵌套字段和脚本字段。 KQL 不支持正则表达式或使用模糊术语进行搜索。

更为详细的可以看官方文档 Kibana Query Language

• key method value 标准单个语句


• key method value OR/AND key method value OR/AND key method value .... 标准多个语句


• key OR/AND key OR/AND key OR/AND key method value .... 不标准多个语句


• ......

Tips：key(字段名称)、method(运算符)、value(值)

实现

textarea

• 由于用户可以输入多行文本信息，所以需要 textarea。type="textarea"


• 为了用户能清楚看到输入内容，以及input 的美观，初始行数 :rows="2"


• 因为我们能支持关键字和KQL两种情况，所以 placeholder="KQL/关键字"


• 获取焦点需要打开下拉展示框 @focus="dropStatus = true"


• 失去焦点且没有操作下拉选项则关闭下拉框 @blur="changeDrop"


• 由于下拉框的位置需要跟着 textarea 高度变化，所以 v-resizeHeight="inputResizeHeight"

<el-input

    v-resizeHeight="inputResizeHeight"

    id="searchInputID"

    ref="searchInputRef"

    v-model="input"

    :rows="2"

    type="textarea"

    placeholder="KQL/关键字"

    class="searchInput"

    @blur="changeDrop"

    @focus="dropStatus = true"

>

</el-input>

changeDrop 需要判断用户是否正在操作下拉框内容，如果是，就不要关闭。这块你会怎么实现呢？可以先思考自己的实现方式，再看下边是我个人的实现方式。

其实理论就是给下拉框操作的时候增加标记，在失去焦点要关闭的时候，判断是否有这个标记，如果有，就不要关闭，否则就关闭。但这个标记又不能影响真正的失焦状态下关闭动作。

我想到的就是定时器，定时器能增加一个变量，同时还能自动销毁。具体的实现方式：

// 不关闭下拉框标记

noCloseInput() {

  this.$refs.searchInputRef.focus()

  if (this.timer) clearInterval(this.timer)

  let time = 500

  this.timer = setInterval(() => {

    time -= 100

    if (time === 0) {

      clearInterval(this.timer)

      this.timer = null

    }

  }, 100)

}



// 失焦操作

changeDrop() {

  setTimeout(() => {

    if (!this.timer) this.dropStatus = false

  }, 200)

}

这么做需要有以下几点注意：

• 失焦操作因为需要切换到下拉框有一定延迟需要定时器，而定时器的时间必须小于标记里边的定时器时间


• 定时器 this.timer = setInterval() 中 this.timer 是定时器的 id


• clearInterval(this.timer) 只会清除定时器，不会清空 this.timer

v-resizeHeight="inputResizeHeight" 这个是我写的一个自定义指令来检测元素的高度变化的，不知道你有什么好的方法吗？有的话请请共享一下，😍

const resizeHeight = {

  // 绑定时调用

  bind(el, binding) {

    let height = ''

    function isResize() {

      // 可根据需求，调整内部代码，利用 binding.value 返回即可

      const style = document.defaultView.getComputedStyle(el)

      if (height !== style.height) {

        // 此处关键代码，通过此处代码将数据进行返回，从而做到自适应

        binding.value({ height: style.height })

      }

      height = style.height

    }

    // 设置调用函数的延时，间隔过短会消耗过多资源

    el.__vueSetInterval__ = setInterval(isResize, 100)

  },

  unbind(el) {

    clearInterval(el.__vueSetInterval__)

  }

}



export default resizeHeight

下拉面板

下拉框是左右布局，右侧是检索语法说明的静态文案，可忽略。左侧是语句提示内容。

语句提示内容经过研究其实有四种：

key(字段名称)、method(运算符)、value(值)、connectionSymbol(连接符)

由于可能会有多个语句，其实我们是只对当前语句进行提示的，所以我们只分析当前语句的情况。

// 当前语句详情

{

    cur_fields: '', // 当前 key

    cur_methods: '', // 当前 method

    cur_values: '', // 当前 value

    cur_input: '' // 当前用户输入内容，可模糊匹配检索

}

有四部分，肯定就是需要在符合条件的情况下分别展示对应的 options 面板内容。

那判断条件就是如下图，其中后续需要注意的就是这几个判断条件的值赋值场景要准确。

语法分析器

想处理输入内容，做一个语法分析器，首先需要去监听用户的输入，那么就用 vue 提供的 watch。

watch: {

    input: debounce(function(newValue, oldValue) {

      if (newValue !== oldValue) this.dealInputShow(newValue)

    }, 500)

}

基本大概思路如下：

其中获取输入框的光标位置的方法如下：

const selectionStart = this.$refs.searchInputRef.$el.children[0].selectionStart

修改完了之后，光标会自动跑的最后，这样有点违反用户操作逻辑，所以需要设置一下光标位置：

if (this.endValue) {

    this.$nextTick(() => {

      const dom = this.$refs.searchInputRef.$el.children[0]

      dom.setSelectionRange(this.input.length, this.input.length)

      this.input += this.endValue

    })

}

还有面板里边有四项内容，那每一项内容选择都可以通过鼠标点击选择，点击选择后，就需要按照规则处理一下，进行最终的字符串 this.input 拼接，得到最终结果。

// 当前 key 点击选择

curFieldClick(str) {},



// 当前 method 点击选择

curMethodClick(str) {},



// 当前 value 点击选择

curValueClick(str) {},



// 当前 链接符 点击选择

curConnectClick(str) {},

这部分需要注意的就是点击面板 input 会失去焦点，就加上前边说到的 noCloseInput() 不关闭下拉面板标记。

键盘快捷操作

必备的目前就 3 个事件 enter、up、down，其他算是锦上添花，由于排期紧张，暂时只做了必备的 3 个 事件：

<el-input

    v-resizeHeight="inputResizeHeight"

    id="searchInputID"

    ref="searchInputRef"

    v-model="input"

    :rows="2"

    type="textarea"

    placeholder="KQL/关键字"

    class="searchInput"

    @blur="changeDrop"

    @focus="dropStatus = true"

    @keydown.enter.native.capture.prevent="getSearchEnter($event)"

    @keydown.up.native.capture.prevent="getSearchUp($event)"

    @keydown.down.native.capture.prevent="getSearchDown($event)"

>

</el-input>

那么，我们的这几个键盘事件都需要怎么处理呢？？接下来就直接上代码简单分析一下：

// 键盘 enter 事件，有两种情况

// 一种就是 选择内容，第二种就是 相当于回车事件直接触发接口

getSearchEnter(event) {

  event.preventDefault()

  

  // 当前下拉面板的展示的 options

  const suggestions = this.get_suggestions()

  

  // 满足可以选的条件

  if (this.dropStatus && this.dropIndex !== null && suggestions[this.dropIndex]) {

      // 光标之后是否有内容，有就需要截取处理

      // ......

      

      // 当前项是否是手动输入的，需要做截取处理

      // .......

    

      // 拼接 enter 键选择的选项

      this.input += suggestions[this.dropIndex] + ' '

      

      // 光标之后是否有内容，就需要设置光标在当前操作位置，并拼接之前截取掉的光标后的内容

      // .......

      

      // 设置当前语法区域的各个当前项 cur_fields、cur_methods、cur_values

      // ......

      

      // 恢复键盘 up、down 选择初始值

      this.dropIndex = 0

  } else {

      // 不满足选的条件，就关闭选择面板，并触发检索查询接口

      this.dropStatus = false

      this.$emit('getSearchData', 2)

  }

},



// 键盘 up 事件

getSearchUp(event) {

  event.preventDefault()

  

  // 满足上移，就做 dropIndex 减法

  if (this.dropStatus && this.dropIndex !== null) {

    this.decrementIndex(this.dropIndex)

  }

},



// 键盘 down 事件

getSearchDown(event) {

  event.preventDefault()

  

  // 满足下移，就做 dropIndex 加法

  if (this.dropStatus && this.dropIndex !== null) {

    this.incrementIndex(this.dropIndex)

  }

},



// 加法，注意边界问题

incrementIndex(currentIndex) {

  let nextIndex = currentIndex + 1

  const suggestions = this.get_suggestions()

  // 到最后边，重置到第一个，形成循环

  if (currentIndex === null || nextIndex >= suggestions.length) {

    nextIndex = 0

  }

  this.dropIndex = nextIndex

  

  // 被选择的选项如果不在可视范围之内，需要滚动到可视区

  this.$nextTick(() => this.scrollToOption())

},



// 减法，注意边界问题

decrementIndex(currentIndex) {

  const previousIndex = currentIndex - 1

  const suggestions = this.get_suggestions()

  // 到最前边，重置到最后，形成循环

  if (previousIndex < 0) {

    this.dropIndex = suggestions.length - 1

  } else {

    this.dropIndex = previousIndex

  }

  

  // 被选择的选项如果不在可视范围之内，需要滚动到可视区

  this.$nextTick(() => this.scrollToOption())

},

键盘事件的核心逻辑上述基本说清楚了，那么其中需要注意的一个点，那就是被选择的选项如果不在可视范围之内，需要滚动到可视区，这样可提高用户体验。那这块到底怎么做呢？其实实现起来还挺有意思的。

import scrollIntoView from './scroll-into-view'



// 滚动 optiosns 区域，保持在可视区域

scrollToOption() {

  if (this.dropStatus === true) {

    const target = document.getElementsByClassName('drop-active')[0]

    const menu = document.getElementsByClassName('search-drop__left')[0]

    scrollIntoView(menu, target)

  }

},

scroll-into-view.js 内容如下：

export default function scrollIntoView(container, selected) {

  // 如果当前激活 active 元素不存在

  if (!selected) {

    container.scrollTop = 0

    return

  }



  const offsetParents = []

  let pointer = selected.offsetParent

  while (pointer && container !== pointer && container.contains(pointer)) {

    offsetParents.push(pointer)

    pointer = pointer.offsetParent

  }

  

  const top = selected.offsetTop + offsetParents.reduce((prev, curr) => (prev + curr.offsetTop), 0)

  const bottom = top + selected.offsetHeight

  const viewRectTop = container.scrollTop

  const viewRectBottom = viewRectTop + container.clientHeight



  if (top < viewRectTop) {

    container.scrollTop = top

  } else if (bottom > viewRectBottom) {

    container.scrollTop = bottom - container.clientHeight

  }

}

针对上述内容几个技术点做出简单解释：

offsetParent：就是距离该子元素最近的进行过定位的父元素，如果其父元素中不存在定位则 offsetParent为：body元素。

offsetParent 根据定义分别存在以下几种情况：

1. 元素自身有 fixed 定位，父元素不存在定位，则 offsetParent 的结果为 null（firefox 中为：body，其他浏览器返回为 null）


2. 元素自身无 fixed 定位，且父元素也不存在定位，offsetParent 为 <body> 元素


3. 元素自身无 fixed 定位，且父元素存在定位，offsetParent 为离自身最近且经过定位的父元素


4. <body>元素的 offsetParent 是 null

offsetTop：元素到 offsetParent 顶部的距离

offsetHeight：是一个只读属性，它返回该元素的像素高度，高度包含内边距（padding）和边框（border），不包含外边距（margin），是一个整数，单位是像素 px。

通常，元素的 offsetHeight 是一种元素 CSS 高度的衡量标准，包括元素的边框、内边距和元素的水平滚动条（如果存在且渲染的话），不包含 :before或 :after 等伪类元素的高度。

scrollTop：可以获取或设置一个元素的内容垂直滚动的像素数。

一个元素的 scrollTop 值是这个元素的内容顶部（卷起来的）到它的视口可见内容（的顶部）的距离的度量。当一个元素的内容没有产生垂直方向的滚动条，那么它的 scrollTop 值为0。

clientHeight：是一个只读属性，它返回该元素的像素高度，高度包含内边距（padding），不包含边框（border），外边距（margin）和滚动条，是一个整数，单位是像素 px。

clientHeight 可以通过 CSS height + CSS padding - 水平滚动条高度 (如果存在)来计算。

最全各个属性相关图如下：

效果

效果怎么说呢，也算顺利上线生产环境了，在此截图几张，给大家看看效果。

小结

做这个需求，最难的点是要求自己去研究 KQL 的语法规则，以及使用方式，然后总结规则，写出自己的词法分析器。

其中有什么技术难点吗？似乎并没有，都是各种判断条件，最简单的 if-else。

所以想告诉大家的是，不要一心只钻研技术，在做业务的时候也需要好好梳理业务，做一个懂业务的技术人。业务和技术互相成就！

最后，如果感到本文还可以，请给予支持！来个点赞、评论、收藏三连，万分感谢！😄🙏

最近ChatGPT的热度非常高，OPEN AI也是在不久前刚刚宣布开放ChatGPT商用API。

写这篇文章的契机在于前几天一位群友分享了一个日本程序员基于ChatGPT开发了一个AI佛：HOTOKE AI

例如当用户提问“我不知道生存的目的”，AI佛会做出如下回答：

感觉还是挺有意思的，他会从佛教及心理学的角度去给你分析与解释。

但作为一名程序员，我们肯定对背后的原理更感兴趣，于是我又问了他和GPT有什么区别：

这个回答还是有点出乎我的意料的，于是我更感兴趣了，直接网上找起了教程，也研读了一下OPEN API的文档。所以这篇文章更像是一个学习笔记，也希望能吸引到一些同样感兴趣的小伙伴。

文章最后我们会开发一个基于ChatGPT的AI孙子（就是培养出高启强的那个孙子）

ChatGPT

相信大家能点进来的都知道ChatGPT是啥, 这part就过了吧。

OPEN AI API

Examples

OPEN AI API提供了很多种模型供用户选择，在官网上也提供了很多示例，包括各种各样的模型及其生成的结果。
这是官网示例的地址：platform.openai.com/examples

我们以Q&A为例：

可以看到它用的模型是text-davinci-003，然后他说"我是一个高度智能的问答机器人。如果你问的问题有确切答案，我就会给出答案，如果你问的问题是在搞我或者没有明确答案，我会回答不知道"。然后下面就是一些示例。

提示工程（Prompt Engineering）

我们还可以点右上角的Open in Playground来自己尝试下

可以看到右侧侧边栏有许多参数可以调节，根据调节的参数不同，生成的答案也会有所区别。参数就不细说了，感兴趣的同学可以自己去看，当你鼠标移到那个参数上时，会有对应的解释框弹出来解释这个参数的作用。

这里简单演示了如何去通过提示，引导AI之后回答出你所想要的答案，所以提示（Prompt）就变的尤为重要。事实上，现在提示工程师（Prompt Engineer）已经成为一个炙手可热的岗位，他们的主要任务就是引导AI去学习及训练。
官方文档也用了相当大的篇幅去介绍如何去提示：platform.openai.com/docs/guides…

这里就简单翻译一下开头：

概述

我们的模型可以做任何事情，从生成原创故事到执行复杂的文本分析。因为它们可以做这么多事情，所以你必须明确描述你想要什么。告诉他该怎么做，而不只是简单陈述，这就是一个好提示的秘籍。

创作提示有三个基本准则。

• 
  

  展示和讲述。通过指示、例子或两者的结合，明确你想要什么。如果你想让模型按字母顺序排列一个项目清单，或按情绪对一个段落进行分类，就向它展示你想要的东西。

  
  


• 
  

  提供高质量的数据。如果你试图建立一个分类器或让模型遵循一个模式，确保有足够的例子。确保校对你的例子 —— 模型足够聪明，它可以识别拼写错误，并且告诉你，但它也可能认为这是你故意写错的，这都会影响他的回答。

  
  


• 
  

  检查你的设置。temperature和top_p参数控制了模型在产生响应方面的确定性。如果你要求它产生一个只有一个正确答案的响应，那么你就想把这些设置得低一些。如果你在寻找更多不同的反应，那么你可能想把它们设置得更高。人们使用这些设置的第一大错误是，假定它们是对"聪明"或"创造性"控制。

  
  

到这里大家应该也就知道了，那个AI佛就是通过程序员选择合适的模型，以及对他加以训练，比如告诉他当用户提问时，他需要从佛教及心理学的角度去回答用户的问题。

模型（Models）

模型可以说是非常重要的一部分，也是Open AI的核心。

ChatGPT用的就是GPT-3.5模型，他主要是面向大众，所以被训练的更加安全，不会输出一些出格的内容。

在GPT-3.5中又包含了几个子模型：

目前官方推荐的是gpt-3.5-turbo，称此模型能生成最好的结果，并且只需要text-davinci-003十分之一的算力。

价格

目前gpt-3.5-turbo的价格是每一千个token需要0.002🔪。所谓token可以理解为他处理的单词数，1000个token大概可以生成750个单词。

AI孙子

接下来我们尝试简单写一个AI孙子。

首先当然是创建一个项目，我用的就是简单的create-react-app去创建一个react应用：
npx create-react-app ai-sunzi

使用express写一个简单的服务端：

重写App.js，我们只需要一个textarea和一个提交按钮

访问http://localhost:3000 确保可以访问服务端，返回“Hello World！”：

接下来我们需要去Open AI官方文档中查看如何使用它的API，文档中有一个例子，如何在nodejs中引入包：

我们把他复制到我们代码中，有些地方还是需要改动一下，比如包的引入不能直接使用import。再将API Key复制到configuration中（API Key需要注册并登录OpenAI，可以免费领取）：

然后我们再查看文档中Completion部分：

将其复制到我们代码中并测试：

此处我将max_token修改为100，因为中文字符所占字节数长一些。随后将prompt参数改为“无论用户输入什么，只需回答这是一个测试”
再次访问localhost:3000可以看到确实可以返回“这是一个测试”。

说明我们的后端已经从OPEN AI得到了返回的数据。

再接下来就简单了，我们只需要把前端和后端连上，再修改prompt，让这个AI表现的像孙子：

将textarea中的message传入至prompt参数中，再从OPEN AI得到返回的答案，就大功告成了。
以下为一些测试：

Reference: http://www.youtube.com/watch?v=bB7…

李彦宏缓缓走入会场。

亮了，他亮了。

文心一言具有五大功能：

1. 文学创作（写诗歌，写小说）


2. 商业文案创作（给公司起名，写宣传语）


3. 数理逻辑推算（做题）


4. 中文理解（理解华夏文化）


5. 多模态生成（文字、图片、音频、视频）

其中，前三个功能ChatGPT都有，我感觉百度搞不过它。

比如：

再比如：

但是，后两个功能是ChatGPT不具备的。

首先说中文理解。

老李说文心一言的重点是用中文训练。AI模型能深入中国文化到什么程度呢？

拿洛阳纸贵举例子，他连着问了模型几个问题。

尤其是第二个问题，洛阳纸贵，那么当时到底多少钱呢？

模型可以结合唐朝时期的物价以及相关文献记载，给出来答案：当时洛阳的纸由八百文涨到两三千文。

甚至让它以“洛阳纸贵”写一篇藏头诗，模型也写了出来。虽然比不上我写的，但是起码它藏头。

我们再来看看ChatGPT对于中文的理解是什么效果。

问ChatGPT洛阳纸贵什么意思，然后再问洛阳的纸多少钱。

很明显，它对第二个问题回答的不是很好。它没有清楚的理解我的问题，反而还指出了我的错误。它没有说具体多少钱，它说这不是贵的问题，只是一种现象。

而对于藏头诗，ChatGPT也是无能为力。

它可能知道什么是诗，但并不知道什么是藏头诗。因为，这就有点深入中国文化了。

但是，我相信，你让它解释藏头诗，它凭借搜索引擎是能找到并打印出来的。但是，你让它写，很遗憾。

ChatGPT没有的，文心一言有的，第二个功能就是多模态。

多模态是AI的一个专业名词，比如文本是一种模态，图片是一种模态。多模态就是多种形式。

我们知道，ChatGPT是一个文本单模态的语言模型。

我李哥演示了一个从文字到图片到语音再到视频的例子。

海报图片设计出来了。

然后再用四川方言讲出来。

最后生成视频。

其实，后面的几种模态并非是首发，只是一种整合。

语音合成是老技术了，这不用说。

图文转视频的功能，去年开始，在各大自媒体平台也纷纷上线了。包括头条号在内，写完一篇文章，可以自动生成视频。

但是，大多都是素材库的标签拼凑。生成的效果较差，有时候百度自己生成的，自己都无法通过审核。

但是，让ChatGPT干这些，它除了文本模态之外，它都会回复你它只是一个语言模型。

讲完了五大功能。后面说了三大产业机会。

中间休息，亮出了很多AIGC的案例。

休息完了，百度首席技术官，王海峰老师对文心一言的技术做了简单解读。

其实主要还是说了利用飞桨开源平台实现的。

然后介绍了文心一言模型的功能组成。

最后说，飞桨平台好！

结束前，官方平台宣布，企业用户可以申请内测。

方法在图片里面了，搜索关键词“百度智能云”填写表单就可以。

有个邀请体验说明是这样的：

我们期待与您尽快展开合作，但由于初期名额有限，目前暂不能满足所有人的申请，因此请您仔细填写需求，我们会结合业务场景、访问量等级等信息综合评估，并在您通过评估后尽快给您反馈，本次邀测仅面向企业用户，谢谢您的理解。

最后，我感觉李哥和王老师在讲的时候，声音有些发颤。可能理工男面对大型发布会都有怯场的情况，也可能他们对平台不自信。

整个发布会，都是在播放视频，并没有现场实际操作平台。这也是为了达到最好的发布效果。李哥说，实际操作的话会比较慢，大家需要等。

我感觉，抛去技术不谈，文心一言在中国肯定是有市场的。

因为，我在直播间发布了很多信息，都没有显示。但是，当我和大家万众一心时，我的评论赫然出现在字幕上。

这一点，ChatGPT无论如何是无法做到的！

我们不黑不吹，后续的情况，只能等待用户的反馈了。

什么是ChatGPT

官方解释：ChatGPT是一个智能聊天机器人，来自于OpenAI，它能够使用人工智能技术进行对话，并回答用户提出的问题和请求。它由GPT（Generative Pre-trained Transformer）算法支持，可以模拟人类对话和回答各种问题，包括日常生活、科技、娱乐、健康、财经等领域。ChatGPT可以通过各种渠道进行访问，如网站、社交媒体或移动应用程序。

ChatGPT优势

ChatGPT有以下几个优势：

1. 可以模拟真人对话：ChatGPT使用GPT算法，可以生成自然语言，使得对话非常流畅和自然，就好像在与一个真人交流一样。


2. 能够自我学习：ChatGPT使用机器学习技术，可以通过不断的学习来提高自己的答案和回复质量。


3. 24小时在线：ChatGPT可以在任何时间回答用户的问题，不需要等待人类客服的接待时间。


4. 处理大量请求：ChatGPT可以处理大量请求，在同一时间内可以同时与多个用户进行对话。


5. 提高客户满意度：ChatGPT可以回答用户的问题并提供有用的信息，这可以提高用户的满意度和忠诚度。


6. 提高效率：ChatGPT可以快速响应和解答用户问题，减少人工客服的工作量和时间。

接下来，我们来聊一聊它对前端开发产生了什么样的影响

体验流程

我们需要先拥有一个相应的账户才能体验，这里我直接放上体验流程的链接:sms-activate.org，按照本流程对于没有接触过ChatGPT的童鞋们可以体验一下，这里我就不展开详细解释了。tips：电脑需要科学上网哦~~

辅助开发

重点来了，我们需要先分析我们在日常开发中哪些方面可以用到它，根据开发的流程我们可以从以下几点分析：

1. 
   

   需求阶段：我们做业务开发的前提是以需求为准，对于需求而言，实现的方式多种多样，我们应该分析一下，应该用什么技术去实现，具体对应到哪种框架、第三方依赖库等等。

   
   


2. 
   

   编码阶段：这个阶段是业务逻辑的实现阶段，要完成需求中的功能。举个🌰：做登录注册模块，输入账号和密码时一般都需要校验格式（复杂情况），这时正则表达式不失为一个好的办法，此时我们的主角就该登场了~~ 话不多说，直接上图：

   
   

   

   
   经验证：^[a-zA-Z0-9]{6,}$ 符合预期
   

     let reg = /^[a-zA-Z0-9]{6,}$/
   
     let str = '0203'
   
     let str2 = 'yk0203'
   
     console.log(reg.test(str), 'str') // false
   
     console.log(reg.test(str2), 'str2') // true
   
   

   
   

这个正则限制比较简单，来个复杂点的吧：

tips：解释满分。

这里我就不做test了，更复杂的大家可以自己尝试~~

3. 代码优化：我们在在编码阶段完成功能后，应该考虑代码优化之道，优化代码包括多个层面，提高代码的复用性就是其中一个方面，直接上demo说明一下：

在这个demo中，我们定义了两个函数，一个用于计算两个数的和，另一个用于计算两个数的差。通过调用这两个函数，我们可以实现复用性，避免在不同的地方重复编写相同的计算代码。此外，我们还可以通过将这些函数放入一个模块中，从而实现更高程度的复用性。将这两个函数放入一个名为"calculator.py"的模块中，然后在其他文件中引入这个模块，就可以在其他地方轻松地重用这些函数。然后我又向它发起提问：

我们使用JavaScript语言实现了与前面Python demo相同的功能。将这两个函数放入一个名为"Calculator.js"的模块中，然后在其他文件中引入这个模块，就可以在其他地方轻松地重用这些函数。其实这种思想在前端已经老生常谈了。

4. 代码重构:一般来说，一个项目经过多个人先后开发并维护，每个人的开发习惯也不尽相同，最终导致代码中很多逻辑不是很清晰，尤其是那些很久之前的项目，再加上当时没有添加注释，维护效率不高，这个时候我们可以考虑下重构下部分代码，用图来说话：

这里只是一个简单的demo，项目中重构代码要比这个复杂（慎重考虑是否进行代码重构），说到这里，养成良好的编码习惯就显得特别重要啦，比如定义方法时语义化，适当给方法添加注释等，我们的主角也是也可以帮忙添加注释的，请看：

function factorial(n) { 

    if (n === 0) return 1; 

    else return n * factorial(n-1);

}

//示例输出 

console.log(factorial(5)); //120 

console.log(factorial(10)); //3628800

// 定义递归函数，计算阶乘 

function factorial(n) { 

    if (n === 0) { 

        // 当 n 等于 0 时，阶乘结果为 1 

        return 1; 

     } else { 

       // 当 n 不等于 0 时，调用函数自身来计算阶乘

       return n * factorial(n-1); 

       } 

}

// 示例输出

console.log(factorial(5)); //120 

console.log(factorial(10)); //3628800

然后我又追问：

综上，我们想要主角帮我们处理问题，就应该把条件罗列清晰，否则主角也给不了最完善的回答，它有时在处理基本数学问题时出错，有时无法全面理解逻辑，并且甚至会提供完全错误的事实来支持其答案。OpenAI 已经承认了这个问题，并表示“ChatGPT 有时会写出听起来合理但是不正确或无意义的答案”。ChatGPT 是一种辅助工具，能够理解复杂的问题。但最好也不要完全相信它所说的一切。

tips：提问和回答的截图均来自VScode的ChatGPT中文版扩展插件（站在了大佬的肩膀上），有兴趣的童鞋可以自行搜索体验一波~

ChatGPT的现状与未来

目前，OpenAI官方已经官宣了GPT-4，只不过还没完全开放，并且门槛较高，发展前景还是相当nice的。

总结

总体看来，未来可期~~，对于希望在工作中提升效率的开发人员来说是一柄利剑。然而，它的回答也不是100%准确的，因此在将其用于更高级的任务之前，需进行深究。到此，ChatGPT的初探到此结束，感谢各位看官。有问题欢迎评论区留言。

背景

今年是应届生就业最难的一年。说实话，每一届毕业生都这么说，而且每一届毕业生说的都没有问题。疫情刚开始那一年，王兴说过一句话 2019 年可能会是过去十年最差的一年，却是未来十年里最好的一年。因为难，所以很多人将目光放向了金三银四，无论是应届的，还是找新机会的。

金三银四就是往年最好的求职时期。三四月份刚好又是春招的时期，过年后，每个企业又刚好制定好下一年的计划。刚发完年终奖，职场的小同学们又蠢蠢欲动，空出来不少位置。

现况

但是对于今年来说，金三银四就是纯骗局。即使你通过了很多简历初选，发现最后拿到手没有什么好offer，你发现好像同样的岗位，去年学长学姐，硬件指标不需要这么严格。辞职前聊的好好的offer，裸辞之后就被缩紧了。

我之前看过一段话，我一直觉得欧洲特别拉胯，今天搞游行，明天搞罢工，昨天嫌工作时间多了，今天嫌假期少了。直到有一天，我改变了看法，我毕业了。我们以为疫情过去，所有的一切都会好转，因为这是艰难的最主要来源。但是好像不是这样。因为疫情指很多深层问题的表面借口罢了。

原因

疫情只是一方面。国内资源开发过度，房地产集体不拿地，导致房企上下游的企业、广告公司、活动公司、印刷公司、工程公司对外招聘收紧。国际局势紧张，投资愈加谨慎，金融行业都卷得飞起，依赖投资的入不敷出的互联网公司，更无法支出如此大的人力成本。由此牵扯的行业计算机产品、自媒体运营、招聘收紧。教育本来就人走茶凉，牵扯出来的行业也多的不行。甚至俄乌战争能通过大量蝴蝶效应影响着我们。

那我们能怎么办呢？

混乱的背景，只会使富人更富，穷人更穷。没办法了吗？那我们能怎么办呢？

我们无法改变局势，我们只能在夹缝中求生存。但我们起码要成为在这个环境下人群中的最优解。求职也好，职业规划也好，面对现在困境，主要有两个生存的角度避坑与主动措施。

避坑

想要避免被坑，就得了解面试官和公司。他们到底怎么想的？

这两年最主要的坑分别是赛马机制、表面繁荣和白嫖逻辑。

赛马机制

面试公司让你以为你很优秀，其实你已经掉入公司的陷阱了。赛马机制就是强势烘托起所有人的竞争欲，最后选出最优秀的一匹马。赛马本无问题，但是大面积的赛马是对求职者的极其不负责任。以前的公司经常会搞 PUA 这一套来实现控制员工的目的。现在公司用的方法更加高级 NLP 教练技巧。 NLP 教练技巧可以理解为正向PUA。

你以为面试官在夸你？你以为公司很器重你？

但你已经掉进公司糖衣炮弹的陷阱了。 NLP 本来是良性的引导，但在大面积的竞争驱使下，赛马机制应运而生。 NLP 带来的自我催眠会让你适应恶劣的竞争，像养蛊一样愿意吃掉所有的竞争者。

如何判断一个公司是否在赛马？

最简单的逻辑是

1. 第一、看是否是需要通过试用期多人的竞争来确定留用。不用可惜这样子的机会，因为转正后一定会迎来更为内卷的赛马机制。


2. 第二、 不是面试前，而是所有面试后还有一堆面试官加你微信的，大概率是想拉着你再赛马几次，或者我只能请你保护好自己的私生活。


3. 第三、 画饼的公司必然在赛马。

就业难在哪里？因为人力资源充沛这件事既是红利也是诅咒。人力资源看起来充沛，就会带来第二个坑，

表面繁荣，

实际上企业现阶段根本没有什么需求，裁员都来不及呢。这和你们现在面对的很多情况是类似的。一个岗位有超多人竞聘，很多人认为这个岗位热门就是行业趋势了。其实并不是，其实只是只是企业可能需要到面率等一系列人力资源指标，为了让这个看起来很繁荣罢了。这也是为什么你们很多人通过简历关，但是最后都拿不到 offer 的原因。

如何避免？

几乎无法避免，毕竟海头是你我们常干的事情。但是可以做好心理预设，就是招聘人数需求很大的岗位，不要对这种岗位抱有太高的希望，避免影响自己招聘热情和状态。

白嫖逻辑

当你跟面试官运筹帷幄，展示自己的专业性时，你已经失去了工作的机会。公司招不起人才，但想白嫖。人才的创意和专业知识，

怎么嫖？让人才参加面试？

我认识的一个大厂的面试官跟我聊天，说今年他们的招生名额少了很多，但是面试数量增加很多。我很好奇的问他，逻辑有点矛盾，他贱兮兮的跟我说，他们内部叫做给奖励，主要给那些很厉害的人奖励，但是并不会招他们。比如一些 35 岁以上很专业的人，比如有一些硬伤但真的有东西的人。这些人在求职市场处处碰壁，给的奖励就是面试的机会。他们刚好也可以从这些面试者那里了解到一些打破信息壁垒的专业知识或信息，顺便给一些刚入职的人或者项目经理培训，但是他们肯定是不会招的。说实话，我听到这里已经开始气了。应届生常见的类似的坑，就是拿一些内部案例作为面试题进行面试。本质就是白嫖，却堂而皇之的说是奖励，谁稀罕你的奖励。所以，如果你碰到公司，一拿非常具体的案例来去进行考核，让你演绎操作细节的。并且不断询问你对行业的认识，跟你讨论战略并显得他毫无理解的。或者面试官相较于你过于年轻的这一类公司，扭头就走就好了。

相反的，如一个公司不断的给你输出他们的信息，并且真实的拿这些信息和你比对，这类公司大概率是比较靠谱的。

其实听你看完上面的，你基本能面对在金三银四的大粪坑了，还有一些很明显的坑，大部分你在网上也能搜索到，我就不扩展讲了。但是下面你要仔细看了，因为这是你在避坑之后能够有可能找到工作的重要手段。

主动措施

我们如果把找工作分成找工作前、找工作中和找工作后，我们分别要做的东西就是信息获取、个人展示和职业规划。我不断在文章里面强调信息的重要性。各个公司官网的 drop description 一定需要好好看看。如果可以用爬虫把很多公司的求职信息 down 下来，可以在他们的官网，也可以在智联招聘一类的网站，不用担心太难。你在 b 站或者其他平台搜索一下。爬虫找工作。现在已经有很多打包的工具或者软件，

金三银四

还有金三银四，不是三四月份开始，春节后就已经开启了。非要再说一些信息，新能源医药现在形势的确不错，按照之前教给你们的思维，他们的上下游求职都会比较顺利。应面试之前去企查查天眼查之类的，好好查一下公司的相关情况，什么情况，成立时间，公司规模，组织架构，法律风险是否存在信誉问题，股东信息是否正常，是否有财务纠纷。查完了，门清了你再冲，不然给你拐缅北去。再看一圈。脉脉拉钩，牛客网、看准网之类的，里面有大量吐槽到起飞的评价，可以让种草的你立马拔草。还有一些关于签署协议、劳动合同、三方协议等等一系列你需要了解，保护自己权益的相关信息，

个人展示

重要的大家理解的还是简历。简历其实针对不同的行业，需要针对定向的简历。因为你要展示的东西暴露问题是不一样的。如果你没有简历模板，或者简历做得很拉，可以使用木及简历，他是一款免费的简历模板网站。还可以使用Markdown编辑特别方便，不要用网上那些花里胡哨的剪辑模板，谁用谁死。往年我们在各大网站搜索找工作，都是各种干货方法。今年你在知乎搜一下 2023 找工作试试。只有一个统一的话题 2023 找工作好难。

你要准备无非是从找工作的环节入手。简历、笔试、面试、二面、终面。简历跟大家说了，笔试自己准备，唯一能准备的就是面试了。牛客网有不少念经，可以去看看，剩下的就是最后一个。

心态

最重要的心态随缘。我不是让大家摆烂。很多公司会组织无领导小组面试，很多公司会有压力面。如果让我给你讲分别，有什么技巧，我是能讲很多的，毕竟我也参加过招聘招聘。但是没必要随缘这个词很重要，因为它恰恰是器中了面试的核心表现状态。当你随缘的时候，无领导小组面试就没必要非要去争取leader，压力面也不会有什么压力，我不会。要知道 leader 通过率并不会比其他角色高。争取表现机会的行为其实并不会帮到什么。很多人总跟你讲放平心态，什么叫做放平心态？随缘就好。工作暂时找不到，并不会饿死，并不是你一个人现在这么艰难。削弱焦虑还没到最后一刻。

最后职业规划在这里。我只想跟应届生和已经工作的同学说两条。

• 一、应届生转行并没有什么壁垒，去现在好一些的行业。


• 二、别跳槽，市场太不景气了。不要觉得疫情过去，一切都好了。求职很重要，只是人生的一小步，并不会因为你应届的求职受挫而影响那么深远。从大厂离开的决定，那一刻，如果你也不想找工作，就就当你给自己放个长假。最重要的是要
  
  作者：zayyo
  来源：juejin.cn/post/7207314488243585081
  开心。

记一次JNI内存泄漏

前景

在视频项目播放界面来回退出时，会触发内存LeakCanary内存泄漏警告。

分析

查看leakCanary的日志没有看到明确的泄漏点，所以直接取出leakCanary保存的hprof文件，保存目录在日志中有提醒，需要注意的是如果是android11系统及以上的保存目录和android11以下不同，android11保存的目录在：

   /data/media/10/Download/leakcanary-包名/2023-03-14_17-19-45_115.hprof 

使用Memory Analyzer Tool（简称MAT） 工具进行分析，需要讲上面的hrof文件转换成mat需要的格式：

   hprof-conv -z 转换的文件 转换后的文件

    

   hprof-conv -z 2023-03-14_17-19-45_115.hprof mat115.hprof

打开MAT，导入mat115文件，等待一段时间。

在预览界面打开Histogram，搜索需要检测的类，如：VideoActivity

搜索结果查看默认第一栏，如果没有泄漏，关闭VideoActivity之后，Objects数量一般是零，如果不为零，则可能存在泄漏。

右键Merge Shortest Paths to GC Roots/exclude all phantom/weak/soft etc,references/ 筛选出强引用的对象。

筛选出结果后，出现com.voyah.cockpit.video.ui.VideoActivity$1 @0x3232332 JIN Global 信息，且无法继续跟踪下去。

筛选出结果之后显示有六个VideoActivity对象没有释放，点击该对象也无法看到GC对象路径。（正常的java层内存泄漏能够看到泄漏的对象具体是哪一个）

正常的内存泄漏能够看到具体对象，如图：

这个MegaDataStorageConfig就是存在内存泄漏。

而我们现在的泄漏确实只知道VideoActivity$1 对象泄漏了，没有具体的对象，这样就没有办法跟踪下去了。

解决办法：

虽然无法继续跟踪，但泄漏的位置说明就是这个VideoActivity$1 ，我们可以解压apk，在包内的class.dex中找到VideoActivity$1这个Class类（class.dex可能有很多，一个个找），打开这个class，查看字节码（可以android studio中快捷打开build中的apk）,根据【 .line 406 】等信息定位代码的位置，找到泄漏点。

根据方法名、代码行数、类名，直接定位到了存在泄漏的代码：

红框区内就是内存泄漏的代码，这个回调是一个三方sdk工具，我使用时进行了注册，在onDestory中反注册，但还是存在内存泄漏。（该对象未使用是我代码修改之后的）

修改方法

将这个回调移动到Application中去，然后进行事件或者回调的方式通知VideoActivity，在VideoActivity的onDestory中进行销毁回调。

修改完之后，多次进入VideoAcitivity然后在退出，导出hprof文件到mat中筛选查看，如图：

VideoActiviyty的对象已经变成了零，说明开始存在的内存泄漏已经修改好了，使用android proflier工具也能看到在退出videoactivity界面之后主动进行几次gc回收，内存使用量会回归到进入该界面之前。

总结：

1. LeakCanary工具为辅助，MAT工具进行具体分析。因为LeakCanary工具的监听并不准确，如触发leakcanary泄漏警告时代码已经泄漏了很多次。


2. 如果能够直接查看泄漏的对象，那是最好修改的，如果不能直接定位泄漏的对象，可以通过泄漏的Class对象在apk解压中找到改class，查看字节码定位具体的代码泄漏位置。


3. 使用第三方的sdk时，最好使用Application Context，统一分发统一管理，减少内存泄漏。

GPT-4 即将面世，它到底是擎天柱还是威震天？

呆鸟说：“ChatGPT 是具备人机对话能力的人工智能，一经问世，就给世人带来了前所未有的新奇体验。短短几个月时间，它就占据了人们的视野。有人好奇，有人担忧，有人看到了致富的机会，也有人担心 AI 会夺走我们的饭碗。ChatGPT 的升级版 GPT-4 也即将问世，面对更强大的 AI，我们应当何去何从呢”

GPT-3 是 ChatGPT 的核心，它是一个超大规模的大语言模型（large language models，LLMs）。GPT-3 的英文全称是生成式预训练转换器-3（generative pre-trained transformer 3），是基于 Transformer 架构开发的大型语言模型，拥有超过 1750 亿个参数。公众可以通过 OpenAI API 访问。ChatGPT 的 API 用户界面简单易用，只需“输入文本”，即可“输出文本”，无需用户具备任何专业技术知识。

据传，OpenAI 正在开发 GPT-4，该模型的参数可能高达 100 万亿，但 OpenAI 的首席执行官 Sam Altman 反驳了这一说法。

那么，GPT-4 与 GPT-3 到底有何不同，它是否会颠覆我们现有的认知？本文将一一对此进行说明。

预计 GPT-4 将在 2023 年发布

汽车人首领 ~ 擎天柱

虽然尚未正式官宣，但 IT 界对 GPT-4 的传言数不胜数，预计 OpenAI 很有可能会在今年发布 GPT-4。尽管有传言称微软必应的聊天功能中使用了新版 GPT，但目前测试用户必须排队等待才能使用由 ChatGPT 支持的新必应，而且也无法确定新必应的聊天功能是否使用了新版本的 GPT。

在 ChatGPT 发布之前，即 2022 年底，OpenAI 只允许指定的合作伙伴、付费客户和学术机构使用 GPT-3。预计在GPT-4 发布之前，OpenAI 也会采取类似的方式限制 GPT-4 的使用人员。

GPT-4 可能不会比 GPT-3 训练更多的数据

有传言称，GPT-4 的参数规模将比 GPT-3 大 100 倍，即 17 万亿个参数。但 Altman 曾表示，GPT-4 的参数规模可能并不会比 GPT-3 大很多，因为改进的重点应该是利用现有数据的能力，而不是添加更多的数据。

与 GPT-3 竞争的 Megatron 3（注：Megatron 是变形金刚里霸天虎的首领，中文名为威震天）也是一种大语言模型，它训练的数据比 GPT-3 多，但在测试效果并没有超越 GPT-3，这表明在 AI 领域，规模更大并不一定意味着效果更好。改进算法将降低 GPT-4 和 ChatGPT 的运行成本，这将是 ChatGPT 想要取代谷歌成为最流行搜索引擎的重要因素。

霸天虎首领 ~ 威震天

GPT-4 将生成更好的编程语言代码

ChatGPT 令人印象最深刻的一点是它不仅可以生成人类语言，还可以生成 Javascript、Python、C++ 等编程语言的代码，可以说是软件开发、Web 开发和数据分析统统都能搞定。

有消息称，目前，OpenAI 正在积极招聘擅长使用人类语言描述代码功能的程序员，预计 GPT-4 将推动 AI 突破生成编程代码的新境界。这种趋势将进一步推动开发工具的革命，例如，微软旗下的 Github 推出的 Copilot 使用的就是经过微调的 GPT-3，提供了把人类自然语言转换为代码的能力。

GPT-4 将使 AI 生成编程代码的能力迈向新的境界。除了生成人类语言，ChatGPT 还能生成 JavaScript、Python、C++ 等编程语言的代码，在软件开发、Web开发和数据分析等领域都将有广泛的应用。

据称，OpenAI 正在招聘能以人类语言描述代码功能的程序员，这将进一步推动开发工具的革命。例如，微软旗下的 Github 推出的 Copilot 使用的就是经过微调的 GPT-3，能够把人类自然语言转换为代码。

总之一句话，就是让程序员开发干掉程序员的程序。

GPT-4 不会添加图形功能

有人曾预测 GPT-4 将整合 GPT-3 的文本生成和 Dall-E 2（OpenAI 的另一款 AI 产品）的图像创作功能，如果 能提供数据可视化功能，ChatGPT 将更加完美。但 Altman 否认了这一点，并表示 GPT-4 仍只提供文本生成的功能。

Dall-E 生成的图像

有人会对 GPT-4 失望

虽然 GPT-3 的闪亮登场让整个世界都兴奋不已，但 GPT-4 的表现可能并不会让人再次惊艳。计算机第一次写诗的时候，你可能会觉得震撼，但几年后，即使能让 AI 把诗写得更优美，也不会再给人带来同样的震撼。

Altman 在今年一月的一次采访中曾说过，“有关 GPT-4 的传言很荒谬，都是空穴来风，只怕是希望越大，失望越大。”

那么，我亲爱的读者们，你们对此是怎么看的呢？

在我的电脑中，回想一下我们想要把一个文件拖动到另一个文件夹是什么样子的呢

1:鼠标抓起文件

2:拖动文件到文件夹上方

3:文件夹高亮，表示到达指定位置

4:松开鼠标将文件夹放入文件

下面就来一步步实现它吧👇

一：让我们的元素可拖动

方式一： draggable="true"

`<div draggable="true" class="dragdiv">拖动我</div>`

方式二：-webkit-user-drag: element;

  .dragdiv {



    width: 100px;



    height: 100px;



    background-color: bisque;



    -webkit-user-drag: element;



    }

    

效果

二：让文件夹有高亮效果

给文件夹添加伪类？

🙅如果你直接给文件夹设置伪类:hover，会发现当拖动元素时，文件夹的:hover是不会触发的

🧘这是因为在拖拽元素时，拖拽操作和悬停操作是不同的事件类型，浏览器在处理拖拽操作时，会优先处理拖拽事件，而不会触发悬停事件。拖拽操作是通过鼠标点击和拖拽来触发的，而悬停事件是在鼠标指针停留在一个元素上时触发的。

所以我们就来对拖拽操作的事件类型做功课吧🫱

• dragstart：拖拽开始


• dragend：拖拽结束


• dragover：拖拽的元素在可放置区域内移动时触发，即鼠标指针在可放置区域内移动时持续触发


• dragenter：拖拽的元素首次进入可放置区域时触发


• dragleave：拖拽的元素离开可放置区域时触发


• drop：当在可放置区域时，松开鼠标放置元素时触发

什么是可放置元素？

    当你给元素设置事件：dragover、dragenter、dragleave、drop的时候  

    它就变成了可放置元素，特点是移到上面有绿色的➕号

拖动高亮实现

1：我们给files文件夹添加两个响应事件：dragover和dragleave

ps: 这里用dragover事件而不用dragenter事件是为了后续能够成功触发drop事件

2：当拖动元素进入可放置区域时，动态的给files添加类，离开时则移除类

// 显示高亮类

.fileshover {

    background-color: rgba(0, 255, 255, 0.979);

}

// 添加dragover事件处理程序，在可放置区域触发



files.addEventListener('dragover', (event) => {



    event.target.classList.add('fileshover');



});



// 添加dragleave事件处理程序，离开可放置区域触发



files.addEventListener('dragleave', (event) => {



    event.target.classList.remove('fileshover');



});

🥳 恭喜你成功实现了移动到元素高亮的效果了

三：文件信息传递

文件拖过去，是为了切换文件夹，在这里你可能会进行一些异步的操作，比如请求后端更换文件在数据库中的路径等。我们的需求多种多样，但是归根到底都是获取到文件的数据，并传递到文件夹中。

DataTransfer对象

DragEvent.dataTransfer： 在拖放交互期间传输的数据

我们主要使用它的两个方法：

• DataTransfer.setData(format, data)：就是设置键值对，把我们要传的数据添加到drag object


• DataTransfer.getData(format)：根据键获取保存的数据

知道了这两个方法，相信你一定就有实现思路了 👊

拖拽开始 --> setData添加数据 --> 进入可放置区域 --> 放置时getData获取数据 --> 完成

1：给文件设置dragstart事件

// 开始拖拽事件



draggable.addEventListener('dragstart', (event) => {



    const data = event.target.innerText;

    

    event.dataTransfer.setData('name', data); //添加数据



})

2：在dragover事件中用event.preventDefault()阻止默认行为，允许拖拽元素放置到该元素上，否则无法触发drop事件

// 添加dragover事件处理程序



files.addEventListener('dragover', (event) => {



    event.target.classList.add('fileshover');



    event.preventDefault(); //新增



});

3：给文件夹设置放置事件drop

// 添加drop事件处理程序



files.addEventListener('drop', (event) => {



    const data = event.dataTransfer.getData('name'); // 获取文件的数据



    const text = document.createTextNode(data);



    files.appendChild(text);

    

    event.target.classList.remove('fileshover'); // 记得放置后也要移除类



});

实现效果：

四：完整代码：

<!DOCTYPE html>



<html lang="en">



<head>



<meta charset="UTF-8">



<meta http-equiv="X-UA-Compatible" content="IE=edge">



<meta name="viewport" content="width=device-width, initial-scale=1.0">



<title>Document</title>



<style>



.dragdiv {



width: 100px;



height: 100px;



background-color: bisque;



-webkit-user-drag: element;



}



.files {



width: 200px;



height: 200px;



background-color: rgba(0, 255, 255, 0.376);



margin-top: 100px;



}



.fileshover {



background-color: rgba(0, 255, 255, 0.979);



}



</style>



</head>



<body>



<div draggable="true" class="dragdiv">我是文件1</div>



<div class="files">



<p>文件夹</p>



拖动文件名称：



</div>



<script>



const draggable = document.querySelector('.dragdiv');



const files = document.querySelector('.files');



// 开始拖拽事件



draggable.addEventListener('dragstart', (event) => {



    const data = event.target.innerText;



    event.dataTransfer.setData('name', data);



})



// 添加dragover事件处理程序



files.addEventListener('dragover', (event) => {



    event.target.classList.add('fileshover')



    event.preventDefault()



});



// 添加dragleave事件处理程序



files.addEventListener('dragleave', (event) => {



    event.target.classList.remove('fileshover')



});



// 添加drop事件处理程序



files.addEventListener('drop', (event) => {



    const data = event.dataTransfer.getData('name')



    const text = document.createTextNode(data)



    files.appendChild(text);



    event.target.classList.remove('fileshover')





});



</script>



</body>



</html>

总结：以上只是简单的熟悉拖拽事件的整个过程，你可以在此拓展更多自己想要功能，欢迎分享👏

使用指纹

说明 ： 指纹解锁在23 的时候，官方就已经给出了api ,但是由于Android市场复杂，无法形成统一，硬件由不同的厂商开发，导致相同版本的软件系统，搭载的硬件千变万化，导致由的机型不支持指纹识别，但是，这也挡不住指纹识别在接下来的时间中进入Android市场的趋势，因为它相比较输入密码或图案，它更加简单，相比较密码或者图案，它更炫酷 ，本文Demo 使用最新的28 支持的androidx 库中的API及最近火热的kotlin语言完成的

需要知道的

• FingerprintManager : 指纹管理工具类


• FingerprintManager.AuthenticationCallback :使用验证的时候传入该接口，通过该接口进行验证结果回调


• FingerprintManager.CryptoObject: FingerprintManager 支持的分装加密对象的类

以上是28以下API 中使用的类 在Android 28版本中google 宣布使用Androidx 库代替Android库，所以在28版本中Android 推荐使用androidx库中的类 所以在本文中我 使用的是推荐是用的FingerprintManagerCompat 二者的使用的方式基本相似

如何使用指纹

• 开始验证 ，系统默认的每段时间验证指纹次数为5次 次数用完之后自动关闭验证，并且30秒之内不允行在使用验证

验证的方法是authenticate()

/**

*

*@param crypto object associated with the call or null if none required.

* @param flags optional flags; should be 0

* @param cancel an object that can be used to cancel authentication

* @param callback an object to receive authentication events

* @param handler an optional handler for events

**/

@RequiresPermission(android.Manifest.permission.USE_FINGERPRINT)

    public void authenticate(@Nullable CryptoObject crypto, int flags,

            @Nullable CancellationSignal cancel, @NonNull AuthenticationCallback callback,

            @Nullable Handler handler) {

        if (Build.VERSION.SDK_INT >= 23) {

            final FingerprintManager fp = getFingerprintManagerOrNull(mContext);

            if (fp != null) {

                android.os.CancellationSignal cancellationSignal = cancel != null

                        ? (android.os.CancellationSignal) cancel.getCancellationSignalObject()

                        : null;

                fp.authenticate(

                        wrapCryptoObject(crypto),

                        cancellationSignal,

                        flags,

                        wrapCallback(callback),

                        handler);

            }

        }

    }

arg1: 用于通过指纹验证取出AndroidKeyStore中key的值
arg2: 系统建议为0

arg3: 取消指纹验证 手动关闭验证 可以调用该参数的cancel方法

arg4:返回验证结果

arg5: Handler fingerprint 中的
消息都是通过handler来传递的 如果不需要则传null 会自动默认创建一个主线程的handler来传递消息

使用指纹识别的条件

• 添加权限(这个权限不需要在6.0中做处理)


• 判断硬件是否支持


• 是否已经设置了锁屏 并且已经有一个被录入的指纹


• 判断是否至少存在一条指纹信息

通过零碎的知识完成一个Demo

指纹识别通过之后跳转到 指定页面

进入之后首先弹出对话框，进行指纹验证

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical">



    <ImageView

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:layout_gravity="center"

        android:src="@drawable/fingerprint" />



    <TextView

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:layout_gravity="center"

        android:layout_marginTop="20dp"

        android:text="验证指纹" />



    <TextView

        android:id="@+id/fingerprint_error_tv"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:layout_gravity="center"

        android:layout_marginTop="10dp"

        android:maxLines="1" />



    <View

        android:layout_width="match_parent"

        android:layout_height="0.5dp"

        android:layout_marginLeft="5dp"

        android:layout_marginTop="10dp"

        android:layout_marginRight="5dp"

        android:background="#696969" />



    <TextView

        android:id="@+id/fingerprint_cancel_tv"

        android:layout_width="wrap_content"

        android:layout_height="50dp"

        android:layout_gravity="center"

        android:gravity="center"

        android:text="取消"

        android:textSize="16sp" />



</LinearLayout>

使用DialogFragment 完成对话框 新建一个DialogFragment 并且初始化相关的api

 override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        //获取fingerprintManagerCompat对象

        fingerprintManagerCompat = FingerprintManagerCompat.from(context!!)

        setStyle(DialogFragment.STYLE_NORMAL, android.R.style.Theme_Material_Light_Dialog)

    }

在界面显示在前台的时候开始扫描

override fun onResume() {

        super.onResume()

        startListening()

    }

@SuppressLint("MissingPermission")

    private fun startListening() {

        isSelfCancelled = false

        mCancellationSignal = CancellationSignal()

        fingerprintManagerCompat.authenticate(FingerprintManagerCompat.CryptoObject(mCipher), 0, mCancellationSignal, object : FingerprintManagerCompat.AuthenticationCallback() {

        //验证错误

            override fun onAuthenticationError(errMsgId: Int, errString: CharSequence?) {

                if (!isSelfCancelled) {

                    errorMsg.text = errString

                    if (errMsgId == FingerprintManager.FINGERPRINT_ERROR_LOCKOUT) {

                        Toast.makeText(mActivity, errString, Toast.LENGTH_SHORT).show()

                        dismiss()

                        mActivity.finish()

                    }

                }

            }

				//成功

            override fun onAuthenticationSucceeded(result: FingerprintManagerCompat.AuthenticationResult?) {

                MainActivity.startActivity(mActivity, true)

            }

			//错误时提示帮助，比如说指纹错误，我们将显示在界面上 让用户知道情况

            override fun onAuthenticationHelp(helpMsgId: Int, helpString: CharSequence?) {

                errorMsg.text = helpString

            }

			//验证失败

            override fun onAuthenticationFailed() {

                errorMsg.text = "指纹验证失败，请重试"

            }

        }, null)

    }

在不可见的时候停止验证

if (null != mCancellationSignal) {

            mCancellationSignal.cancel()

            isSelfCancelled = true

        }

在MainActivity 中首先判断是否验证成功 是 跳转到目标页 否则的话需要进行验证
在这个过程中我们需要做的就是判断是否支持，判断是否满足指纹验证的条件（条件在上面）

if (intent.getBooleanExtra("isSuccess", false)) {

            WelcomeActivity.startActivity(this)

            finish()

        } else {

            //判断是否支持该功能

            if (supportFingerprint()) {

                initKey() //生成一个对称加密的key

                initCipher() //生成一个Cipher对象

            }

        }

验证条件

 if (Build.VERSION.SDK_INT < 23) {

            Toast.makeText(this, "系统不支持指纹功能", Toast.LENGTH_SHORT).show()

            return false

        } else {

            val keyguardManager = getSystemService(KeyguardManager::class.java)

            val managerCompat = FingerprintManagerCompat.from(this)

            if (!managerCompat.isHardwareDetected) {

                Toast.makeText(this, "系统不支持指纹功能", Toast.LENGTH_SHORT).show()

                return false

            } else if (!keyguardManager.isKeyguardSecure) {

                Toast.makeText(this, "屏幕未设置锁屏 请先设置锁屏并添加一个指纹", Toast.LENGTH_SHORT).show()

                return false

            } else if (!managerCompat.hasEnrolledFingerprints()) {

                Toast.makeText(this, "至少在系统中添加一个指纹", Toast.LENGTH_SHORT).show()

                return false

            }

        }

必须生成一个加密的key 和一个Cipher对象

//生成Cipher

private fun initCipher() {

        val key = keyStore.getKey(DEFAULT_KEY_NAME, null) as SecretKey

        val cipher = Cipher.getInstance(KeyProperties.KEY_ALGORITHM_AES + "/"

                + KeyProperties.BLOCK_MODE_CBC + "/"

                + KeyProperties.ENCRYPTION_PADDING_PKCS7)

        cipher.init(Cipher.ENCRYPT_MODE, key)

        showFingerPrintDialog(cipher)

    }

    //生成一个key

private fun initKey() {

        keyStore = KeyStore.getInstance("AndroidKeyStore")

        keyStore.load(null)

        val keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore")

        val builder = KeyGenParameterSpec.Builder(DEFAULT_KEY_NAME,

                KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)

                .setBlockModes(KeyProperties.BLOCK_MODE_CBC)

                .setUserAuthenticationRequired(true)

                .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_PKCS7)

        keyGenerator.init(builder.build())

        keyGenerator.generateKey()

    }

Demo 是kotlin 写的
Demo地址

对于 ChatGPT 如今大家应该都不陌生，经过这么长时间的「调戏」，相信大家应该都感受用 ChatGPT 「代替」搜索引擎的魅力，例如写周报、定位 Bug、翻译文档等等，而其中不乏一些玩的很「花」的场景，例如：

• 
  

  ChatPDF ：使用 ChatPDF 读取 PDF 之后，你可以和 PDF 文件进行「交谈」，就好像它是一个完全理解内容的「人」一样，通过它可以总结中心思想，解读专业论文，生成内容摘要，翻译外籍，并且还支持中文输出等。

  
  

  

  
  


• 
  

  BiBiGPT : 一键总结视频内容，主要依赖字幕来做总结，绝对是「二创」作者的摸鱼利器。

  
  

  

  
  

所以把 ChatGPT 理解为「搜索引擎」其实并不正确，从上述介绍的两个落地实现上看， ChatGPT 不是单纯的统计模型，它的核心并不是完全依赖于它的「语料库」，更多来自于临场学习的能力「 in-context learning」，这就是 ChatGPT 不同于以往传统 NLP「一切都从语料的统计里学习」的原因。

当然，我本身并非人工智能领域的开发者，而作为一个普通开发者，我更关心的是 ChatGPT 可以如何提升我的开（mo）发（yu）效率，只是没想到随手一试，我会被 ChatGPT 的 「 in-context learning」 给「逼疯」。

ChatGPT & UI

相信大家平时「面向」 ChatGPT 开发时，也是通过它来输出「算法」或者「 CURD」 等逻辑居多，因为这部分输出看起来相对会比较直观，而用 ChatGPT 来绘制前端 UI 的人应该不多，因为 UI 效果从代码上看并不直观 ，而且 ChatGPT 对与 UI 的理解目前还处于 「人工智障」的阶段。

但是我偏偏不信邪。。。。。

因为近期开发需求里恰好需要绘制一个具有动画效果的 ⭐️ 按键，面对这么「没有挑战性」的工作我决定尝试交给 ChatGPT 来完成，所以我向 ChatGPT 发起了第一个命令：

「用 Flutter 画一个黄色的五角星」

结果不负众望，关键部分如下代码所示，Flutter 很快就提供了完整的 Dart 代码，并且还针对代码提供了代码相关实现的讲解，不过运行之后可以看到，这时候的 ⭐️ 的样式并不满足我们的需求。

此时顶部的角也太「肥」了 。

所以我随着提出了调整，希望五角星的五个角能够一样大，只是没想到我的描述，开始让 ChatGPT 放飞自我 。

也许是我的描述并不准确？

在我满怀期待的 cv 代码并运行之后，猝不及防的「五角星」差点没让我喷出一口老血，虽然这也有五个角，但是你管这个叫 「五角星」 ？？？

这难道不是某个红白机游戏里的小飞机？？

甚至于在看到后续 ChatGPT 关于代码的相关讲解时，我觉得它已经开始在「一本正经的胡说八道」，像极了今天早上刚给我提需求的产品经理。

哪里可以看出五个角相同了？？？

接着我继续纠正我的需求，表示我要的是 「一个五个角一样大的黄色五角星」 ，我以为这样的描述应过比较贴切，须不知·····

如下代码所示，其实在看到代码输出 for 循环时我就觉得不对了，但是秉承着「一切以实物为准」的理念，在运行后不出意外的发生了意外，确实是五个角一样大，不过是一个等边五边形。

算一个发胖的 ⭐️ 能解（jiao）释（bian）过去不？

再看 ChatGPT 对于代码的描述，我发现我错了，原来它像的是「理解错需求还在嘴硬的我」，只是它在说「这是一个五角星」的时候眼皮都不会眨一下。

AI：确实五个角一样大，五个角一样大的五边形为什么就不能是五角星？你这是歧视体型吗？

所以我继续要求：「我要的是五角星，不是五边形」，还好 ChatGPT 的临场学习能力不错，他又一次「重新定义五角星」，不过我此时我也不抱希望，就是单纯想看看它还能给出什么「惊喜」。

不出意外，这个「离谱」的多边形让我心头一紧，就在我想着是否放弃的时候，身为人类无法驯服 AI 「既爱又恨」的复杂情绪，让我最终坚持一定要让 ChatGPT 给我画出一个 ⭐️。

不过心灰意冷之下，我选择让 ChatGPT 重新画一个黄色五角星，没想道这次却有了意外的惊喜，从下面的图片可以看到，此时的 ⭐️ 除了角度不对，形状已经完全满足需求。

所以一个问题我多问几遍，也许就能接近我要的答案？

事实上这也是目前 ChatGPT 的现状，因为「临场学力」能力等因素影响，同一个问题它可能会给出不同的答案，而有的答案其实和我们要的根本不沾边。

那么，接下来只要让 ChatGPT 把 ⭐️ 旋转一下角度，应该就可以完成需求····了吧？所以我提出「帮我旋转 180度」的要求。

结果不出意外的还是发生了意外，可能 ChatGPT 理解的 180 度和我不大一样，如下图所示，确实旋转了，只是还是歪的，而基于前面的尝试，我觉得有必要再给它一次机会。

终于，在我换了以下描述之后，ChatGPT 似乎「开窍」了，终于让我如愿以偿的得到了我想要的 ⭐️ 代码。

可以看到，其实这段代码并不复杂，你自己写或者去搜索引擎扒一扒大概会比用 ChatGPT 更快，但是 ChatGPT 的魅力就在于：它也许会错，但是总有一次它会「蒙对」，如果现在还不对，那么未来也会有算对的时候，这就是我感受到的 AI 魅力所在。

既然五角星都出来，那么接下来我们来完成最后一步的动画效果，我们希望的是点击 ⭐️ 的时候可以有一个爆炸粒子的动画，所以我提出了：

「希望加上一个动画效果，就是点击的时候星星爆炸成颗粒的动画效果」

结果还是「一口老血」，如下图所示，「星星确实爆炸了」，只是这个爆炸动画看起来是那么的「一言难尽」，感兴趣的可以 cv 下面的源代码自己体验下，不出意外接下来又是新的一轮人类和 AI 的「斗智斗勇」。

class YellowStar extends StatefulWidget {

  @override

  _YellowStarState createState() => _YellowStarState();

}



class _YellowStarState extends State<YellowStar> with TickerProviderStateMixin {

  bool _isExploded = false;

  late AnimationController _animationController;

  late Animation<double> _animation;



  @override

  void initState() {

    super.initState();

    _animationController = AnimationController(

      duration: const Duration(milliseconds: 500),

      vsync: this,

    );

    _animation = CurvedAnimation(

      parent: _animationController,

      curve: Curves.easeInOut,

    );

  }



  @override

  void dispose() {

    _animationController.dispose();

    super.dispose();

  }



  void _handleTapDown(TapDownDetails details) {

    setState(() {

      _isExploded = true;

      _animationController.forward(from: 0.0);

    });

  }



  void _resetStar() {

    setState(() {

      _isExploded = false;

      _animationController.reset();

    });

  }



  @override

  Widget build(BuildContext context) {

    return GestureDetector(

      onTapDown: _handleTapDown,

      onTap: _resetStar,

      child: AnimatedContainer(

        duration: const Duration(milliseconds: 500),

        decoration: BoxDecoration(

          color: Colors.white,

          borderRadius: _isExploded

              ? BorderRadius.circular(50)

              : BorderRadius.zero,

        ),

        child: _isExploded

            ? _buildParticles()

            : Container(

          width: 100,

          height: 100,

          child: CustomPaint(

            painter: YellowStarPainter(),

          ),

        ),

      ),

    );

  }



  Widget _buildParticles() {

    return AnimatedBuilder(

      animation: _animation,

      builder: (context, child) {

        return Container(

          width: 100,

          height: 100,

          child: Stack(

            children: List.generate(

              50,

                  (index) {

                double radius = _animation.value * 50;

                double angle = 2 * pi * index / 50;

                double x = 50 + cos(angle) * radius;

                double y = 50 + sin(angle) * radius;

                return Positioned(

                  left: x,

                  top: y,

                  child: Container(

                    width: 4,

                    height: 4,

                    decoration: BoxDecoration(

                      shape: BoxShape.circle,

                      color: Colors.yellow,

                    ),

                  ),

                );

              },

            ),

          ),

        );

      },

    );

  }

}







class YellowStarPainter extends CustomPainter {

  final double starSizeRatio = 0.4;

  final double centerOffsetRatio = 0.2;

  final double rotationOffset = -pi / 2;



  @override

  void paint(Canvas canvas, Size size) {

    double starSize = min(size.width, size.height) * starSizeRatio;

    double centerX = size.width / 2;

    double centerY = size.height / 2;

    double centerOffset = starSize * centerOffsetRatio;



    Path path = Path();

    Paint paint = Paint()

      ..color = Colors.yellow

      ..style = PaintingStyle.fill;



    for (int i = 0; i < 5; i++) {

      double radians = 2 * pi / 5 * i + rotationOffset;

      double x = centerX + cos(radians) * starSize / 2;

      double y = centerY + sin(radians) * starSize / 2;

      if (i == 0) {

        path.moveTo(x, y);

      } else {

        path.lineTo(x, y);

      }



      radians += 2 * pi / 10;

      x = centerX + cos(radians) * centerOffset;

      y = centerY + sin(radians) * centerOffset;

      path.lineTo(x, y);

    }



    path.close();

    canvas.drawPath(path, paint);

  }



  @override

  bool shouldRepaint(CustomPainter oldDelegate) => false;

}

经过一轮「鏖战」如下图所示，面对同一个问题，ChatGPT 总能找到不同的实现方式来回答你，只是这些实现里有的无法运行的，有的是运行没有效果的，有的甚至是给你输出了一个 //TODO 爆炸动画 ，总之就是让你「血压飙升」。

当然，「胜利终将属于人类」，如下图所示，在经历了无数次「血压飙升」的场景之后，最终我还是得到了我想要的：点击 ⭐️，然后出现了💥的动画效果，尽管还是不完美，但是基本满足了我后续开发的需求。

这个代码完完全全由 ChatGPT 输出，我一句没改，完整代码贴在了后面。

class YellowStarPage extends StatefulWidget {

  @override

  _YellowStarPageState createState() => _YellowStarPageState();

}



class _YellowStarPageState extends State<YellowStarPage>

    with SingleTickerProviderStateMixin {

  late AnimationController _animationController;

  bool _isExploded = false;



  @override

  void initState() {

    super.initState();

    _animationController =

        AnimationController(vsync: this, duration: Duration(milliseconds: 500))

          ..addListener(() {

            setState(() {});

          });

  }



  @override

  void dispose() {

    _animationController.dispose();

    super.dispose();

  }



  void _handleStarTap() {

    if (!_isExploded) {

      _isExploded = true;

      _animationController.forward(from: 0);

      Future.delayed(Duration(milliseconds: 500), () {

        setState(() {

          _isExploded = false;

        });

      });

    }

    setState(() {});

  }



  @override

  Widget build(BuildContext context) {

    return Scaffold(

      appBar: AppBar(title: Text('Yellow Star')),

      body: Center(

        child: GestureDetector(

          onTap: _handleStarTap,

          child: Container(

            width: 300,

            height: 300,

            child: AnimatedBuilder(

              animation: _animationController,

              builder: (context, child) {

                return CustomPaint(

                  painter: YellowStarPainter(_animationController.value,

                      isExploded: _isExploded),

                );

              },

            ),

          ),

        ),

      ),

    );

  }

}



class YellowStarPainter extends CustomPainter {

  final double starSizeRatio = 0.4;

  final double centerOffsetRatio = 0.2;

  final double rotationOffset = -pi / 2;



  final double animationValue;

  final bool isExploded;



  YellowStarPainter(this.animationValue, {this.isExploded = false});



  @override

  void paint(Canvas canvas, Size size) {

    double starSize = min(size.width, size.height) * starSizeRatio;

    double centerX = size.width / 2;

    double centerY = size.height / 2;

    double centerOffset = starSize * centerOffsetRatio;



    Path path = Path();

    Paint paint = Paint()

      ..color = Colors.yellow

      ..style = PaintingStyle.fill;



    if (isExploded) {

      double particleSize = starSize / 30;

      paint.strokeWidth = 1;

      paint.style = PaintingStyle.fill;

      paint.color = Colors.yellow;

      Random random = Random();



      for (int i = 0; i < 30; i++) {

        double dx = random.nextDouble() * starSize - starSize / 2;

        double dy = random.nextDouble() * starSize - starSize / 2;

        double x = centerX + dx * (1 + animationValue);

        double y = centerY + dy * (1 + animationValue);



        canvas.drawCircle(Offset(x, y), particleSize, paint);

      }

    } else {

      for (int i = 0; i < 5; i++) {

        double radians = 2 * pi / 5 * i + rotationOffset;

        double x = centerX + cos(radians) * starSize / 2;

        double y = centerY + sin(radians) * starSize / 2;

        if (i == 0) {

          path.moveTo(x, y);

        } else {

          path.lineTo(x, y);

        }



        radians += 2 * pi / 10;

        x = centerX + cos(radians) * centerOffset;

        y = centerY + sin(radians) * centerOffset;

        path.lineTo(x, y);

      }



      path.close();

      canvas.drawPath(path, paint);

    }

  }



  @override

  bool shouldRepaint(CustomPainter oldDelegate) => true;

}