• 关于 异常程序出问题什么情况 的搜索结果

回答

这几个问题回答起来没什么意思,我主要分析分析面试官为什么问你这几个问题。问题 1 主要应该是想了解你对调用其他程序或接口时出现的异常情况是如何处理的,毕竟程序的运行并不总是一帆风顺,如果由于其他的接口出现了问题,而你没有处理好这些问题继而引发你写的程序出错或崩溃,那确实不是一个优秀的程序员所做的。程序员不仅应该了解用户按常理出牌,按既定路线完成程序的情况,还应该做好发生各种异常情况的处理。问题 2 主要应该是想了解你是怎样评估你写的程序的,是通过怎样的手段了解的程序的运行情况,是如何优化你的程序的。实现功能并不是程序员的唯一目标,在实现功能的情况下做一个优秀的、高效的程序也是一项艰巨的工程。问题 3 主要应该是想了解你对程序体系结构,或者说是架构的理解,程序不是简单的代码堆积,是有思想线路支撑,有模块协作分工的。作为程序员,虽然可能不会去实际写某一块的东西,但是至少应该了解这些模块的功能以及所有模块之间的联系和他们是如何协作工作的。就好比实现一个接口,你需要处理输入,进行逻辑判断,数据库操作,遇到错误的响应,返回结果等等,这里每一块都是相当细致的。

a123456678 2019-12-02 03:03:23 0 浏览量 回答数 0

问题

Windows Phone 7 - 如何退出程序:报错

kun坤 2020-06-20 11:52:16 1 浏览量 回答数 1

问题

我这个是共享型的吗?能否升级成独享?

skagh 2019-12-01 19:30:08 1151 浏览量 回答数 2

试用中心

为您提供0门槛上云实践机会,企业用户最高免费12个月

回答

回 1楼西秦的帖子 你好,在提示502期间我查看了应用日志是正常的,而且有问题的时候是两台机器的80端口同时异常。 有定义错误返回,而且即使是未定义错误返回,也不可能在输入主页地址时候出现502啊,以为之前一直都是正常的 ------------------------- 回 5楼小柒2012的帖子 memcached我也不是很懂啊,我只是知道项目里用到了memcached,出错是IP+80端口访问不了,但是后台应用日志是没有错误信息的。 如果是网站程序问题的话 为什么会出现这种一直运行的好好的突然就出现了502错误,然后又自己莫名其妙的好了,而且没有规律性,并不是程序运行了好久就出现这种问题。 ------------------------- 回 3楼西秦的帖子 你好,出现reString这种日志是昨天才第一次发现的,场景是我已经启动了应用,后台日志一直在打印正常程序运行的日志,然后就突然出现这样的日志,然后是程序启动日志,然后就是正常启动程序后的样子了 ------------------------- 回 4楼kideny的帖子 你好,nginx日志只提示了我截图上面的那些...出现这种问题的时候443端口是正常的,只有80端口不通,而且是两台机器同时出现这种情况 ------------------------- 回 9楼空格博客的帖子 你好,我没有遇到过超时导致502的情况,我的网站出现这种问题的时候在负载均衡控制台看80端口异常,后台程序日志是正常的。但是这种情况是突然出现的,比如程序启动以后一切都是好好的,过了几小时或者几天或者几个月突然80端口就异常了... ------------------------- 回 11楼西秦的帖子 你好,我就是开发人员,这个项目是半路接手的,Nginx+Resin+Memcached也都是自己摸索出来的,以前没用过这些 ------------------------- 回 12楼小柒2012的帖子 出问题的时候如果通过https访问可以进入网站,不过速度明显变慢,通过IP+80端口无法访问,IP+8080貌似可以打开resin目录,昨天出问题的时候没有试过IP+8080访问,所以不敢肯定。 ------------------------- Re网站正常运行时有时会出现502错误,求助分析原因 我现在很疑惑的问题是:如果是致命的Nginx或者Resin或者其他什么的配置错误,那程序在启动时候就会出错误啊,可是启动程序是正常的,网站也是绝大多数时候都是正常访问的。如果是运行一段时间后因为有内存泄露造成内存不足或者Nginx什么的链接数不够了,那么重启服务或者重启几次了应该就能恢复正常了吧,可是昨天出问题的时候两台机器我都重启过,依然没用。而且出问题的时候只是80端口有问题,443端口正常,所以我完全猜不出问题是出在哪里,是Java Web程序?还是Nginx?还是Resin?还是其他的什么 ------------------------- 回 17楼西秦的帖子 你好,出现问题的时候后台程序运行完全正常啊,日志没有任何异常,而且通过https是可以访问的 ------------------------- 回 16楼lab2016的帖子 你的是java程序还是php的? 如果是php的可以尝试修改php-fpm的链接数 ------------------------- 回 20楼西秦的帖子 你好,你所说的”后端是否发送了拒绝请求“是指Nginx拒绝还是Resin拒绝? 我在nginx的日志里看到俩日志access.log 和 error.log,error.log的日志就是我前面贴的那个提示节点no live全部挂掉的截图, access.log里面就是正常请求日志。

白开水vv 2019-12-02 02:09:31 0 浏览量 回答数 0

问题

Windows 实例开机后一直处于蓝色屏幕(非蓝屏 crash)状态是什么原因

boxti 2019-12-01 22:06:22 1553 浏览量 回答数 0

问题

10个Java异常的常见问题:报错

kun坤 2020-06-09 11:37:57 3 浏览量 回答数 1

问题

ECS Windows端口异常占用的处理方法是什么

boxti 2019-12-01 22:10:16 1233 浏览量 回答数 0

问题

PySpark线性回归数据集中具有比数据点更多的特征

社区小助手 2019-12-01 19:23:37 655 浏览量 回答数 1

问题

系统偶尔出现column XX does not exist异常,需重启应用才能恢复?报错

爱吃鱼的程序员 2020-06-10 13:26:12 0 浏览量 回答数 1

回答

我们先通过一个简单的代码来了解该问题。同步问题我们使用一个简单的结构体 Counter,该结构体包含一个值以及一个方法用来改变这个值: 1 struct Counter { 2 int value; 3 4 void increment(){ 5 ++value; 6 } 7}; 然后启动多个线程来修改结构体的值: 1 int main(){ 2 Counter counter; 3 4 std::vector<std::thread> threads; 5 for(int i = 0; i < 5; ++i){ 6 threads.push_back(std::thread([&counter](){ 7 for(int i = 0; i < 100; ++i){ 8 counter.increment(); 9 } 10 })); 11 } 12 13 for(auto& thread : threads){ 14 thread.join(); 15 } 16 17 std::cout << counter.value << std::endl; 18 19 return 0; 20} 我们启动了5个线程来增加计数器的值,每个线程增加了100次,然后在线程结束时打印计数器的值。但我们运行这个程序的时候,我们是希望它会答应500,但事实不是如此,没人能确切知道程序将打印什么结果,下面是在我机器上运行后打印的数据,而且每次都不同: 442 500 477 400 422 487 问题的原因在于改变计数器值并不是一个原子操作,需要经过下面三个操作才能完成一次计数器的增加:首先读取 value 的值然后将 value 值加1将新的值赋值给 value但你使用单线程来运行这个程序的时候当然没有任何问题,因此程序是顺序执行的,但在多线程环境中就有麻烦了,想象下下面这个执行顺序:Thread 1 : 读取 value, 得到 0, 加 1, 因此 value = 1Thread 2 : 读取 value, 得到 0, 加 1, 因此 value = 1Thread 1 : 将 1 赋值给 value,然后返回 1Thread 2 : 将 1 赋值给 value,然后返回 1这种情况我们称之为多线程的交错执行,也就是说多线程可能在同一个时间点执行相同的语句,尽管只有两个线程,交错的现象也很明显。如果你有更多的线程、更多的操作需要执行,那么这个交错是必然发生的。有很多方法来解决线程交错的问题:信号量 Semaphores原子引用 Atomic referencesMonitorsCondition codesCompare and swap在这篇文章中我们将学习如何使用信号量来解决这个问题。信号量也有很多人称之为互斥量(Mutex),同一个时间只允许一个线程获取一个互斥对象的锁,通过 Mutex 的简单属性就可以用来解决交错的问题。使用 Mutex 让计数器程序是线程安全的 在 C++11 线程库中,互斥量包含在 mutex 头文件中,对应的类是 std::mutex,有两个重要的方法 mutex:lock() 和 unlock() ,从名字上可得知是用来锁对象以及释放锁对象。一旦某个互斥量被锁,那么再次调用 lock() 返回堵塞值得该对象被释放。为了让我们刚才的计数器结构体是线程安全的,我们添加一个 set:mutext 成员,并在每个方法中通过 lock()/unlock() 方法来进行保护: struct Counter { std::mutex mutex; int value; Counter() : value(0) {} void increment(){ mutex.lock(); ++value; mutex.unlock(); } }; 然后我们再次测试这个程序,打印的结果就是 500 了,而且每次都一样。异常和锁 现在让我们来看另外一种情况,想象我们的的计数器有一个减操作,并在值为0的时候抛出异常: struct Counter { int value; Counter() : value(0) {} void increment(){ ++value; } void decrement(){ if(value == 0){ throw "Value cannot be less than 0"; } --value; } }; 然后我们不需要修改类来访问这个结构体,我们创建一个封装器: struct ConcurrentCounter { std::mutex mutex; Counter counter; void increment(){ mutex.lock(); counter.increment(); mutex.unlock(); } void decrement(){ mutex.lock(); counter.decrement(); mutex.unlock(); } }; 大部分时候该封装器运行挺好,但是使用 decrement 方法的时候就会有异常发生。这是一个大问题,一旦异常发生后,unlock 方法就没被调用,导致互斥量一直被占用,然后整个程序就一直处于堵塞状态(死锁),为了解决这个问题我们需要用 try/catch 结构来处理异常情况: void decrement(){ mutex.lock(); try { counter.decrement(); } catch (std::string e){ mutex.unlock(); throw e; } mutex.unlock(); } 这个代码并不难,但看起来很丑,如果你一个函数有 10 个退出点,你就必须为每个退出点调用一次 unlock 方法,或许你可能在某个地方忘掉了 unlock ,那么各种悲剧即将发生,悲剧发生将直接导致程序死锁。接下来我们看如何解决这个问题。自动锁管理 当你需要包含整段的代码(在我们这里是一个方法,也可能是一个循环体或者其他的控制结构),有这么一种好的解决方法可以避免忘记释放锁,那就是 std::lock_guard.这个类是一个简单的智能锁管理器,但创建 std::lock_guard 时,会自动调用互斥量对象的 lock() 方法,当 lock_guard 析构时会自动释放锁,请看下面代码: struct ConcurrentSafeCounter { std::mutex mutex; Counter counter; void increment(){ std::lock_guard<std::mutex> guard(mutex); counter.increment(); } void decrement(){ std::lock_guard<std::mutex> guar(mutex); mutex.unlock(); } };

a123456678 2019-12-02 01:56:44 0 浏览量 回答数 0

问题

ECS Windows调整进程CPU占用示例是什么

boxti 2019-12-01 22:06:58 1311 浏览量 回答数 0

回答

1.第一个问题通过数据版本,也就是所谓的乐观锁解决。 2.先写日志log,然后ack机制。其实很多这种方式被很多应用所用到比如mysql。 3.用户注册本身这个功能不属于高频调用,所以性能上不需要考虑太多,直接悲观锁实现即可。而且这种可能性非常低,就算失败,那么返回给用户一个能理解的失败信息即可。######回复 @sixliu:谢谢回复靠谱的回答真不多我再等等看...######回复 @花歌:第二个可能没太理解你的场景######谢谢咯~1和3可以,我看看还有什么别的方案,差不多也就这么做了,2的话再考虑考虑吧感觉还是有点不适用场景###### 三个问题,其实就是同一个并发的问题,###### 都是并发中会出现的问题。 1说的在内存里的情况,就是2。 1说的在数据库中的情况,就是3。 在数据库中,数据库自己会有锁来解决这个问题,遇到这种情况会修改失败,程序中捕获这种异常做处理返回给前台就可以了。 在内存中,单机单进程单线程,会有顺序,因此没有问题。多机或多进程或多线程操作同一数据,会出现此问题。一种实现方式是加锁,相当于仿照数据库那样的实现,内存正在被修改时,其他的修改会被阻塞或者异常终止。另一种方式是通过队列实现顺序操作,所有的修改都发送到一个程序修改。######让我想想,嗯差不多,回答比较靠谱,谢了先其实...我用的是nodejs全异步操作,前面的数据库操作没完成,后面的也可以进入函数,如果网络延迟,就会造成执行完成顺序和开始执行顺序不一致...等等想一会再问你哈###### 1.是设计上的问题 两个操作如果有先后顺序 就得先后执行  一个操作完了之后再下一个操作 不可能明知道有一前一后却还要非得一起 2.这个就是非常典型的数据库事务 就是保证多个不相关的操作的原子性 只要其中一个出问题就全部回滚 不存在有的成功有的失败 事务还是个挺复杂的东西 mongodb都还不支持事务 多服务器之间分布式的事务也是有些麻烦的  3.同时的操作数据库自己会进行锁的处理 对数据库来说还是一前一后  如果某个字段设置了唯一索引 那后面的那个必然会出错 代码里正常处理就可以了 所以用户名不唯一的处理有两个地方 一个是在插入之前 一个是在插入时抛出唯一索引异常   当然也可以在新建用户这一整个操作上加锁 全局同时只能有一个用户在新建 不过这样可能效率不高 ######问题1现实情况就是这样用户以为他的操作有顺序但基于连接池算是并发操作即时不用池那也是异步操作不能保证顺序所以只能考虑数据库锁时间戳问题2还没到数据库呢...只考虑多个内存中的对象操作问题3现在就是这样处理的###### 1.加锁 2.加事务控制 3.异常捕获与处理 工作不满一年吧######不好意思...工作6年多了开发经验10多年问题1暂时用乐观锁解决了问题2事务控制个毛线问题你可能是没读清内存中的几个对象而已和数据库无关就是事务也得自己实现这话谁都会说我想听的是备忘录模式这种...到底怎么做能优雅点还是我从需求设计上可能有问题问题3靠数据库唯一约束出错返回太暴力现在就是这么做的也可以数据库加锁怕影响性能###### 1,updateusersetstatus=2wherestatus=3andid=1; 2,用户名设置唯一索引。###### 可以用现在拷贝上操作,再合并的方法解决。1、按顺序合并。2、按状态合并。3、按索引合并。

优选2 2020-06-09 10:36:32 0 浏览量 回答数 0

回答

1.第一个问题通过数据版本,也就是所谓的乐观锁解决。 2.先写日志log,然后ack机制。其实很多这种方式被很多应用所用到比如mysql。 3.用户注册本身这个功能不属于高频调用,所以性能上不需要考虑太多,直接悲观锁实现即可。而且这种可能性非常低,就算失败,那么返回给用户一个能理解的失败信息即可。######回复 @sixliu : 谢谢回复 靠谱的回答真不多 我再等等看...######回复 @花歌 : 第二个 可能没太理解你的场景######谢谢咯~ 1和3可以,我看看还有什么别的方案,差不多也就这么做了,2的话 再考虑考虑吧 感觉还是有点不适用场景###### 三个问题,其实就是同一个并发的问题,###### 都是并发中会出现的问题。 1说的在内存里的情况,就是2。 1说的在数据库中的情况,就是3。 在数据库中,数据库自己会有锁来解决这个问题,遇到这种情况会修改失败,程序中捕获这种异常做处理返回给前台就可以了。 在内存中,单机单进程单线程,会有顺序,因此没有问题。多机或多进程或多线程操作同一数据,会出现此问题。一种实现方式是加锁,相当于仿照数据库那样的实现,内存正在被修改时,其他的修改会被阻塞或者异常终止。另一种方式是通过队列实现顺序操作,所有的修改都发送到一个程序修改。######让我想想,嗯 差不多,回答比较靠谱,谢了先 其实...我用的是nodejs 全异步操作,前面的数据库操作没完成,后面的也可以进入函数,如果网络延迟,就会造成执行完成顺序和开始执行顺序不一致... 等等想一会再问你哈###### 1. 是设计上的问题  两个操作如果有先后顺序  就得先后执行   一个操作完了之后再下一个操作   不可能明知道有一前一后 却还要非得一起 2. 这个就是非常典型的数据库事务   就是保证多个不相关的操作的原子性  只要其中一个出问题就全部回滚  不存在有的成功有的失败  事务还是个挺复杂的东西   mongodb都还不支持事务  多服务器之间分布式的事务也是有些麻烦的   3. 同时的操作 数据库自己会进行锁的处理  对数据库来说还是一前一后    如果某个字段设置了唯一索引  那后面的那个必然会出错  代码里正常处理就可以了   所以用户名不唯一的处理有两个地方  一个是在插入之前  一个是在插入时抛出唯一索引异常      当然也可以在新建用户这一整个操作上加锁   全局同时只能有一个用户在新建  不过这样可能效率不高  ######问题1 现实情况就是这样 用户以为他的操作有顺序 但基于连接池 算是并发操作 即时不用池 那也是异步操作 不能保证顺序 所以只能考虑数据库锁 时间戳 问题2 还没到数据库呢... 只考虑多个内存中的对象操作 问题3 现在就是这样处理的###### 1.加锁 2.加事务控制 3.异常捕获与处理 工作不满一年吧######不好意思... 工作6年多了 开发经验10多年 问题1 暂时用乐观锁解决了 问题2 事务控制个毛线 问题你可能是没读清 内存中的几个对象而已 和数据库无关 就是事务也得自己实现 这话谁都会说 我想听的是 备忘录模式 这种... 到底怎么做能优雅点 还是我从需求设计上可能有问题 问题3 靠数据库唯一约束出错返回太暴力 现在就是这么做的 也可以数据库加锁 怕影响性能###### 1,update user set status=2 where status=3 and id=1; 2,用户名设置唯一索引。###### 可以用现在拷贝上操作,再合并的方法解决。1、按顺序合并。2、按状态合并。3、按索引合并。

爱吃鱼的程序员 2020-05-29 20:15:24 0 浏览量 回答数 0

回答

回 1楼无衣蒹葭的帖子 是这样的,我是一个服务器要一直获取用户传来的资源进行处理再回送 但是如果我在中途进行aos_http_io_deinitialize(); 程序就相当于返回到更高一级的线程,在那个线程里通过批处理去掉cmd如果异常 批处理会终止 不进行aos_http_io_deinitialize();的话 会在当前子线程模块运行 能确保程序的正确运行 ------------------------- 回 1楼无衣蒹葭的帖子 我没有采取外调 exe方式 而是直接把sdk代码加到我原有的代码里了 ------------------------- 回 1楼无衣蒹葭的帖子 只调用aos_pool_destroy(p);不调用aos_http_io_deinitialize();会有什么问题? 或者有没有其他的办法 不让程序回到更高一级? ------------------------- 回 5楼无衣蒹葭的帖子 嗯,确实是多线程,那样的话如果在主函数循环里进行清理会影响到其他线程的处理对吧? ------------------------- 回 5楼无衣蒹葭的帖子 是不是只要运行一次aos_http_io_deinitialize last就可以全部清理 我在主循环里设置一个空闲的期间 然后进行 aos_http_io_initialize("oss_test", 0); aos_http_io_deinitialize(); 两句 这样行嘛? ------------------------- 回 5楼无衣蒹葭的帖子 我试了一下,发现只要我加了aos_http_io_deinitialize(); 程序就错了= =!!! 后面调系统命令只要异常就不会继续执行了 不知道这是什么情况。。。 ------------------------- 回 9楼无衣蒹葭的帖子 这个问题蛮蛋疼的。。只要我用aos_http_io_initialize cmd就会回到主线程状态 出异常就直接错了 哪怕只是删一个不存在的文件夹。。都不会继续执行批处理了 ------------------------- 回 9楼无衣蒹葭的帖子 只调aos_pool_destroy(p) 不调aos_http_io_initialize 然后 定期重启整个程序 会不会有什么危害? 从目前的状态来看 我确实不能调aos_http_io_initialize。。。除非我把整个osssdk单独做一个进程去调用 ------------------------- ReCSDKOSS不清理运行环境会怎样? 确实每次上传下载内存都有少量的增长

九日王朝 2019-12-02 01:28:29 0 浏览量 回答数 0

回答

手动捕获异常的时候,要继续抛出,jfinal事务才能继续工作,否则不抛出异常,他会认为这个操作是正确的! 或者你手动回滚也成: DbKit.getConfig().getConnection().rollback(); ###### 引用来自“aqu”的评论 手动捕获异常的时候,要继续抛出,jfinal事务才能继续工作,否则不抛出异常,他会认为这个操作是正确的! 或者你手动回滚也成: DbKit.getConfig().getConnection().rollback(); 引用来自“天王盖地虎626”的评论 可是我抛出异常也没用呀,呜呜 如果你抛出也没用,如果你手动回滚也无用,,,,,如果你正好用的是mysql,请检查数据库引擎是不是InnoDB ,,,,,mysql默认的主引擎 MyISAM是不支持事务的!######再确认一下 @Before(Tx.class) 是否是用在 Controller 之上的######@Before(Tx.class)注释必须是加载Controller之上的吗?###### 引用来自“aqu”的评论 手动捕获异常的时候,要继续抛出,jfinal事务才能继续工作,否则不抛出异常,他会认为这个操作是正确的! 或者你手动回滚也成: DbKit.getConfig().getConnection().rollback(); 可是我抛出异常也没用呀,呜呜###### 正确做法是不是去掉try{}catch()就可以了? 这样异常就会正常抛出 ######no try catch no throws ######如果对事务方面比较关心 可以看下 http://my.oschina.net/idreamblue/blog/388875###### 引用来自“JFinal”的评论 再确认一下 @Before(Tx.class) 是否是用在 Controller 之上的 比如我是这样用的: @Before(AuthInterceptor.class) public class MyCreditManagerAction extends BoxAction { @Before(Tx.class)  public void updateCreditInfo()  throws Exception{ try{ 。。。 hydLoanLog.save(); 。。。 hydLoan.save(); }catch(Exception e){ throw new Exception("出错了"); } } } 我目前的情况,类似这样的写法,如果第2个操作数据库出现错误,但是第一个操作数据库正常的话,发现数据保存成功了第一个,却没有一起回滚到初始状态。 ######注意一下事务级别,调高到 4 ,还要注意一下引擎是否为 InnoDB###### 引用来自“天王盖地虎626”的评论 引用来自“JFinal”的评论 再确认一下 @Before(Tx.class) 是否是用在 Controller 之上的 比如我是这样用的: @Before(AuthInterceptor.class) public class MyCreditManagerAction extends BoxAction { @Before(Tx.class)  public void updateCreditInfo()  throws Exception{ try{ 。。。 hydLoanLog.save(); 。。。 hydLoan.save(); }catch(Exception e){ throw new Exception("出错了"); } } } 我目前的情况,类似这样的写法,如果第2个操作数据库出现错误,但是第一个操作数据库正常的话,发现数据保存成功了第一个,却没有一起回滚到初始状态。 从图片上看,应该是InnoDB,而且事务级别也是4 ActiveRecordPlugin arp = new ActiveRecordPlugin("otherConfig",druidPlugin); arp.setTransactionLevel(4);但是事务回滚就是没有效果,而且甚至debug了Tx.java类,程序也确实走到了conn.rollback(); 理论上说,我的代码写法应该没有问题,已经起到事务效果了,但是,数据库里数据依然不能保持一致,难不成,数据库这边还有什么要调整吗?    

爱吃鱼的程序员 2020-05-29 19:46:45 0 浏览量 回答数 0

回答

手动捕获异常的时候,要继续抛出,jfinal事务才能继续工作,否则不抛出异常,他会认为这个操作是正确的! 或者你手动回滚也成: DbKit.getConfig().getConnection().rollback(); ###### 引用来自“aqu”的评论 手动捕获异常的时候,要继续抛出,jfinal事务才能继续工作,否则不抛出异常,他会认为这个操作是正确的! 或者你手动回滚也成: DbKit.getConfig().getConnection().rollback(); 引用来自“天王盖地虎626”的评论 可是我抛出异常也没用呀,呜呜 如果你抛出也没用,如果你手动回滚也无用,,,,,如果你正好用的是mysql,请检查数据库引擎是不是InnoDB ,,,,,mysql默认的主引擎 MyISAM是不支持事务的!######再确认一下 @Before(Tx.class) 是否是用在 Controller 之上的######@Before(Tx.class)注释必须是加载Controller之上的吗?###### 引用来自“aqu”的评论 手动捕获异常的时候,要继续抛出,jfinal事务才能继续工作,否则不抛出异常,他会认为这个操作是正确的! 或者你手动回滚也成: DbKit.getConfig().getConnection().rollback(); 可是我抛出异常也没用呀,呜呜###### 正确做法是不是去掉try{}catch()就可以了? 这样异常就会正常抛出 ######no try catch no throws ######如果对事务方面比较关心 可以看下 http://my.oschina.net/idreamblue/blog/388875###### 引用来自“JFinal”的评论 再确认一下 @Before(Tx.class) 是否是用在 Controller 之上的 比如我是这样用的: @Before(AuthInterceptor.class) public class MyCreditManagerAction extends BoxAction { @Before(Tx.class)  public void updateCreditInfo()  throws Exception{ try{ 。。。 hydLoanLog.save(); 。。。 hydLoan.save(); }catch(Exception e){ throw new Exception("出错了"); } } } 我目前的情况,类似这样的写法,如果第2个操作数据库出现错误,但是第一个操作数据库正常的话,发现数据保存成功了第一个,却没有一起回滚到初始状态。 ######注意一下事务级别,调高到 4 ,还要注意一下引擎是否为 InnoDB###### 引用来自“天王盖地虎626”的评论 引用来自“JFinal”的评论 再确认一下 @Before(Tx.class) 是否是用在 Controller 之上的 比如我是这样用的: @Before(AuthInterceptor.class) public class MyCreditManagerAction extends BoxAction { @Before(Tx.class)  public void updateCreditInfo()  throws Exception{ try{ 。。。 hydLoanLog.save(); 。。。 hydLoan.save(); }catch(Exception e){ throw new Exception("出错了"); } } } 我目前的情况,类似这样的写法,如果第2个操作数据库出现错误,但是第一个操作数据库正常的话,发现数据保存成功了第一个,却没有一起回滚到初始状态。 从图片上看,应该是InnoDB,而且事务级别也是4 ActiveRecordPlugin arp = new ActiveRecordPlugin("otherConfig",druidPlugin); arp.setTransactionLevel(4);但是事务回滚就是没有效果,而且甚至debug了Tx.java类,程序也确实走到了conn.rollback(); 理论上说,我的代码写法应该没有问题,已经起到事务效果了,但是,数据库里数据依然不能保持一致,难不成,数据库这边还有什么要调整吗?    

爱吃鱼的程序员 2020-06-02 13:53:35 0 浏览量 回答数 0

回答

手动捕获异常的时候,要继续抛出,jfinal事务才能继续工作,否则不抛出异常,他会认为这个操作是正确的! 或者你手动回滚也成: DbKit.getConfig().getConnection().rollback(); ###### 引用来自“aqu”的评论 手动捕获异常的时候,要继续抛出,jfinal事务才能继续工作,否则不抛出异常,他会认为这个操作是正确的! 或者你手动回滚也成: DbKit.getConfig().getConnection().rollback(); 引用来自“天王盖地虎626”的评论 可是我抛出异常也没用呀,呜呜 如果你抛出也没用,如果你手动回滚也无用,,,,,如果你正好用的是mysql,请检查数据库引擎是不是InnoDB ,,,,,mysql默认的主引擎 MyISAM是不支持事务的!######再确认一下 @Before(Tx.class) 是否是用在 Controller 之上的######@Before(Tx.class)注释必须是加载Controller之上的吗?###### 引用来自“aqu”的评论 手动捕获异常的时候,要继续抛出,jfinal事务才能继续工作,否则不抛出异常,他会认为这个操作是正确的! 或者你手动回滚也成: DbKit.getConfig().getConnection().rollback(); 可是我抛出异常也没用呀,呜呜###### 正确做法是不是去掉try{}catch()就可以了? 这样异常就会正常抛出 ######no try catch no throws ######如果对事务方面比较关心 可以看下 http://my.oschina.net/idreamblue/blog/388875###### 引用来自“JFinal”的评论 再确认一下 @Before(Tx.class) 是否是用在 Controller 之上的 比如我是这样用的: @Before(AuthInterceptor.class) public class MyCreditManagerAction extends BoxAction { @Before(Tx.class)  public void updateCreditInfo()  throws Exception{ try{ 。。。 hydLoanLog.save(); 。。。 hydLoan.save(); }catch(Exception e){ throw new Exception("出错了"); } } } 我目前的情况,类似这样的写法,如果第2个操作数据库出现错误,但是第一个操作数据库正常的话,发现数据保存成功了第一个,却没有一起回滚到初始状态。 ######注意一下事务级别,调高到 4 ,还要注意一下引擎是否为 InnoDB###### 引用来自“天王盖地虎626”的评论 引用来自“JFinal”的评论 再确认一下 @Before(Tx.class) 是否是用在 Controller 之上的 比如我是这样用的: @Before(AuthInterceptor.class) public class MyCreditManagerAction extends BoxAction { @Before(Tx.class)  public void updateCreditInfo()  throws Exception{ try{ 。。。 hydLoanLog.save(); 。。。 hydLoan.save(); }catch(Exception e){ throw new Exception("出错了"); } } } 我目前的情况,类似这样的写法,如果第2个操作数据库出现错误,但是第一个操作数据库正常的话,发现数据保存成功了第一个,却没有一起回滚到初始状态。 从图片上看,应该是InnoDB,而且事务级别也是4 ActiveRecordPlugin arp = new ActiveRecordPlugin("otherConfig",druidPlugin); arp.setTransactionLevel(4);但是事务回滚就是没有效果,而且甚至debug了Tx.java类,程序也确实走到了conn.rollback(); 理论上说,我的代码写法应该没有问题,已经起到事务效果了,但是,数据库里数据依然不能保持一致,难不成,数据库这边还有什么要调整吗?    

优选2 2020-06-05 11:32:16 0 浏览量 回答数 0

回答

声明引用变量(即对象)时,实际上是在创建指向对象的指针。考虑以下代码,您在其中声明基本类型的变量int: int x; x = 10; 在此示例中,变量x是an int,Java会0为您初始化它。在10第二行为其分配值时,您的值将10写入所指的存储位置x。 但是,当您尝试声明引用类型时,会发生一些不同的事情。采取以下代码: Integer num; num = new Integer(10); 第一行声明了一个名为的变量num,但实际上尚未包含原始值。相反,它包含一个指针(因为类型是Integer引用类型)。由于您尚未说出要指向的内容,因此Java将其设置为null,表示“ 我什么都没有指向 ”。 在第二行中,new关键字用于实例化(或创建)一个类型的对象,Integer并将指针变量num分配给该Integer对象。 在NullPointerException当你声明一个变量,但没有创建对象时发生。因此,您指向的是实际上不存在的东西。 如果num在创建对象之前尝试取消引用,则会显示NullPointerException。在大多数情况下,编译器会发现问题,并让您知道“” num may not have been initialized,但是有时您可能会编写不直接创建对象的代码。 例如,您可能具有如下方法: public void doSomething(SomeObject obj) { //do something to obj } 在这种情况下,您不是在创建对象obj,而是假设它是在doSomething()调用方法之前创建的。注意,可以这样调用方法: doSomething(null); 在这种情况下obj为null。如果该方法旨在对传入的对象做某事,则最好抛出,NullPointerException因为这是程序员错误,程序员将需要该信息来进行调试。 替代地,在某些情况下,该方法的目的不仅是要对传入的对象进行操作,因此null参数是可以接受的。在这种情况下,您将需要检查null参数并改变行为。您还应该在文档中对此进行解释。例如,doSomething()可以写成: /** * @param obj An optional foo for ____. May be null, in which case * the result will be ____. */ public void doSomething(SomeObject obj) { if(obj != null) { //do something } else { //do something else } } 最后,如何使用堆栈跟踪来查明异常和原因 可以使用哪些方法/工具确定原因,以阻止异常导致程序过早终止? 带有findbug的声纳可以检测NPE。 声纳能否动态捕获由JVM引起的空指针异常

垚tutu 2019-12-02 03:23:42 0 浏览量 回答数 0

问题

【推荐】Windows系统异常重启以及蓝屏的处理方法是什么

boxti 2019-12-01 22:06:15 1737 浏览量 回答数 0

问题

【推荐】Windows虚拟内存不足问题的处理方法是什么

boxti 2019-12-01 22:06:24 3441 浏览量 回答数 0

回答

第一种OutOfMemoryError: PermGen space发生这种问题的原意是程序中使用了大量的jar或class,使java虚拟机装载类的空间不够,与Permanent Generation space有关。解决这类问题有以下两种办法:增加java虚拟机中的XX:PermSize和XX:MaxPermSize参数的大小,其中XX:PermSize是初始永久保存区域大小,XX:MaxPermSize是最大永久保存区域大小。如针对tomcat6.0,在catalina.sh 或catalina.bat文件中一系列环境变量名说明结束处(大约在70行左右) 增加一行: JAVA_OPTS=" -XX:PermSize=64M -XX:MaxPermSize=128m" 如果是windows服务器还可以在系统环境变量中设置。感觉用tomcat发布sprint+struts+hibernate架构的程序时很容易发生这种内存溢出错误。使用上述方法,我成功解决了部署ssh项目的tomcat服务器经常宕机的问题。清理应用程序中web-inf/lib下的jar,如果tomcat部署了多个应用,很多应用都使用了相同的jar,可以将共同的jar移到tomcat共同的lib下,减少类的重复加载。这种方法是网上部分人推荐的,我没试过,但感觉减少不了太大的空间,最靠谱的还是第一种方法。第二种OutOfMemoryError: Java heap space发生这种问题的原因是java虚拟机创建的对象太多,在进行垃圾回收之间,虚拟机分配的到堆内存空间已经用满了,与Heap space有关。解决这类问题有两种思路:检查程序,看是否有死循环或不必要地重复创建大量对象。找到原因后,修改程序和算法。 我以前写一个使用K-Means文本聚类算法对几万条文本记录(每条记录的特征向量大约10来个)进行文本聚类时,由于程序细节上有问题,就导致了Java heap space的内存溢出问题,后来通过修改程序得到了解决。增加Java虚拟机中Xms(初始堆大小)和Xmx(最大堆大小)参数的大小。如:set JAVA_OPTS= -Xms256m -Xmx1024m第三种OutOfMemoryError:unable to create new native thread在java应用中,有时候会出现这样的错误:OutOfMemoryError: unable to create new native thread.这种怪事是因为JVM已经被系统分配了大量的内存(比如1.5G),并且它至少要占用可用内存的一半。有人发现,在线程个数很多的情况下,你分配给JVM的内存越多,那么,上述错误发生的可能性就越大。那么是什么原因造成这种问题呢?每一个32位的进程最多可以使用2G的可用内存,因为另外2G被操作系统保留。这里假设使用1.5G给JVM,那么还余下500M可用内存。这500M内存中的一部分必须用于系统dll的加载,那么真正剩下的也许只有400M,现在关键的地方出现了:当你使用Java创建一个线程,在JVM的内存里也会创建一个Thread对象,但是同时也会在操作系统里创建一个真正的物理线程(参考JVM规范),操作系统会在余下的400兆内存里创建这个物理线程,而不是在JVM的1500M的内存堆里创建。在jdk1.4里头,默认的栈大小是256KB,但是在jdk1.5里头,默认的栈大小为1M每线程,因此,在余下400M的可用内存里边我们最多也只能创建400个可用线程。这样结论就出来了,要想创建更多的线程,你必须减少分配给JVM的最大内存。还有一种做法是让JVM宿主在你的JNI代码里边。给出一个有关能够创建线程的最大个数的估算公式:(MaxProcessMemory - JVMMemory - ReservedOsMemory) / (ThreadStackSize) = Number of threads对于jdk1.5而言,假设操作系统保留120M内存:1.5GB JVM: (2GB-1.5Gb-120MB)/(1MB) = ~380 threads1.0GB JVM: (2GB-1.0Gb-120MB)/(1MB) = ~880 threads对于栈大小为256KB的jdk1.4而言,1.5GB allocated to JVM: ~1520 threads1.0GB allocated to JVM: ~3520 threads 对于这个异常我们首先需要判断下,发生内存溢出时进程中到底都有什么样的线程,这些线程是否是应该存在的,是否可以通过优化来降低线程数; 另外一方面默认情况下java为每个线程分配的栈内存大小是1M,通常情况下,这1M的栈内存空间是足足够用了,因为在通常在栈上存放的只是基础类型的数据或者对象的引用,这些东西都不会占据太大的内存, 我们可以通过调整jvm参数,降低为每个线程分配的栈内存大小来解决问题,例如在jvm参数中添加-Xss128k将线程栈内存大小设置为128k。

蛮大人123 2019-12-02 02:27:59 0 浏览量 回答数 0

回答

final   在java中,final可以用来修饰类,方法和变量(成员变量或局部变量)。下面将对其详细介绍。 1.1 修饰类   当用final修饰类的时,表明该类不能被其他类所继承。当我们需要让一个类永远不被继承,此时就可以用final修饰,但要注意: final类中所有的成员方法都会隐式的定义为final方法。 1.2 修饰方法 使用final方法的原因主要有两个:   (1) 把方法锁定,以防止继承类对其进行更改。   (2) 效率,在早期的java版本中,会将final方法转为内嵌调用。但若方法过于庞大,可能在性能上不会有多大提升。因此在最近版本中,不需要final方法进行这些优化了。 final方法意味着“最后的、最终的”含义,即此方法不能被重写。 注意:若父类中final方法的访问权限为private,将导致子类中不能直接继承该方法,因此,此时可以在子类中定义相同方法名的函数,此时不会与重写final的矛盾,而是在子类中重新地定义了新方法。复制代码 class A{ private final void getName(){ } } public class B extends A{ public void getName(){ } public static void main(String[]args){ System.out.println("OK"); } } 复制代码    1.3 修饰变量   final成员变量表示常量,只能被赋值一次,赋值后其值不再改变。类似于C++中的const。   当final修饰一个基本数据类型时,表示该基本数据类型的值一旦在初始化后便不能发生变化;如果final修饰一个引用类型时,则在对其初始化之后便不能再让其指向其他对象了,但该引用所指向的对象的内容是可以发生变化的。本质上是一回事,因为引用的值是一个地址,final要求值,即地址的值不发生变化。    final修饰一个成员变量(属性),必须要显示初始化。这里有两种初始化方式,一种是在变量声明的时候初始化;第二种方法是在声明变量的时候不赋初值,但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。   当函数的参数类型声明为final时,说明该参数是只读型的。即你可以读取使用该参数,但是无法改变该参数的值。       在java中,String被设计成final类,那为什么平时使用时,String的值可以被改变呢?   字符串常量池是java堆内存中一个特殊的存储区域,当我们建立一个String对象时,假设常量池不存在该字符串,则创建一个,若存在则直接引用已经存在的字符串。当我们对String对象值改变的时候,例如 String a="A"; a="B" 。a是String对象的一个引用(我们这里所说的String对象其实是指字符串常量),当a=“B”执行时,并不是原本String对象("A")发生改变,而是创建一个新的对象("B"),令a引用它。 finally   finally作为异常处理的一部分,它只能用在try/catch语句中,并且附带一个语句块,表示这段语句最终一定会被执行(不管有没有抛出异常),经常被用在需要释放资源的情况下。(×)(这句话其实存在一定的问题)   很多人都认为finally语句块一定会执行,但真的是这样么?答案是否定的,例如下面这个例子:      当我们去掉注释的三行语句,执行结果为:      为什么在以上两种情况下都没有执行finally语句呢,说明什么问题?   只有与finally对应的try语句块得到执行的情况下,finally语句块才会执行。以上两种情况在执行try语句块之前已经返回或抛出异常,所以try对应的finally语句并没有执行。   但是,在某些情况下,即使try语句执行了,finally语句也不一定执行。例如以下情况:      finally 语句块还是没有执行,为什么呢?因为我们在 try 语句块中执行了 System.exit (0) 语句,终止了 Java 虚拟机的运行。那有人说了,在一般的 Java 应用中基本上是不会调用这个 System.exit(0) 方法的。OK !没有问题,我们不调用 System.exit(0) 这个方法,那么 finally 语句块就一定会执行吗?   再一次让大家失望了,答案还是否定的。当一个线程在执行 try 语句块或者 catch 语句块时被打断(interrupted)或者被终止(killed),与其相对应的 finally 语句块可能不会执行。还有更极端的情况,就是在线程运行 try 语句块或者 catch 语句块时,突然死机或者断电,finally 语句块肯定不会执行了。可能有人认为死机、断电这些理由有些强词夺理,没有关系,我们只是为了说明这个问题。 易错点   在try-catch-finally语句中执行return语句。我们看如下代码:      答案:4,4,4 。 为什么呢?   首先finally语句在改代码中一定会执行,从运行结果来看,每次return的结果都是4(即finally语句),仿佛其他return语句被屏蔽掉了。   事实也确实如此,因为finally用法特殊,所以会撤销之前的return语句,继续执行最后的finally块中的代码。    finalize     finalize()是在java.lang.Object里定义的,也就是说每一个对象都有这么个方法。这个方法在gc启动,该对象被回收的时候被调用。其实gc可以回收大部分的对象(凡是new出来的对象,gc都能搞定,一般情况下我们又不会用new以外的方式去创建对象),所以一般是不需要程序员去实现finalize的。 特殊情况下,需要程序员实现finalize,当对象被回收的时候释放一些资源,比如:一个socket链接,在对象初始化时创建,整个生命周期内有效,那么就需要实现finalize,关闭这个链接。   使用finalize还需要注意一个事,调用super.finalize();   一个对象的finalize()方法只会被调用一次,而且finalize()被调用不意味着gc会立即回收该对象,所以有可能调用finalize()后,该对象又不需要被回收了,然后到了真正要被回收的时候,因为前面调用过一次,所以不会调用finalize(),产生问题。 所以,推荐不要使用finalize()方法,它跟析构函数不一样。

wangccsy 2019-12-02 01:48:34 0 浏览量 回答数 0

问题

C++面向对象【问答合集】

马铭芳 2019-12-01 20:19:13 1780 浏览量 回答数 1

回答

我们都知道JVM的内存管理是自动化的,Java语言的程序指针也不需要开发人员手工释放,JVM的GC会自动的进行回收,但是,如果编程不当,JVM仍然会发生内存泄露,导致Java程序产生了OutOfMemoryError(OOM)错误。 产生OutOfMemoryError错误的原因包括: java.lang.OutOfMemoryError: Java heap spacejava.lang.OutOfMemoryError: PermGen space及其解决方法java.lang.OutOfMemoryError: unable to create new native threadjava.lang.OutOfMemoryError:GC overhead limit exceeded对于第1种异常,表示Java堆空间不够,当应用程序申请更多的内存,而Java堆内存已经无法满足应用程序对内存的需要,将抛出这种异常。 对于第2种异常,表示Java永久带(方法区)空间不够,永久带用于存放类的字节码和长常量池,类的字节码加载后存放在这个区域,这和存放对象实例的堆区是不同的,大多数JVM的实现都不会对永久带进行垃圾回收,因此,只要类加载的过多就会出现这个问题。一般的应用程序都不会产生这个错误,然而,对于Web服务器来讲,会产生有大量的JSP,JSP在运行时被动态的编译成Java Servlet类,然后加载到方法区,因此,太多的JSP的Web工程可能产生这个异常。 对于第3种异常,本质原因是创建了太多的线程,而能创建的线程数是有限制的,导致了这种异常的发生。 对于第4种异常,是在并行或者并发回收器在GC回收时间过长、超过98%的时间用来做GC并且回收了不到2%的堆内存,然后抛出这种异常进行提前预警,用来避免内存过小造成应用不能正常工作。 下面两个异常与OOM有关系,但是,又没有绝对关系。 java.lang.StackOverflowError ...java.net.SocketException: Too many open files对于第1种异常,是JVM的线程由于递归或者方法调用层次太多,占满了线程堆栈而导致的,线程堆栈默认大小为1M。 对于第2种异常,是由于系统对文件句柄的使用是有限制的,而某个应用程序使用的文件句柄超过了这个限制,就会导致这个问题。 上面介绍了OOM相关的基础知识,接下来我们开始讲述笔者经历的一次OOM问题的定位和解决的过程。 产生问题的现象 在某一段时间内,我们发现不同的业务服务开始偶发的报OOM的异常,有的时候是白天发生,有的时候是晚上发生,有的时候是基础服务A发生,有的时候是上层服务B发生,有的时候是上层服务C发生,有的时候是下层服务D发生,丝毫看不到一点规律。 产生问题的异常如下: Caused by: java.lang.OutOfMemoryError: unable to create new native thread at java.lang.Thread.start0(Native Method)at java.lang.Thread.start(Thread.java:597)at java.util.Timer.(Timer.java:154) 解决问题的思路和过程 经过细心观察发现,产生问题虽然在不同的时间发生在不同的服务池,但是,晚上0点发生的时候概率较大,也有其他时间偶发,但是都在整点。 这个规律很重要,虽然不是一个时间,但是基本都在整点左右发生,并且晚上0点居多。从这个角度思考,整点或者0点系统是否有定时,与出问题的每个业务系统技术负责人核实,0点没有定时任务,其他时间的整点有定时任务,但是与发生问题的时间不吻合,这个思路行不通。 到现在为止,从现象的规律上我们已经没法继续分析下去了,那我们回顾一下错误本身: java.lang.OutOfMemoryError: unable to create new native thread 顾名思义,错误产生的原因就是应用不能创建线程了,但是,应用还需要创建线程。为什么程序不能创建线程呢? 有两个具体原因造成这个异常: 由于线程使用的资源过多,操作系统已经不能再提供给应用资源了。操作系统设置了应用创建线程的最大数量,并且已经达到了最大允许数量。上面第1条资源指的是内存,而第2条中,在Linux下线程使用轻量级进程实现的,因此线程的最大数量也是操作系统允许的进程的最大数量。 内存计算 操作系统中的最大可用内存除去操作系统本身使用的部分,剩下的都可以为某一个进程服务,在JVM进程中,内存又被分为堆、本地内存和栈等三大块,Java堆是JVM自动管理的内存,应用的对象的创建和销毁、类的装载等都发生在这里,本地内存是Java应用使用的一种特殊内存,JVM并不直接管理其生命周期,每个线程也会有一个栈,是用来存储线程工作过程中产生的方法局部变量、方法参数和返回值的,每个线程对应的栈的默认大小为1M。 Linux和JVM的内存管理示意图如下: 内存结构模型因此,从内存角度来看创建线程需要内存空间,如果JVM进程正当一个应用创建线程,而操作系统没有剩余的内存分配给此JVM进程,则会抛出问题中的OOM异常:unable to create new native thread。 如下公式可以用来从内存角度计算允许创建的最大线程数: 最大线程数 = (操作系统最大可用内存 - JVM内存 - 操作系统预留内存)/ 线程栈大小 根据这个公式,我们可以通过剩余内存计算可以创建线程的数量。 下面是问题出现的时候,从生产机器上执行前面小节介绍的Linux命令free的输出: free -m >> /tmp/free.log total used free shared buffers cached Mem: 7872 7163 709 0 31 3807-/+ buffers/cache: 3324 4547Swap: 4095 173 3922Tue Jul 5 00:27:51 CST 2016从上面输出可以得出,生产机器8G内存,使用了7G,剩余700M可用,其中操作系统cache使用3.8G。操作系统cache使用的3.8G是用来缓存IO数据的,如果进程内存不够用,这些内存是可以释放出来优先分配给进程使用。然而,我们暂时并不需要考虑这块内存,剩余的700M空间完全可以继续用来创建线程数: 700M / 1M = 700个线程 因此,根据内存可用计算,当OOM异常:unable to create new native thread问题发生的时候,还有700M可用内存,可以创建700个线程。 到现在为止可以证明此次OOM异常不是因为线程吃光所有的内存而导致的。 线程数对比 上面提到,有两个具体原因造成这个异常,我们上面已经排除了第1个原因,那我们现在从第2个原因入手,评估是否操作系统设置了应用创建线程的最大数量,并且已经达到了最大允许数量。 在问题出现的生产机器上使用ulimit -a来显示当前的各种系统对用户使用资源的限制: robert@robert-ubuntu1410:~$ ulimit -acore file size (blocks, -c) 0data seg size (kbytes, -d) unlimitedscheduling priority (-e) 0file size (blocks, -f) unlimitedpending signals (-i) 62819max locked memory (kbytes, -l) 64max memory size (kbytes, -m) unlimitedopen files (-n) 65535pipe size (512 bytes, -p) 8POSIX message queues (bytes, -q) 819200real-time priority (-r) 0stack size (kbytes, -s) 10240cpu time (seconds, -t) unlimitedmax user processes (-u) 1024virtual memory (kbytes, -v) unlimitedfile locks (-x) unlimited这里面我们看到生产机器设置的允许使用的最大用户进程数为1024: max user processes (-u) 1024现在,我们必须获得问题出现的时候,用户下创建的线程情况。 在问题产生的时候,我们使用前面小结介绍的JVM监控命令jstack命令打印出了Java线程情况,jstack命令的示例输出如下: robert@robert-ubuntu1410:~$ jstack 27432017-04-09 12:06:51Full thread dump Java HotSpot(TM) Server VM (25.20-b23 mixed mode): "Attach Listener" #23 daemon prio=9 os_prio=0 tid=0xc09adc00 nid=0xb4c waiting on condition [0x00000000] java.lang.Thread.State: RUNNABLE "http-nio-8080-Acceptor-0" #22 daemon prio=5 os_prio=0 tid=0xc3341000 nid=0xb02 runnable [0xbf1bd000] java.lang.Thread.State: RUNNABLE at sun.nio.ch.ServerSocketChannelImpl.accept0(Native Method) at sun.nio.ch.ServerSocketChannelImpl.accept(ServerSocketChannelImpl.java:241) - locked <0xcf8938d8> (a java.lang.Object) at org.apache.tomcat.util.net.NioEndpoint$Acceptor.run(NioEndpoint.java:688) at java.lang.Thread.run(Thread.java:745) "http-nio-8080-ClientPoller-1" #21 daemon prio=5 os_prio=0 tid=0xc35bc400 nid=0xb01 runnable [0xbf1fe000] java.lang.Thread.State: RUNNABLE at sun.nio.ch.EPollArrayWrapper.epollWait(Native Method) at sun.nio.ch.EPollArrayWrapper.poll(EPollArrayWrapper.java:269) at sun.nio.ch.EPollSelectorImpl.doSelect(EPollSelectorImpl.java:79) at sun.nio.ch.SelectorImpl.lockAndDoSelect(SelectorImpl.java:86) - locked <0xcf99b100> (a sun.nio.ch.Util$2) - locked <0xcf99b0f0> (a java.util.Collections$UnmodifiableSet) - locked <0xcf99aff8> (a sun.nio.ch.EPollSelectorImpl) at sun.nio.ch.SelectorImpl.select(SelectorImpl.java:97) at org.apache.tomcat.util.net.NioEndpoint$Poller.run(NioEndpoint.java:1052) at java.lang.Thread.run(Thread.java:745) ......从jstack命令的输出并统计后,我们得知,JVM一共创建了904个线程,但是,这还没有到最大的进程限制1024。 robert@robert-ubuntu1410:~$ grep "Thread " js.log | wc -l 904 这是我们思考,除了JVM创建的应用层线程,JVM本身可能会有一些管理线程存在,而且操作系统内用户下可能也会有守护线程在运行。 我们继续从操作系统的角度来统计线程数,我们使用上面小结介绍的Linux操作系统命令pstack,并得到如下的输出: PID LWP USER %CPU %MEM CMD 1 1 root 0.0 0.0 /sbin/init 2 2 root 0.0 0.0 [kthreadd] 3 3 root 0.0 0.0 [migration/0] 4 4 root 0.0 0.0 [ksoftirqd/0] 5 5 root 0.0 0.0 [migration/0] 6 6 root 0.0 0.0 [watchdog/0] 7 7 root 0.0 0.0 [migration/1] 8 8 root 0.0 0.0 [migration/1] 9 9 root 0.0 0.0 [ksoftirqd/1] 10 10 root 0.0 0.0 [watchdog/1] 11 11 root 0.0 0.0 [migration/2] 12 12 root 0.0 0.0 [migration/2] 13 13 root 0.0 0.0 [ksoftirqd/2] 14 14 root 0.0 0.0 [watchdog/2] 15 15 root 0.0 0.0 [migration/3] 16 16 root 0.0 0.0 [migration/3] 17 17 root 0.0 0.0 [ksoftirqd/3] 18 18 root 0.0 0.0 [watchdog/3] 19 19 root 0.0 0.0 [events/0] 20 20 root 0.0 0.0 [events/1] 21 21 root 0.0 0.0 [events/2] 22 22 root 0.0 0.0 [events/3] 23 23 root 0.0 0.0 [cgroup] 24 24 root 0.0 0.0 [khelper] ...... 7257 7257 zabbix 0.0 0.0 /usr/local/zabbix/sbin/zabbix_agentd: active checks #2 [idle 1 sec] 7258 7258 zabbix 0.0 0.0 /usr/local/zabbix/sbin/zabbix_agentd: active checks #3 [idle 1 sec] 7259 7259 zabbix 0.0 0.0 /usr/local/zabbix/sbin/zabbix_agentd: active checks #4 [idle 1 sec] ...... 9040 9040 app 0.0 30.5 /apps/prod/jdk1.6.0_24/bin/java -Dnop -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Ddbconfigpath=/apps/dbconfig/ -Djava.io.tmpdir=/apps/data/java-tmpdir -server -Xms2048m -Xmx2048m -XX:PermSize=128m -XX:MaxPermSize=512m -Dcom.sun.management.jmxremote -Djava.rmi.server.hostname=192.168.10.194 -Dcom.sun.management.jmxremote.port=6969 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp -Xshare:off -Dhostname=sjsa-trade04 -Djute.maxbuffer=41943040 -Djava.net.preferIPv4Stack=true -Dfile.encoding=UTF-8 -Dworkdir=/apps/data/tomcat-work -Djava.endorsed.dirs=/apps/product/tomcat-trade/endorsed -classpath commonlib:/apps/product/tomcat-trade/bin/bootstrap.jar:/apps/product/tomcat-trade/bin/tomcat-juli.jar -Dcatalina.base=/apps/product/tomcat-trade -Dcatalina.home=/apps/product/tomcat-trade -Djava.io.tmpdir=/apps/data/tomcat-temp/ org.apache.catalina.startup.Bootstrap start 9040 9041 app 0.0 30.5 /apps/prod/jdk1.6.0_24/bin/java -Dnop -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Ddbconfigpath=/apps/dbconfig/ -Djava.io.tmpdir=/apps/data/java-tmpdir -server -Xms2048m -Xmx2048m -XX:PermSize=128m -XX:MaxPermSize=512m -Dcom.sun.management.jmxremote -Djava.rmi.server.hostname=192.168.10.194 -Dcom.sun.management.jmxremote.port=6969 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp -Xshare:off -Dhostname=sjsa-trade04 -Djute.maxbuffer=41943040 -Djava.net.preferIPv4Stack=true -Dfile.encoding=UTF-8 -Dworkdir=/apps/data/tomcat-work -Djava.endorsed.dirs=/apps/product/tomcat-trade/endorsed -classpath commonlib:/apps/product/tomcat-trade/bin/bootstrap.jar:/apps/product/tomcat-trade/bin/tomcat-juli.jar -Dcatalina.base=/apps/product/tomcat-trade -Dcatalina.home=/apps/product/tomcat-trade -Djava.io.tmpdir=/apps/data/tomcat-temp/ org.apache.catalina.startup.Bootstrap start ......通过命令统计用户下已经创建的线程数为1021。 $ grep app pthreads.log | wc -l 1021 现在我们确定,1021的数字已经相当的接近1021的最大进程数了,正如前面我们提到,在Linux操作系统里,线程是通过轻量级的进程实现的,因此,限制用户的最大进程数,就是限制用户的最大线程数,至于为什么没有精确达到1024这个最大值就已经报出异常,应该是系统的自我保护功能,在还剩下3个线程的前提下,就开始报错。 到此为止,我们已经通过分析来找到问题的原因,但是,我们还是不知道为什么会创建这么多的线程,从第一个输出得知,JVM已经创建的应用线程有907个,那么他们都在做什么事情呢? 于是,在问题发生的时候,我们又使用JVM的jstack命令,查看输出得知,每个线程都阻塞在打印日志的语句上,log4j中打印日志的代码实现如下: public void callAppenders(LoggingEvent event) { int writes = 0; for(Category c = this; c != null; c=c.parent) { // Protected against simultaneous call to addAppender, removeAppender,... synchronized(c) { if(c.aai != null) { writes += c.aai.appendLoopOnAppenders(event); } if(!c.additive) { break; } } } if(writes == 0) { repository.emitNoAppenderWarning(this); } }在log4j中,打印日志有一个锁,锁的作用是让打印日志可以串行,保证日志在日志文件中的正确性和顺序性。 那么,新的问题又来了,为什么只有凌晨0点会出现打印日志阻塞,其他时间会偶尔发生呢?这时,我们带着新的线索又回到问题开始的思路,凌晨12点应用没有定时任务,系统会不会有其他的IO密集型的任务,比如说归档日志、磁盘备份等? 经过与运维部门碰头,基本确定是每天凌晨0点日志切割导致磁盘IO被占用,于是堵塞打印日志,日志是每个工作任务都必须的,日志阻塞,线程池就阻塞,线程池阻塞就导致线程池被撑大,线程池里面的线程数超过1024就会报错。 到这里,我们基本确定了问题的原因,但是还需要对日志切割导致IO增大进行分析和论证。 首先我们使用前面小结介绍的vmstat查看问题发生时IO等待数据: vmstat 2 1 >> /tmp/vm.logprocs -----------memory---------- ---swap-- -----io---- --system-- -----cpu----- r b swpd free buff cache si so bi bo in cs us sy id wa st 3 0 177608 725636 31856 3899144 0 0 2 10 0 0 39 1 1 59 0 Tue Jul 5 00:27:51 CST 2016可见,问题发生的时候,CPU的IO等待为59%,同时又与运维部门同事复盘,运维同事确认,脚本切割通过cat命令方法,先把日志文件cat后,通过管道打印到另外一个文件,再清空原文件,因此,一定会导致IO的上升。 其实,问题的过程中,还有一个疑惑,我们认为线程被IO阻塞,线程池被撑开,导致线程增多,于是,我们查看了一下Tomcat线程池的设置,我们发现Tomcat线程池设置了800,按理说,永远不会超过1024。 maxThreads="800" minSpareThreads="25" maxSpareThreads="75" enableLookups="false" redirectPort="8443" acceptCount="100" debug="0" connectionTimeout="20000" disableUploadTimeout="true" /> 关键在于,笔者所在的支付平台服务化架构中,使用了两套服务化框架,一个是基于dubbo的框架,一个是点对点的RPC,用来紧急情况下dubbo服务出现问题,服务降级使用。 每个服务都配置了点对点的RPC服务,并且独享一个线程池: maxThreads="800" minSpareThreads="25" maxSpareThreads="75" enableLookups="false" redirectPort="8443" acceptCount="100" debug="0" connectionTimeout="20000" disableUploadTimeout="true" /> 由于我们在对dubbo服务框架进行定制化的时候,设计了自动降级原则,如果dubbo服务负载变高,会自动切换到点对点的RPC框架,这也符合微服务的失效转移原则,但是设计中没有进行全面的考虑,一旦一部分服务切换到了点对点的RPC,而一部分的服务没有切换,就导致两个现场池都被撑满,于是超过了1024的限制,就出了问题。 到这里,我们基本可以验证,问题的根源是日志切割导致IO负载增加,然后阻塞线程池,最后发生OOM:unable to create new native thread。 剩下的任务就是最小化重现的问题,通过实践来验证问题的原因。我们与性能压测部门沟通,提出压测需求: Tomcat线程池最大设置为1500.操作系统允许的最大用户进程数1024.在给服务加压的过程中,需要人工制造繁忙的IO操作,IO等待不得低于50%。经过压测压测部门的一下午努力,环境搞定,结果证明完全可以重现此问题。 最后,与所有相关部门讨论和复盘,应用解决方案,解决方案包括: 全部应用改成按照小时切割,或者直接使用log4j的日志滚动功能。Tomcat线程池的线程数设置与操作系统的线程数设置不合理,适当的减少Tomcat线程池线程数量的大小。升级log4j日志,使用logback或者log4j2。这次OOM问题的可以归结为“多个因、多个果、多台机器、多个服务池、不同时间”,针对这个问题,与运维部、监控部和性能压测部门的同事奋斗了几天几夜,终于通过在线上抓取信息、分析问题、在性能压测部门同事的帮助下,最小化重现问题并找到问题的根源原因,最后,针对问题产生的根源提供了有效的方案。 与监控同事现场编写的脚本 本节提供一个笔者在实践过程中解决OOM问题的一个简单脚本,这个脚本是为了解决OOM(unable to create native thread)的问题而在问题机器上临时编写,并临时使用的,脚本并没有写的很专业,笔者也没有进行优化,保持原汁原味的风格,这样能让读者有种身临其境的感觉,只是为了抓取需要的信息并解决问题,但是在线上问题十分火急的情况下,这个脚本会有大用处。 !/bin/bash ps -Leo pid,lwp,user,pcpu,pmem,cmd >> /tmp/pthreads.logecho "ps -Leo pid,lwp,user,pcpu,pmem,cmd >> /tmp/pthreads.log" >> /tmp/pthreads.logecho date >> /tmp/pthreads.logecho 1 pid=ps aux|grep tomcat|grep cwh|awk -F ' ' '{print $2}'echo 2 echo "pstack $pid >> /tmp/pstack.log" >> /tmp/pstack.logpstack $pid >> /tmp/pstack.logecho date >> /tmp/pstack.logecho 3 echo "lsof >> /tmp/sys-o-files.log" >> /tmp/sys-o-files.loglsof >> /tmp/sys-o-files.logecho date >> /tmp/sys-o-files.logecho 4 echo "lsof -p $pid >> /tmp/service-o-files.log" >> /tmp/service-o-files.loglsof -p $pid >> /tmp/service-o-files.logecho date >> /tmp/service-o-files.logecho 5 echo "jstack -l $pid >> /tmp/js.log" >> /tmp/js.logjstack -l -F $pid >> /tmp/js.logecho date >> /tmp/js.logecho 6 echo "free -m >> /tmp/free.log" >> /tmp/free.logfree -m >> /tmp/free.logecho date >> /tmp/free.logecho 7 echo "vmstat 2 1 >> /tmp/vm.log" >> /tmp/vm.logvmstat 2 1 >> /tmp/vm.logecho date >> /tmp/vm.logecho 8 echo "jmap -dump:format=b,file=/tmp/heap.hprof 2743" >> /tmp/jmap.logjmap -dump:format=b,file=/tmp/heap.hprof >> /tmp/jmap.logecho date >> /tmp/jmap.logecho 9 echo end

hiekay 2019-12-02 01:39:43 0 浏览量 回答数 0

回答

从业余程序员到职业程序员 程序员刚入行时,我觉得最重要的是把自己培养成职业的程序员。 我的程序员起步比同龄人都晚了很多,更不用说现在的年轻人了。我大学读的是生物专业,在上大学前基本算是完全没接触过计算机。军训的时候因为很无聊,我和室友每天跑去学校的机房玩,我现在还印象很深刻,我第一次走进机房的时候,别人问,你是要玩windows,还是dos,我那是完全的一抹黑。后来就只记得在机房一堆人都是在练习盲打,军训完,盲打倒是练的差不多了,对计算机就这么产生了浓厚的兴趣,大一的时候都是玩组装机,捣鼓了一些,对计算机的硬件有了那么一些了解。 到大二后,买了一些书开始学习当时最火的网页三剑客,学会了手写HTML、PS的基本玩法之类的,课余、暑假也能开始给人做做网站什么的(那个时候做网站真的好赚钱),可能那样过了个一年左右,做静态的网页就不好赚钱了,也不好找实习工作,于是就开始学asp,写些简单的CRUD,做做留言板、论坛这些动态程序,应该算是在这个阶段接触编程了。 毕业后加入了深圳的一家做政府行业软件的公司,一个非常靠谱和给我空间的Leader,使得自己在那几年有了不错的成长,终于成了一个职业的程序员。 通常来说,业余或半职业的程序员,多数是1个人,或者很小的一个团队一起开发,使得在开发流程、协作工具(例如jira、cvs/svn/git等)、测试上通常会有很大的欠缺,而职业的程序员在这方面则会专业很多。另外,通常职业的程序员做的系统都要运行较长的时间,所以在可维护性上会特别注意,这点我是在加入阿里后理解更深的。一个运行10年的系统,和一个写来玩玩的系统显然是有非常大差别的。 这块自己感觉也很难讲清楚,只能说模模糊糊有个这样的概念。通常在有兴趣的基础上,从业余程序员跨越到成为职业程序员我觉得不会太难。 编程能力的成长 作为程序员,最重要的能力始终是编程能力,就我自己的感受而言,我觉得编程能力的成长主要有这么几个部分: 1、编程能力初级:会用 编程,首先都是从学习编程语言的基本知识学起的,不论是什么编程语言,有很多共同的基本知识,例如怎么写第一个Hello World、if/while/for、变量等,因此我比较建议在刚刚开始学一门编程语言的时候,看看编程语言自己的一些文档就好,不要上来就去看一些高阶的书。我当年学Java的时候上来就看Think in Java、Effective Java之类的,真心好难懂。 除了看文档以外,编程是个超级实践的活,所以一定要多写代码,只有这样才能真正熟练起来。这也是为什么我还是觉得在面试的时候让面试者手写代码是很重要的,这个过程是非常容易判断写代码的熟悉程度的。很多人会说由于写代码都是高度依赖IDE的,导致手写很难,但我绝对相信写代码写了很多的人,手写一段不太复杂的、可运行的代码是不难的。即使像我这种三年多没写过代码的人,让我现在手写一段不太复杂的可运行的Java程序,还是没问题的,前面N年的写代码生涯使得很多东西已经深入骨髓了。 我觉得编程能力初级这个阶段对于大部分程序员来说都不会是问题,勤学苦练,是这个阶段的核心。 2、编程能力中级:会查和避免问题 除了初级要掌握的会熟练的使用编程语言去解决问题外,中级我觉得首先是提升查问题的能力。 在写代码的过程中,出问题是非常正常的,怎么去有效且高效的排查问题,是程序员群体中通常能感受到的大家在编程能力上最大的差距。 解决问题能力强的基本很容易在程序员群体里得到很高的认可。在查问题的能力上,首先要掌握的是一些基本的调试技巧,好用的调试工具,在Java里有JDK自带的jstat、jmap、jinfo,不在JDK里的有mat、gperf、btrace等。工欲善其事必先利其器,在查问题上是非常典型的,有些时候大家在查问题时的能力差距,有可能仅仅是因为别人比你多知道一个工具而已。 除了调试技巧和工具外,查问题的更高境界就是懂原理。一个懂原理的程序员在查问题的水平上和其他程序员是有明显差距的。我想很多的同学应该能感受到,有些时候查出问题的原因仅仅是因为有效的工具,知其然不知其所以然。 我给很多阿里的同学培训过Java排查问题的方法,在这个培训里,我经常也会讲到查问题的能力的培养最主要的也是熟练,多尝试给自己写一些会出问题的程序,多积极的看别人是怎么查问题的,多积极的去参与排查问题,很多最后查问题能力强的人多数仅仅是因为“无他,但手熟尔”。 我自己排查问题能力的提升主要是在2009年和2010年。那两年作为淘宝消防队(处理各种问题和故障的虚拟团队)的成员,处理了很多的故障和问题。当时消防队还有阿里最公认的技术大神——多隆,我向他学习到了很多排查问题的技巧。和他比,我排查问题的能力就是初级的那种。 印象最深刻的是一次我们一起查一个应用cpu us高的问题,我们两定位到是一段代码在某种输入参数的时候会造成cpu us高的原因后,我能想到的继续查的方法是去生产环境抓输入参数,然后再用参数来本地debug看是什么原因。但多隆在看了一会那段代码后,给了我一个输入参数,我拿这个参数一运行,果然cpu us很高!这种case不是一次两次。所以我经常和别人说,我是需要有问题场景才能排查出问题的,但多隆是完全有可能直接看代码就能看出问题的,这是本质的差距。 除了查问题外,更厉害的程序员是在写代码的过程就会很好的去避免问题。大家最容易理解的就是在写代码时处理各种异常情况,这里通常也是造成程序员们之间很大的差距的地方。 写一段正向逻辑的代码,大部分情况下即使有差距,也不会太大,但在怎么很好的处理这个过程中有可能出现的异常上,这个时候的功力差距会非常明显。很多时候一段代码里处理异常逻辑的部分都会超过正常逻辑的代码量。 我经常说,一个优秀程序员和普通程序员的差距,很多时候压根就不需要看什么满天飞的架构图,而只用show一小段的代码就可以。 举一个小case大家感受下。当年有一个严重故障,最后查出的原因是输入的参数里有一个是数组,把这个数组里的值作为参数去查数据库,结果前面输入了一个很大的数组,导致从数据库查了大量的数据,内存溢出了,很多程序员现在看都会明白对入参、出参的保护check,但类似这样的case我真的碰到了很多。 在中级这个阶段,我会推荐大家尽可能的多刻意的去培养下自己这两个方面的能力,成为一个能写出高质量代码、有效排查问题的优秀程序员。 3、编程能力高级:懂高级API和原理 就我自己的经历而言,我是在写了多年的Java代码后,才开始真正更细致的学习和掌握Java的一些更高级的API,我相信多数Java程序员也是如此。 我算是从2003年开始用Java写商业系统的代码,但直到在2007年加入淘宝后,才开始非常认真地学习Java的IO通信、并发这些部分的API。尽管以前也学过也写过一些这样的代码,但完全就是皮毛。当然,这些通常来说有很大部分的原因会是工作的相关性,多数的写业务系统的程序员可能基本就不需要用到这些,所以导致会很难懂这些相对高级一些的API,但这些API对真正的理解一门编程语言,我觉得至关重要。 在之前的程序员成长路线的文章里我也讲到了这个部分,在没有场景的情况下,只能靠自己去创造场景来学习好。我觉得只要有足够的兴趣,这个问题还是不大的,毕竟现在有各种开源,这些是可以非常好的帮助自己创造机会学习的,例如学Java NIO,可以自己基于NIO包一个框架,然后对比Netty,看看哪些写的是不如Netty的,这样会非常有助于真正的理解。 在学习高级API的过程中,以及排查问题的过程中,我自己越来越明白懂编程语言的运行原理是非常重要的,因此我到了后面的阶段开始学习Java的编译机制、内存管理、线程机制等。对于我这种非科班出身的而言,学这些会因为缺乏基础更难很多,但这些更原理性的东西学会了后,对自己的编程能力会有质的提升,包括以后学习其他编程语言的能力,学这些原理最好的方法我觉得是先看看一些讲相关知识的书,然后去翻看源码,这样才能真正的更好的掌握,最后是在以后写代码的过程中、查问题的过程中多结合掌握的原理,才能做到即使在N年后也不会忘。 在编程能力的成长上,我觉得没什么捷径。我非常赞同1万小时理论,在中级、高级阶段,如果有人指点或和优秀的程序员们共事,会好非常多。不过我觉得这个和读书也有点像,到了一定阶段后(例如高中),天分会成为最重要的分水岭,不过就和大部分行业一样,大部分的情况下都还没到拼天分的时候,只需要拼勤奋就好。 系统设计能力的成长 除了少数程序员会进入专深的领域,例如Linux Kernel、JVM,其他多数的程序员除了编程能力的成长外,也会越来越需要在系统设计能力上成长。 通常一个编程能力不错的程序员,在一定阶段后就会开始承担一个模块的工作,进而承担一个子系统、系统、跨多领域的更大系统等。 我自己在工作的第三年开始承担一个流程引擎的设计和实现工作,一个不算小的系统,并且也是当时那个项目里的核心部分。那个阶段我学会了一些系统设计的基本知识,例如需要想清楚整个系统的目标、模块的划分和职责、关键的对象设计等,而不是上来就开始写代码。但那个时候由于我是一个人写整个系统,所以其实对设计的感觉并还没有那么强力的感觉。 在那之后的几年也负责过一些系统,但总体感觉好像在系统设计上的成长没那么多,直到在阿里的经历,在系统设计上才有了越来越多的体会。(点击文末阅读原文,查看:我在系统设计上犯过的14个错,可以看到我走的一堆的弯路)。 在阿里有一次做分享,讲到我在系统设计能力方面的成长,主要是因为三段经历,负责专业领域系统的设计 -> 负责跨专业领域的专业系统的设计 -> 负责阿里电商系统架构级改造的设计。 第一段经历,是我负责HSF。HSF是一个从0开始打造的系统,它主要是作为支撑服务化的框架,是个非常专业领域的系统,放在整个淘宝电商的大系统来看,其实它就是一个很小的子系统,这段经历里让我最深刻的有三点: 1).要设计好这种非常专业领域的系统,专业的知识深度是非常重要的。我在最早设计HSF的几个框的时候,是没有设计好服务消费者/提供者要怎么和现有框架结合的,在设计负载均衡这个部分也反复了几次,这个主要是因为自己当时对这个领域掌握不深的原因造成的; 2). 太技术化。在HSF的阶段,出于情怀,在有一个版本里投入了非常大的精力去引进OSGi以及去做动态化,这个后来事实证明是个非常非常错误的决定,从这个点我才真正明白在设计系统时一定要想清楚目标,而目标很重要的是和公司发展阶段结合; 3). 可持续性。作为一个要在生产环境持续运行很多年的系统而言,怎么样让其在未来更可持续的发展,这个对设计阶段来说至关重要。这里最low的例子是最早设计HSF协议的时候,协议头里竟然没有版本号,导致后来升级都特别复杂;最典型的例子是HSF在早期缺乏了缺乏了服务Tracing这方面的设计,导致后面发现了这个地方非常重要后,全部落地花了长达几年的时间;又例如HSF早期缺乏Filter Chain的设计,导致很多扩展、定制化做起来非常不方便。 第二段经历,是做T4。T4是基于LXC的阿里的容器,它和HSF的不同是,它其实是一个跨多领域的系统,包括了单机上的容器引擎,容器管理系统,容器管理系统对外提供API,其他系统或用户通过这个来管理容器。这个系统发展过程也是各种犯错,犯错的主要原因也是因为领域掌握不深。在做T4的日子里,学会到的最重要的是怎么去设计这种跨多个专业领域的系统,怎么更好的划分模块的职责,设计交互逻辑,这段经历对我自己更为重要的意义是我有了做更大一些系统的架构的信心。 第三段经历,是做阿里电商的异地多活。这对我来说是真正的去做一个巨大系统的架构师,尽管我以前做HSF的时候参与了淘宝电商2.0-3.0的重大技术改造,但参与和自己主导是有很大区别的,这个架构改造涉及到了阿里电商众多不同专业领域的技术团队。在这个阶段,我学会的最主要的: 1). 子系统职责划分。在这种超大的技术方案中,很容易出现某些部分的职责重叠和冲突,这个时候怎么去划分子系统,就非常重要了。作为大架构师,这个时候要从团队的职责、团队的可持续性上去选择团队; 2). 大架构师最主要的职责是控制系统风险。对于这种超大系统,一定是多个专业领域的架构师和大架构师共同设计,怎么确保在执行的过程中对于系统而言最重要的风险能够被控制住,这是我真正的理解什么叫系统设计文档里设计原则的部分。 设计原则我自己觉得就是用来确保各个子系统在设计时都会遵循和考虑的,一定不能是虚的东西,例如在异地多活架构里,最重要的是如何控制数据风险,这个需要在原则里写上,最基本的原则是可接受系统不可用,但也要保障数据一致,而我看过更多的系统设计里设计原则只是写写的,或者千篇一律的,设计原则切实的体现了架构师对目标的理解(例如当时异地多活这个其实开始只是个概念,但做到什么程度才叫做到异地多活,这是需要解读的,也要确保在技术层面的设计上是达到了目标的),技术方案层面上的选择原则,并确保在细节的设计方案里有对于设计原则的承接以及执行; 3). 考虑问题的全面性。像异地多活这种大架构改造,涉及业务层面、各种基础技术层面、基础设施层面,对于执行节奏的决定要综合考虑人力投入、机器成本、基础设施布局诉求、稳定性控制等,这会比只是做一个小的系统的设计复杂非常多。 系统设计能力的成长,我自己觉得最重要的一是先在一两个技术领域做到专业,然后尽量扩大自己的知识广度。例如除了自己的代码部分外,还应该知道具体是怎么部署的,部署到哪去了,部署的环境具体是怎么样的,和整个系统的关系是什么样的。 像我自己,是在加入基础设施团队后才更加明白有些时候软件上做的一个决策,会导致基础设施上巨大的硬件、网络或机房的投入,但其实有可能只需要在软件上做些调整就可以避免,做做研发、做做运维可能是比较好的把知识广度扩大的方法。 第二点是练习自己做tradeoff的能力,这个比较难,做tradeoff这事需要综合各种因素做选择,但这也是所有的架构师最关键的,可以回头反思下自己在做各种系统设计时做出的tradeoff是什么。这个最好是亲身经历,听一些有经验的架构师分享他们选择背后的逻辑也会很有帮助,尤其是如果恰好你也在同样的挑战阶段,光听最终的架构结果其实大多数时候帮助有限。 技术Leader我觉得最好是能在架构师的基础上,后续注重成长的方面还是有挺大差别,就不在这篇里写了,后面再专门来写一篇。 程序员金字塔 我认为程序员的价值关键体现在作品上,被打上作品标签是一种很大的荣幸,作品影响程度的大小我觉得决定了金字塔的层次,所以我会这么去理解程序员的金字塔。 当然,要打造一款作品,仅有上面的两点能力是不够的,作品里很重要的一点是对业务、技术趋势的判断。 希望作为程序员的大伙,都能有机会打造一款世界级的作品,去为技术圈的发展做出贡献。 由于目前IT技术更新速度还是很快的,程序员这个行当是特别需要学习能力的。我一直认为,只有对程序员这个职业真正的充满兴趣,保持自驱,才有可能在这个职业上做好,否则的话是很容易淘汰的。 作者简介: 毕玄,2007年加入阿里,十多年来主要从事在软件基础设施领域,先后负责阿里的服务框架、Hbase、Sigma、异地多活等重大的基础技术产品和整体架构改造。

茶什i 2020-01-10 15:19:35 0 浏览量 回答数 0

问题

10+年程序员总结的20+条经验教训

雅蕾 2019-12-01 21:56:26 7714 浏览量 回答数 0

回答

Kotlin的简介 Kotlin是由JetBrains公司(IDEA开发者)所开发的编程语言,其名称来自于开发团队附近的科特林岛。 多平台开发 JVM :Android; Server-Side Javascript:前端 Native(beta) :开发原生应用 windows、macos、linux Swift与Kotlin非常像 http://nilhcem.com/swift-is-like-kotlin/ kotlin发展历程 image.png java发展历程 image.png JVM语言的原理 image.png JVM规范与java规范是相互独立的 只要生成的编译文件匹配JVM字节码规范,任何语言都可以由JVM编译运行. Kotlin也是一种JVM语言,完全兼容java,可以与java相互调用;Kotlin语言的设计受到Java、C#、JavaScript、Scala、Groovy等语言的启发 kotlin的特性 下面不会罗列kotlin中具体的语法,会介绍我认为比较重要的特性,以及特性背后的东西。 类型推断 空类型设计 函数式编程 类型推断 image.png 类型推断是指编程语言中在编译期自动推导出值的数据类型。推断类型的能力让很多编程任务变得容易,让程序员可以忽略类型标注的同时仍然允许类型检查。 在开发环境中,我们往往写出表达式,然后可以用快捷键来生成变量声明,往往都是很准的,这说明了编译器其实是可以很准确的推断出来类型的。编程语言所具备的类型推断能力可以把类型声明的任务由开发者转到了编译器. java中声明变量的方式是类型写在最前面,后面跟着变量名,这就迫使开发者在声明变量时就要先思考变量的类型要定义成什么,而在一些情况下比如使用集合、泛型类型的变量,定义类型就会变得比较繁琐。 Kotlin中声明变量,类型可以省略,或者放到变量名后面,这可以降低类型的权重,从必选变为可选,降低开发者思维负担。java10中也引入了类型推断。 Javascript中声明变量也是用关键字var,但是还是有本质区别的,Kotlin中的类型推断并不是变成动态类型、弱类型,类型仍然是在编译期就已经决定了的,Kotlin仍然是静态类型、强类型的编程语言。javascript由于是弱类型语言,同一个变量可以不经过强制类型转换就被赋不同数据类型的值, 编程语言的一个趋势就是抽象程度越来越高,编译器做更多的事情。 空类型设计 空类型的由来 image.png 托尼·霍尔(Tony Hoare),图灵奖得主 托尼·霍尔是ALGOL语言的设计者,该语言在编程语言发展历史上非常重要,对其他编程语言产生重大影响,大多数近代编程语言(包括C语言)皆使用类似ALGOL的语法。他在一次大会上讨论了null应用的设计: “我把 null 引用称为自己的十亿美元错误。它的发明是在1965 年,那时我用一个面向对象语言( ALGOL W )设计了第一个全面的引用类型系统。我加入了null引用设计,仅仅是因为实现起来非常容易。它导致了数不清的错误、漏洞和系统崩溃,可能在之后 40 年中造成了十亿美元的损失。” null引用存在的问题 以java为例,看null引用的设计到底存在哪些问题 空指针问题NPE 编译时不能对空指针做出检查,运行时访问null对象就会出现错误,这个就是工程中常见的空指针异常。 null本身没有语义,会存在歧义 值未被初始化 值不存在 也许表示一种状态 逻辑上有漏洞 Java中,null可以赋值给任何引用,比如赋值给String类型变量,String a = null,但是null并不是String类型: a instanceof String 返回的是false,这个其实是有些矛盾的。所以当持有一个String类型的变量,就存在两种情况,null或者真正的String. 解决NPE的方式 防御式代码 在访问对象前判空,但会有冗余代码;会规避问题,而隐藏真正的问题 抛出异常给调用方处理 方法中传参传入的空值、无效值,抛出受检查异常给上层调用方 增加注解 Android中可以增加@NonNull注解,编译时做额外检查 空状态对象设计模式 空状态对象是一个实现接口但是不做任何业务逻辑的对象,可以取代判空检查;这样的空状态对象也可以在数据不可用的时候提供默认的行为 java8 Optional类 java8中引入了Optional类,来解决广泛存在的null引用问题.官方javadoc文档介绍 A container object which may or may not contain a non-null value. If a value is present, isPresent() will return true and get() will return the value. Additional methods that depend on the presence or absence of a contained value are provided, such as orElse() (return a default value if value not present) and ifPresent() (execute a block of code if the value is present). 来看一下是如何实现的。 举一个访问对象读取熟悉的例子 java 8 之前 : image.png java 8: image.png 总结: 1.用Optional还是会比较繁琐,这个也说明了设计一个替代null的方案还是比较难的。 optional的耗时大约是普通判空的数十倍,主要是涉及泛型、使用时多创键了一个对象的创建;数据比较大时,会造成性能损失。 java8 引入Optional的意义在于提示调用者,用特殊类型包装的变量可能为空,在使用取出时需要判断 Kotlin的空类型设计 Kotlin中引入了可空类型和不可空类型的区分,可以区分一个引用可以容纳null,还是不能容纳null。 String vs String? String 类型表示变量不能为空,String?则表示变量可以为空 String?含义是String or null.这两种是不同的类型. 比如: var a:String = “abc” //ok var a:String = null //不允许 var b :String? = null //ok a=b // 不允许 String?类型的值不能给String类型的值赋值 这样就将类型分成了可空类型和不可能类型,每一个类型都有这样的处理;Kotlin中访问非空类型变量永远不会出现空指针异常。 同样上面的例子,采用Kotlin去写,就会简洁很多 image.png 编程范式-函数式编程 编程范式是什么? 编程范式是程序员看待程序和写程序的观点 主要的类型 非结构化编程 结构化编程 面向对象编程 命令式编程 函数式编程 这些类型并不是彼此互斥的,而是按照不同的维度做的划分,一种编程语言可能都支持多个编程范式 非结构化编程 第一代的高级语言往往是非结构化编程 比如 BASIC语言 每一行的代码前面都有一个数字作为行号,通常使用GOTO的跳跃指令来实现判断和循环. 看一下下面这段代码是做什么的: image.png 实际上做的是:程序在屏幕上显示数字 1 到 10 及其对应的平方 采用这种方式写程序,大量的使用goto实现逻辑的跳转,代码一长,可读性和维护性就比较差了,形成“面条式代码” 结构化编程 采用顺序、分支、循环结构来表达,禁用或者少用GOTO; 并用子程序来组织代码,采用自顶向下的方式来写程序 代表语言是C语言 实现同样的逻辑: image.png 可见采用结构化编程,代码的逻辑会更清晰。 面向对象编程 思想: 将计算机程序视为一组对象的集合,而每个对象都可以接收其他对象发过来的消息,并处理这些消息,计算机程序的执行就是一系列消息在各个对象之间传递。 特性: 封装性、继承性、多态性。 命令式编程 把计算机程序视为一系列的命令集合 主要思想是关注计算机执行的步骤,即一步一步告诉计算机先做什么再做什么。 “先做这,再做那”,强调“怎么做” 实现: 用变量来储存数据,用语句来执行指令,改变变量状态。 基本所有的常见的编程语言都具有此范式 函数式编程 声明式语法,描述要什么,而不是怎么做 类似于SQL语句 语言: kotlin swift python javascript scala 函数是第一等公民 可以赋值给变量,可作为参数传入另一个函数,也可作为函数的返回值 纯函数 y=f(x) 只要输入相同,返回值不变 没有副作用:不修改函数的外部状态 举个栗子 公司部门要进行outing,去哪里是个问题,要考虑多个因素,比如花费、距离、天数等等,有多个备选地点进行选择。 定义一个数据类: image.png 要进行筛选了,分别用sql,kotlin,java来实现 找出花费低于2000元的outing地点信息 SQL image.png Kotlin image.png java 7 image.png 可见kotin的写法还是比较接近于sql的思想的,声明式的写法,而不管具体如何实现;其中的:place->place.money<2000 就是函数,可以作为参数传递给fliter这个高阶函数;而且这个函数没有副作用,不改变外部状态。 再来一个复杂一点的: 找出花费低于5000元,时间不多于4天,按照距离排序的outing地点名称 SQL image.png Kotlin: image.png java 7 image.png 由此可见用kotlin的函数式写法,会更简洁,逻辑也更清晰,这段代码的目标一目了然,这种清晰在于实现了业务逻辑与控制逻辑的分离,业务逻辑就是由函数实现的,比如place->place.money<500,而控制逻辑是由filter,sorterBy等高阶函数实现的。 而java的传统写法是基于对数据的操作,避免不了遍历的操作,业务逻辑与控制逻辑交织在了一起,这段代码的目的就不是那么容易清晰看到的了。 总结 kotlin是实用的现代编程语言,吸收了众多编程语言的优点,支持类型推断、空类型安全、函数式编程、DSL等特性,非常值得学习和使用。

问问小秘 2020-04-30 16:33:40 0 浏览量 回答数 0

回答

声明引用变量(即对象)时,实际上是在创建指向对象的指针。考虑以下代码,您在其中声明基本类型的变量int: int x; x = 10; 在此示例中,变量x是an int,Java会0为您初始化它。在10第二行为其分配值时,您的值将10写入所指的存储位置x。 但是,当您尝试声明引用类型时,会发生一些不同的事情。采取以下代码: Integer num; num = new Integer(10); 第一行声明了一个名为的变量num,但实际上尚未包含原始值。相反,它包含一个指针(因为类型是Integer引用类型)。由于您尚未说出要指向的内容,因此Java将其设置为null,表示“ 我什么都没有指向 ”。 在第二行中,new关键字用于实例化(或创建)一个类型的对象,Integer并将指针变量num分配给该Integer对象。 在NullPointerException当你声明一个变量,但没有创建对象时发生。因此,您指向的是实际上不存在的东西。 如果num在创建对象之前尝试取消引用,则会显示NullPointerException。在大多数情况下,编译器会发现问题,并让您知道“” num may not have been initialized,但是有时您可能会编写不直接创建对象的代码。 例如,您可能具有如下方法: public void doSomething(SomeObject obj) { //do something to obj } 在这种情况下,您不是在创建对象obj,而是假设它是在doSomething()调用方法之前创建的。注意,可以这样调用方法: doSomething(null); 在这种情况下obj为null。如果该方法旨在对传入的对象做某事,则最好抛出,NullPointerException因为这是程序员错误,程序员将需要该信息来进行调试。 替代地,在某些情况下,该方法的目的不仅是要对传入的对象进行操作,因此null参数是可以接受的。在这种情况下,您将需要检查null参数并改变行为。您还应该在文档中对此进行解释。例如,doSomething()可以写成: /** * @param obj An optional foo for ____. May be null, in which case * the result will be ____. */ public void doSomething(SomeObject obj) { if(obj != null) { //do something } else { //do something else } } 最后,如何使用堆栈跟踪来查明异常和原因

养狐狸的猫 2019-12-02 03:04:54 0 浏览量 回答数 0

回答

关于线程和线程池的学习,我们可以从以下几个方面入手: 第一,什么是线程,线程和进程的区别是什么 第二,线程中的基本概念,线程的生命周期 第三,单线程和多线程 第四,线程池的原理解析 第五,常见的几种线程池的特点以及各自的应用场景 一、 线程,程序执行流的最小执行单位,是行程中的实际运作单位,经常容易和进程这个概念混淆。那么,线程和进程究竟有什么区别呢?首先,进程是一个动态的过程,是一个活动的实体。简单来说,一个应用程序的运行就可以被看做是一个进程,而线程,是运行中的实际的任务执行者。可以说,进程中包含了多个可以同时运行的线程。 二、 线程的生命周期,线程的生命周期可以利用以下的图解来更好的理解: 第一步,是用new Thread()的方法新建一个线程,在线程创建完成之后,线程就进入了就绪(Runnable)状态,此时创建出来的线程进入抢占CPU资源的状态,当线程抢到了CPU的执行权之后,线程就进入了运行状态(Running),当该线程的任务执行完成之后或者是非常态的调用的stop()方法之后,线程就进入了死亡状态。而我们在图解中可以看出,线程还具有一个则色的过程,这是怎么回事呢?当面对以下几种情况的时候,容易造成线程阻塞,第一种,当线程主动调用了sleep()方法时,线程会进入则阻塞状态,除此之外,当线程中主动调用了阻塞时的IO方法时,这个方法有一个返回参数,当参数返回之前,线程也会进入阻塞状态,还有一种情况,当线程进入正在等待某个通知时,会进入阻塞状态。那么,为什么会有阻塞状态出现呢?我们都知道,CPU的资源是十分宝贵的,所以,当线程正在进行某种不确定时长的任务时,Java就会收回CPU的执行权,从而合理应用CPU的资源。我们根据图可以看出,线程在阻塞过程结束之后,会重新进入就绪状态,重新抢夺CPU资源。这时候,我们可能会产生一个疑问,如何跳出阻塞过程呢?又以上几种可能造成线程阻塞的情况来看,都是存在一个时间限制的,当sleep()方法的睡眠时长过去后,线程就自动跳出了阻塞状态,第二种则是在返回了一个参数之后,在获取到了等待的通知时,就自动跳出了线程的阻塞过程 三、 什么是单线程和多线程? 单线程,顾名思义即是只有一条线程在执行任务,这种情况在我们日常的工作学习中很少遇到,所以我们只是简单做一下了解 多线程,创建多条线程同时执行任务,这种方式在我们的日常生活中比较常见。但是,在多线程的使用过程中,还有许多需要我们了解的概念。比如,在理解上并行和并发的区别,以及在实际应用的过程中多线程的安全问题,对此,我们需要进行详细的了解。 并行和并发:在我们看来,都是可以同时执行多种任务,那么,到底他们二者有什么区别呢? 并发,从宏观方面来说,并发就是同时进行多种时间,实际上,这几种时间,并不是同时进行的,而是交替进行的,而由于CPU的运算速度非常的快,会造成我们的一种错觉,就是在同一时间内进行了多种事情 而并发,则是真正意义上的同时进行多种事情。这种只可以在多核CPU的基础下完成。 还有就是多线程的安全问题?为什么会造成多线程的安全问题呢?我们可以想象一下,如果多个线程同时执行一个任务,name意味着他们共享同一种资源,由于线程CPU的资源不一定可以被谁抢占到,这是,第一条线程先抢占到CPU资源,他刚刚进行了第一次操作,而此时第二条线程抢占到了CPU的资源,name,共享资源还来不及发生变化,就同时有两条数据使用了同一条资源,具体请参考多线程买票问题。这个问题我们应该如何解决那?   有造成问题的原因我们可以看出,这个问题主要的矛盾在于,CPU的使用权抢占和资源的共享发生了冲突,解决时,我们只需要让一条线程战歌了CPU的资源时,阻止第二条线程同时抢占CPU的执行权,在代码中,我们只需要在方法中使用同步代码块即可。在这里,同步代码块不多进行赘述,可以自行了解。 四,线程池 又以上介绍我们可以看出,在一个应用程序中,我们需要多次使用线程,也就意味着,我们需要多次创建并销毁线程。而创建并销毁线程的过程势必会消耗内存。而在Java中,内存资源是及其宝贵的,所以,我们就提出了线程池的概念。 线程池:Java中开辟出了一种管理线程的概念,这个概念叫做线程池,从概念以及应用场景中,我们可以看出,线程池的好处,就是可以方便的管理线程,也可以减少内存的消耗。 那么,我们应该如何创建一个线程池那?Java中已经提供了创建线程池的一个类:Executor 而我们创建时,一般使用它的子类:ThreadPoolExecutor. public ThreadPoolExecutor(int corePoolSize,                                int maximumPoolSize,                                long keepAliveTime,                                TimeUnit unit,                                BlockingQueue workQueue,                                ThreadFactory threadFactory,                                RejectedExecutionHandler handler)这是其中最重要的一个构造方法,这个方法决定了创建出来的线程池的各种属性,下面依靠一张图来更好的理解线程池和这几个参数: 又图中,我们可以看出,线程池中的corePoolSize就是线程池中的核心线程数量,这几个核心线程,只是在没有用的时候,也不会被回收,maximumPoolSize就是线程池中可以容纳的最大线程的数量,而keepAliveTime,就是线程池中除了核心线程之外的其他的最长可以保留的时间,因为在线程池中,除了核心线程即使在无任务的情况下也不能被清除,其余的都是有存活时间的,意思就是非核心线程可以保留的最长的空闲时间,而util,就是计算这个时间的一个单位,workQueue,就是等待队列,任务可以储存在任务队列中等待被执行,执行的是FIFIO原则(先进先出)。threadFactory,就是创建线程的线程工厂,最后一个handler,是一种拒绝策略,我们可以在任务满了知乎,拒绝执行某些任务。 线程池的执行流程又是怎样的呢? 有图我们可以看出,任务进来时,首先执行判断,判断核心线程是否处于空闲状态,如果不是,核心线程就先就执行任务,如果核心线程已满,则判断任务队列是否有地方存放该任务,若果有,就将任务保存在任务队列中,等待执行,如果满了,在判断最大可容纳的线程数,如果没有超出这个数量,就开创非核心线程执行任务,如果超出了,就调用handler实现拒绝策略。 handler的拒绝策略: 有四种:第一种AbortPolicy:不执行新任务,直接抛出异常,提示线程池已满              第二种DisCardPolicy:不执行新任务,也不抛出异常              第三种DisCardOldSetPolicy:将消息队列中的第一个任务替换为当前新进来的任务执行              第四种CallerRunsPolicy:直接调用execute来执行当前任务 五,四种常见的线程池: CachedThreadPool:可缓存的线程池,该线程池中没有核心线程,非核心线程的数量为Integer.max_value,就是无限大,当有需要时创建线程来执行任务,没有需要时回收线程,适用于耗时少,任务量大的情况。 SecudleThreadPool:周期性执行任务的线程池,按照某种特定的计划执行线程中的任务,有核心线程,但也有非核心线程,非核心线程的大小也为无限大。适用于执行周期性的任务。 SingleThreadPool:只有一条线程来执行任务,适用于有顺序的任务的应用场景。 FixedThreadPool:定长的线程池,有核心线程,核心线程的即为最大的线程数量,没有非核心线程 作者:weixin_40271838 来源:CSDN 原文:https://blog.csdn.net/weixin_40271838/article/details/79998327 版权声明:本文为博主原创文章,转载请附上博文链接!

auto_answer 2019-12-02 01:56:43 0 浏览量 回答数 0

问题

使用Hibernate的ScrollableResults缓慢读取9000万条记录?mysql

保持可爱mmm 2020-05-17 10:15:00 1 浏览量 回答数 1
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 企业信息查询 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 2020阿里巴巴研发效能峰会 企业建站模板 云效成长地图 高端建站 云栖号弹性计算 阿里云云栖号 云栖号案例 云栖号直播