java

腾讯开源 iOS 内存监控组件和OOM检测工具

谁说胖子不能爱 — Sat, 20 Feb 2021 11:57:20 +0000

腾讯开源 iOS 内存监控组件和OOM检测工具谁说胖子不能爱 2021-02-20 19:57:20

自阿里巴巴开源Android检测内存泄露工具LeakCanary后，腾讯开源了一个在iOS 内存监控组件和一个OOM检测工具。

MLeaksFinder

MLeaksFinder 是腾讯开源的 iOS 平台的自动内存泄漏检测工具，引进 MLeaksFinder 后，就可以在日常的开发，调试业务逻辑的过程中自动地发现并警告内存泄漏。开发者无需打开 instrument 等工具，也无需为了找内存泄漏而去跑额外的流程。并且，由于开发者是在修改代码之后一跑业务逻辑就能发现内存泄漏的，这使得开发者能很快地意识到是哪里的代码写得问题。这种及时的内存泄漏的发现在很大的程度上降低了修复内存泄漏的成本。

特性：

自动检测内存泄漏和释放不及时的场景
构建泄漏对象相对于 ViewContrller 的引用链以帮助开发者定位问题
不侵入业务逻辑，引入即生效，无需修改任何代码或引入头文件

用法

MLeaksFinder 可自动查找 UIView 和 UIViewController 对象中的泄漏。当发生泄漏时，它会在 View-ViewController 堆栈中显示泄漏对象预警。

Memory Leak
(
    MyTableViewController,
    UITableView,
    UITableViewWrapperView,
    MyTableViewCell
)

OOMDetector

OOMDetector 是腾讯开源的一个 iOS 内存监控组件，应用此组件可以帮助你轻松实现 OOM 监控、大内存分配监控、内存泄漏检测等功能。

组件特性：

OOM监控
监控 OOM，Dump 引起爆内存的堆栈
大内存分配监控
监控单次大块内存分配，提供分配堆栈信息
内存泄漏检测
可检测 OC 对象、Malloc 堆内存泄漏，提供泄漏堆栈信息

开发者技术前线欢迎各界读者投稿，加群请回复“加群”，

免费小密圈请点击：这年头还有免费小密圈？快加！

开发者技术前线汇聚最新最热的技术干货，行业动态，职场思考，热点思维，和一线面经！

浅谈导出Execl的报表数据解决方案

☆樱花仙子☆ — Sat, 20 Feb 2021 11:54:34 +0000

浅谈导出Execl的报表数据解决方案 ☆樱花仙子☆ 2021-02-20 19:54:34

项目中免不了要做一些数据导出功能，比如导出前一天的订单记录。涉及导出功能可大可小，根据系统具体的用户量、一天的订单量等情况。今天就讨论一下怎么设计一个合理的导出功能。

0x01：同步导出

这个方案最简单，就只需一个导出接口。这个接口只需实现根据用户条件到数据库查询相关数据，然后在应用程序中生成Execl电子表格，最后通过Response把生成的Execl电子表格回写到客户端即可

该方案简单，因为是同步导出，所以不适用大量数据导出。如果使用该方案进行大量数据导出的话，存在客户端（浏览器）超时的情况，导致导出失败；因为浏览器与Nginx之间有超时设置。

0x02：异步导出

异步导出一般需要设计三个接口。

第一个接口：开启一个线程对进行数据查询，并对查询到的数据进行Execl电子表格读写操作，同步返回导出状态标识；
第二个接口：查询第一个接口的完成状态，如果完成Execl电子表格操作，则返回true；否则返回false；
第三个接口：根据第二个接口返回的状态，如果返回true，就调用下载Execl电子表格；否则返回false的话继续轮询调用第二个接口，直到返回true；

这种方案比较耗服务器性能，因为需要第二个接口轮询应用服务器的导出状态，设置一个比较合理的轮询周期显得非常必要。另外，第一种方案和第二种方案都没有对导出的结果进行存库记录，如果要下载同样的数据，要整个流程重新走一遍。这样的话就引出第三种方案。

0x03：导出服务

该方案需要一张表和两个接口。

表的作用是用来存储谁进行了数据导出，导出的电子表格Execl存放的硬盘目录
第一个接口：开启一个线程对进行数据查询，并对查询到的数据进行Execl电子表格读写操作，最后把电子表格的目录存储到数据库；同步返回成功；
第二个接口：在导出列表中找出导出的记录，然后调用该接口进行Execl电子表格下载；

该方案需要额外做一个管理下载记录的界面，进行下载管理；这个方案的最大好处就是对下载操作进行了记录。如果需要对相同的数据导出，只需导出一遍即可。不过增加了存储的空间，无论数据库还是硬盘，都增加了。

在实际项目中使用哪种方案，根据具体业务场景，具体选择即可。其他文件类型的导出方案也可以参考该文章的方案进行操作。

喜欢，在看

本文分享自微信公众号 - JAVA乐园（happyhuangjinjin88）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

来源：oschina

链接：https://my.oschina.net/u/3385288/blog/4957995

标签

java

nginx

Java ---- 遍历链表（递归与非递归实现）

风格不统一 — Sat, 20 Feb 2021 11:30:13 +0000

Java ---- 遍历链表（递归与非递归实现）风格不统一 2021-02-20 19:30:13

package test;
//前序遍历的递归实现与非递归实现
import java.util.Stack;
public class Test 
{
    public static void main(String[] args)
    {
        TreeNode[] node = new TreeNode[10];//以数组形式生成一棵完全二叉树
        for(int i = 0; i < 10; i++)
        {
            node[i] = new TreeNode(i);
        }
        for(int i = 0; i < 10; i++)
        {
            if(i*2+1 < 10)
                node[i].left = node[i*2+1];
            if(i*2+2 < 10)
                node[i].right = node[i*2+2];
        }
        
        preOrderRe(node[0]);
    }
    
    public static void preOrderRe(TreeNode biTree)
    {//递归实现
        System.out.println(biTree.value);
        TreeNode leftTree = biTree.left;
        if(leftTree != null)
        {
            preOrderRe(leftTree);
        }
        TreeNode rightTree = biTree.right;
        if(rightTree != null)
        {
            preOrderRe(rightTree);
        }
    }
    
    public static void preOrder(TreeNode biTree)
    {//非递归实现
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while(biTree != null || !stack.isEmpty())
        {
            while(biTree != null)
            {
                System.out.println(biTree.value);
                stack.push(biTree);
                biTree = biTree.left;
            }
            if(!stack.isEmpty())
            {
                biTree = stack.pop();
                biTree = biTree.right;
            }
        }
    }
}
 
class TreeNode//节点结构
{
    int value;
    TreeNode left;
    TreeNode right;
    
    TreeNode(int value)
    {
        this.value = value;
    }
}

二叉树的遍历

二叉树的遍历分为三种：前序遍历中序遍历后序遍历

前序遍历：按照“根左右”,先遍历根节点，再遍历左子树，再遍历右子树

中序遍历：按照“左根右“,先遍历左子树，再遍历根节点，最后遍历右子树

后续遍历：按照“左右根”，先遍历左子树，再遍历右子树，最后遍历根节点

其中前，后，中指的是每次遍历时候的根节点被遍历的顺序

二叉树遍历：

前根左右

中左根右

后左右根

来源：oschina

链接：https://my.oschina.net/u/4374409/blog/3563229

标签

java

Java程序员养成日记一（计算机基础）2.20

烂漫一生 — Sat, 20 Feb 2021 11:28:29 +0000

Java程序员养成日记一（计算机基础）2.20 烂漫一生 2021-02-20 19:28:29

参照博客java程序员技能树（如有侵权马上删除）

经典回顾

操作系统（ operation system OS）

简介

操作系统（operation system，简称OS）是管理计算机硬件与软件资源的计算机程序。操作系统需要处理如管理与配置内存、决定系统资源供需的优先次序、控制输入设备与输出设备、操作网络与管理文件系统等基本事务。操作系统也提供一个让用户与系统交互的操作界面。

主要的操作系统

嵌入式（ VxWorks、eCos、Symbian OS及Palm OS、 iOS 、 Android ）
类 Unix（ System V、BSD与Linux ）
Microsoft Windows（ Windows XP 、 Windows 7 、 Windows 10 、）
MacOS X（ MacOS和MacOS X ）
Google Chrome OS（ Google的轻型的、基于网络的计算机操作系统计划）

编译原理

基本概念

编译原理即是对高级程序语言进行翻译的一门科学技术, 我们都知道计算机程序由程序语言编写而成, 在早期计算机程序语言发展较为缓慢, 因为计算机存储的数据和执行的程序都是由0、1代码组合而成的, 那么在早期程序员编写计算机程序时必须十分了解计算机的底层指令代码通过将这些微程序指令组合排列从而完成一个特定功能的程序, 这就对程序员的要求非常高了。人们一直在研究如何如何高效的开发计算机程序, 使编程的门槛降低。

编译器

编译过程一般是在计算机系统中实现的, 是将源代码转化为计算机通用语言的过程。

编译的基本流程

编译可以分为五个基本步骤:词法分析、语法分析、语义分析及中间代码的生成、优化、目标代码的生成。这是每个编译器都必须的基本步骤和流程, 从源头输入高级语言源程序输出目标语言代码。

词法分析（词法分析程序或词法分析器或扫描器）
语法分析（语法规则又称为文法, 分为0型、1型、2型、3型文法, 0型文法又称短语文法, 1型称为上下文有关文法, 2型称为上下文无关文法, 3型文法称为正规文法, 限制条件依次递增。判断语法规则）
语义分析（词法分析注重的是每个单词是否合法, 以及这个单词属于语言中的哪些部分）
中间代码生成与优化（所谓“中间代码”是一种结构简单、含义明确的记号系统, 这种记号系统复杂性介于源程序语言和机器语言之间, 容易将它翻译成目标代码。）
目标代码的生成（根据优化后的中间代码, 可生成有效的目标代码。而通常编译器将其翻译为汇编代码, 此时还需要将汇编代码经汇编器汇编为目标机器的机器语言）
出错处理（编译的各个阶段都有可能发现源码中的错误, 尤其是语法分析阶段可能会发现大量的错误, 因此编译器需要做出错处理, 报告错误类型及错误位置等信息）

计算机网络( computer networks )
定义（简介）

计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

按广义（一些相互连接的、以共享资源为目的的、自治的计算机的集合。从逻辑功能上看，计算机网络是以传输信息为基础目的，用通信线路将多个计算机连接起来的计算机系统的集合，一个计算机网络组成包括传输介质和通信设备。）
按连接（计算机网络就是通过线路互连起来的、自治的计算机集合，确切的说就是将分布在不同地理位置上的具有独立工作能力的计算机、终端及其附属设备用通信设备和通信线路连接起来，并配置网络软件，以实现计算机资源共享的系统。）
按需求（计算机网络就是由大量独立的、但相互连接起来的计算机来共同完成计算机任务。这些系统称为计算机网络（computer networks））

组成

计算机网络的分类与一般的事物分类方法一样，可以按事物所具有的不同性质特点（即事物的属性）分类。计算机网络通俗地讲就是由多台计算机（或其它计算机网络设备）通过传输介质和软件物理（或逻辑）连接在一起组成的。总的来说计算机网络的组成基本上包括：计算机、网络操作系统、传输介质（可以是有形的，也可以是无形的，如无线网络的传输介质就是空间）以及相应的应用软件四部分。

功能

数据通信
数据通信是计算机网络的最主要的功能之一。数据通信是依照一定的通信协议，利用数据传输技术在两个终端之间传递数据信息的一种通信方式和通信业务
资源共享
资源共享是人们建立计算机网络的主要目的之一。计算机资源包括硬件资源、软件资源和数据资源。（避免设备、大型数据库等的重复建设）
集中管理
计算机网络技术的发展和应用，已使得现代的办公手段、经营管理等发生了变化
实现分布式处理
网络技术的发展，使得分布式计算成为可能。对于大型的课题，可以分为许许多多小题目，由不同的计算机分别完成，然后再集中起来，解决问题。
负载均衡
负荷均衡是指工作被均匀的分配给网络上的各台计算机系统。网络控制中心负责分配和检测，当某台计算机负荷过重时，系统会自动转移负荷到较轻的计算机系统去处理。

评价：由此可见，计算机网络可以大大扩展计算机系统的功能，扩大其应用范围，提高可靠性，为用户提供方便，同时也减少了费用，提高了性能价格比。

分类

局域网（Local Area Network；LAN）
局域网一般位于一个建筑物或一个单位内，不存在寻径问题，不包括网络层的应用。
城域网（Metropolitan Area Network；MAN）
一般在政府城域网中应用，如邮政、银行、医院等。
广域网（Wide Area Network，WAN）
邮电部的CHINANET，CHINAPAC，和CHINADDN网。
无线网
无线通信系统主要有：低功率的无绳电话系统、模拟蜂窝系统、数字蜂窝系统、移动卫星系统、无线LAN和无线WAN等。

性能

计算机网络的性能一般是指它的几个重要的性能指标。但除了这些重要的性能指标外，还有一些非性能特征，它们对计算机网络的性能也有很大的影响。

计算机网络的性能指标
性能指标从不同的方面来度量计算机网络的性能。
         （1）速率
                 计算机发送出的信号都是数字形式的。比特是计算机中数据量的单位，也是信息论中使用的信息量的单位。
         （2）带宽
                 ① 带宽本来是指某个信号具有的频带宽度。信号的带宽是指该信号所包含的各种不同频率成分所占据的频率范围。例如，在传统的通信线路上传送的电话信号的标准带宽是3.1kHz（从300Hz到3.4kHz，即话音的主要成分的频率范围）。这种意义的带宽的单位是赫（或千赫，兆赫，吉赫等）。
                 ② 在计算机网络中，带宽用来表示网络的通信线路所能传送数据的能力，因此网络带宽表示在单位时间内从网络中的某一点到另一点所能通过的“最高数据率”。这里一般说到的“带宽”就是指这个意思。这种意义的带宽的单位是“比特每秒”，记为bit/s。
         （3）吞吐量
                 吞吐量表示在单位时间内通过某个网络（或信道、接口）的数据量。吞吐量更经常地用于对现实世界中的网络的一种测量，以便知道实际上到底有多少数据量能够通过网络。
         （4）时延
发送时延是主机或路由器发送数据帧所需要的时间，也就是从发送数据帧的第一个比特算起，到该帧的最后一个比特发送完毕所需的时间。
                 ① 发送时延。
                              发送时延的计算公式是：
                 ② 传播时延。
                              传播时延是电磁波在信道中传播一定的距离需要花费的时间。传播时延的计算公式是：
                              传播时延=信道长度（m）/电磁波在信道上的传播速率（m/s）
                              电磁波在自由空间的传播速率是光速，即300000km/s。电磁波在网络传输媒体中的传播速率比在自由空间要略低一些。
                 ③ 处理时延。
                              主机或路由器在收到分组时要花费一定的时间进行处理，例如分析分组的首部，从分组中提取数据部分，进行差错检验或查找适当的路由等，这就产生了处理时延。
                 ④ 排队时延。
                              分组在经过网络传输时，要经过许多的路由器。但分组在进入路由器后要先在输入队列中排队等待处理。在路由器确定了转发接口后，还要在输出队列中排队等待转发。这就产生了排队时延。
                              数据在网络中经历的总时延就是以上四种时延之和：
                              总时延=发送时延+传播时延+处理时延+排队时延
计算机网络的非性能特征
这些非性能特征与前面介绍的性能指标有很大的关系。
         （1）费用
                 即网络的价格（包括设计和实现的费用）。网络的性能与其价格密切相关。一般说来，网络的速率越高，其价格也越高。
         （2）质量
                 网络的质量取决于网络中所有构件的质量，以及这些构件是怎样组成网络的。网络的质量影响到很多方面，如网络的可靠性、网络管理的简易性，以及网络的一些性能（网络质量与价格成正比 ,高质量的网络往往价格也较高）
         （3）标准化
                 网络的硬件和软件的设计既可以按照通用的国际标准，也可以遵循特定的专用网络标准。最好采用国际标准的设计，这样可以得到更好的互操作性，更易于升级换代和维修，也更容易得到技术上的支持。
         （4）可靠性
                 可靠性与网络的质量和性能都有密切关系。速率更高的网络，其可靠性不一定会更差。但速率更高的网络要可靠地运行，则往往更加困难，同时所需的费用也会较高。
         （5）可扩展性和可升级性
                 网络在构造时就应当考虑到今后可能会需要扩展（即规模扩大）和升级（即性能和版本的提高）。网络的性能越高，其扩展费用往往也越高，难度也会相应增加。
         （6）易于管理和维护
                 网络如果没有良好的管理和维护，就很难达到和保持所设计的性能。

互联网协议( Internet Protocol Suite )

IP是互联网协议群（Internet Protocol Suite ，IPS）中众多通信协议中的一个，也是其中最重要的一个。IP 协议属于通信协议中的第三层网络层协议，完成路由寻址和消息传递的功能。专家们一般将IPS解释为一个协议堆栈，它可以将应用程序的信息（比如电子邮件或者网页传输的内容）转换为网络可以传输的数据包。

来源：oschina

链接：https://my.oschina.net/u/4207792/blog/4957877

标签

Try-catch creates infinite loop [duplicate]

只谈情不闲聊 — Sat, 20 Feb 2021 11:08:39 +0000

Try-catch creates infinite loop [duplicate] 只谈情不闲聊 2021-02-20 19:08:39

问题

I need to be able to take user input until the input is greater than the initial price, but I also need to make it robust so that the user can't break the program by entering something other than a double/integer. If the user does enter something other than a double/int.

The problem is that it creates a loop and repeats "Please enter valid currency" + "Please enter: price"

 public static double findChange()
{
    System.out.println("\nPlease insert: " + price + " (enter payment amount)");
    initialPrice = price;
    while (payment < price)
    {  
        try{
            payment = kb.nextDouble();
        }
        catch (Exception e)
        {
            System.out.println("Please enter valid currency");
        }
        if (payment > 0){
            totalPayment += payment;
            price -= payment;
            price = (price * 100);
            payment = 0;
        }
        if (totalPayment < initialPrice)
            System.out.println("Please Insert:" + price);
    }

    change = totalPayment - initialPrice;
    change = Math.round(change * 100);
    change = change / 100;
    System.out.println("\nChange Given: $" + change);

    return change;
}

回答1:

The reason you're seeing an infinite loop is that you never clear the invalid entry out of the input. If you look at the docs, it says

If the translation is successful, the scanner advances past the input that matched.

When it fails, you should call kb.next() to remove the input that did not match a double, so that you can move on to the next user entry. Otherwise, you'll keep trying to parse the same invalid text over and over:

catch (Exception e)
{
    System.out.println("Please enter valid currency");
    kb.next();
}

A few other things you can improve as well. There's no need to be using a try and catch here, since you can use the hasNextDouble method to check that the input is valid. If you do decide to stick with exception handling though, you should catch InputMismatchException rather than a generic Exception, or else you risk running into some more problems (for example, if the input gets exhausted). You can also put a continue in when the input fails, so that it doesn't evaluate the rest of the code which is assuming that you correctly read a value.

if(kb.hasNextDouble()){
    payment = kb.nextDouble();
} else{
    System.out.println("Please enter valid currency");
    kb.next();
    continue;
}

Note that there's still a problem with your logic, and the loop will never exit (since payment always gets reset to zero). I assume you want to do totalPayment < price instead.

回答2:

Since you want it to recognize any input, but only use doubles, try Double.parseDouble(String). I also moved the rest of the logic to your try block, since it should only occur when valid input is received. If it can't parse the double, it breaks out without attempting the rest of the logic and tries again.

while (payment < price && price > 0){
    try{
        payment = Double.parseDouble(kb.next());
        if (payment > 0){
            totalPayment += payment;
            price -= payment;
            price = (price * 100); 
            payment = 0;
        }
        if (totalPayment < initialPrice){
            System.out.println("Please Insert:" + price);
        }
    }
    catch (Exception e) {
        System.out.println("Please enter valid currency");
    }
}

来源：https://stackoverflow.com/questions/34292881/try-catch-creates-infinite-loop

标签

java

try-catch

infinite-loop

visualvm - Local java applications cannot be detected

柔情痞子 — Sat, 20 Feb 2021 10:55:23 +0000

visualvm - Local java applications cannot be detected 柔情痞子 2021-02-20 18:55:23

问题

I am trying to run visualvm in my Windows 8 machine and i am getting error 'Local java applications cannot be detected'. I tried to follow the below steps to resolve the issue as suggested in 'https://visualvm.github.io/troubleshooting.html'. I gave full permission to my 'AppData\Local\Temp\hsperfdata_Dhasan' folder. But still i am getting the same error whenever i start visualvm. Please help me to fix this issue.

Thanks.

回答1:

Quit all java applications and delete hsperfdata_Dhasan folder.

来源：https://stackoverflow.com/questions/49160051/visualvm-local-java-applications-cannot-be-detected

标签

java

VisualVM

jvisualvm

Dynamic programming problems solution to interleaving strings

你。 — Sat, 20 Feb 2021 10:52:08 +0000

Dynamic programming problems solution to interleaving strings 你。 2021-02-20 18:52:08

问题

I was trying to solve this problem, and I gave up, and found the solution below, although I do not understand how the solution works, or why it works. Any in-depth solution would be deeply appreciated.

Question:

Given s1, s2, s3, find whether s3 is formed by the interleaving of s1 and s2.

For example, Given:
s1 = "aabcc"
s2 = "dbbca"
When s3 = "aadbbcbcac", return true.

When s3 = "aadbbbaccc", return false.

Solution:

  public static boolean isInterleave(String s1, String s2, String s3) {
        if (s3.length() == 0 && s1.length() == 0 && s2.length() == 0)
            return true;

        else if (s3.length() != s1.length() + s2.length())
            return false;
        boolean isInter[][] = new boolean[s1.length()+1][s2.length()+1];
        isInter[0][0] = true;
        for ( int i = 1; i <= s1.length(); ++i){
            if (s1.charAt(i-1) == s3.charAt(i-1))
                isInter[i][0] = true;
            else
                break;
        }
        for ( int i = 1; i <= s2.length(); ++i){
            if (s2.charAt(i-1) == s3.charAt(i-1))
                isInter[0][i] = true;
            else
                break;
        }
        // DP
        for ( int i = 1; i <= s1.length(); ++i){
            for ( int j = 1; j <= s2.length(); ++j){
                if (s3.charAt(i+j-1) == s1.charAt(i-1))
                    isInter[i][j] = isInter[i-1][j] || isInter[i][j];
                if (s3.charAt(i+j-1) == s2.charAt(j-1))
                    isInter[i][j] = isInter[i][j-1] || isInter[i][j];
            }
        }
        return isInter[s1.length()][s2.length()];
    }

回答1:

I'm using Python slice syntax here because it is nice. S[:-1] means the string S with its last character removed and S[:n] means the prefix of S that has length n.

The key idea is that if C is an interleaving of A and B, then C[:-1] is either an interleaving of A and B[:-1] or of A[:-1] and B. On the other hand, if C is an interleaving of A and B, then C + 'X' is an interleaving of A + 'X' and B and it is also an interleaving of A and B + 'X'.

These are the substructure properties we need to apply dynamic programming.

We define f(i, j) = true, if s1[:i] and s2[:j] can be interleaved to form s3[:(i+j)] and f(i,j) = false otherwise. By the observation above we have

f(0,0) = true
f(i,0) = f(i-1, 0) if s3[i-1] == s1[i-1]
f(0,j) = f(0, j-1) if s3[j-1] == s2[j-1]
f(i,j) = true if s3[i+j-1] = s1[i-1] and f(i-1, j)
f(i,j) = true if s3[i+j-1] = s2[j-1] and f(i, j-1)

In all the other cases we have f(i,j) = false. The Java code just implements this recurrence using dynamic programming. That said, I would implement it in a bit more concise way:

for (int i = 0; i <= s1.length(); ++i)
    for (int j = 0; j <= s2.length(); ++j)
        isInter[i][j] = (i == 0 && j == 0)
           || (i > 0 && s1.charAt(i-1) == s3.charAt(i+j-1) && isInter[i-1][j])
           || (j > 0 && s2.charAt(j-1) == s3.charAt(i+j-1) && isInter[i][j-1]);

回答2:

The first few lines just deal with simple cases that can be resolved based only on the input string lengths. These tests simplify the remaining code by allowing it to assume that the lengths match.

The guts of the algorithm calculate an array isInter, where isInter[i][j] is true after iteration (i,j) if, and only if, the first i+j characters of s3 can be formed by interleaving the first i characters of s1 with the first j characters of s2.

isInter[i][0] is true if, and only if, the first i characters of s3 match the first i characters of s1. Similarly, isInter[0][i] is true if, and only if, the first i characters of s3 match the first i characters of s2.

The final loop builds up the remaining elements of isInter using already calculated elements and matches between the next character of s3 and either the next character of s1 or the next character of s2.

After isInter has been completely calculated, isInter[s1.length()][s2.length()] is true if, and only if, the whole of s3 can be formed by interleaving the whole of s1 with the whole of s2.

回答3:

Here is another attempt to show how the code works, using extremely plain syntax in C++. Their are some inline comments in the code for you to understand. It can't get simpler than this :)

//using dynamic programming : O(n^2)
bool is_interleaved_On2_DP(string s1, string s2, string s3)
    {
    bool ret = false;
    int len1 = s1.length();
    int len2 = s2.length();
    int len3 = s3.length();

    if( len1 + len2 != len3 )
        {
        return ret;
        }

#define M(i, j) match[ (i) * len1 + (j) ]

    //bool match[len1 + 1][len2 + 1]; //todo; use dynamic allocation
    bool* match = new bool[ (len1+1)*(len2+1) ];
    int i, j, k;

    /* init match table to be all false */
    for( i = 0; i <= len1; i++ )
        {
        for( j = 0; j <= len2; j++ )
            {
            M(i, j) = false;
            }
        }

    /* init match[0][0] == true */
    M(0, 0) = true; //why ? null is interleaving 2 other nulls :)

    /* init the s1 side of table i.e. column */
    for( i = 1; i <= len1; i++ )
        {
        char c1 = s1[i - 1];
        char c3 = s3[i - 1];
        if(c1 == c3)
            {
            M(i, 0) = true;
            }
        else
            {
            break;
            }
        }

    /* init the s2 side of table i.e. row */
    for( j = 1; j <= len2; j++ )
        {
        char c2 = s2[j - 1];
        char c3 = s3[j - 1];
        if(c2 == c3)
            {
            M(0, j) = true;
            }
        else
            {
            break;
            }
        }

    /* compute remaining table */
    for( i = 1; i <= len1; i++ )
        {
        char c1 = s1[i - 1];
        for( j = 1; j <= len2; j++ )
            {
            char c2 = s2[j - 1];
            int k = i + j; //index for s3
            char c3 = s3[k - 1];

            if(c1 == c3)
                {
                M(i, j) = M(i - 1, j) || M(i, j);
                }

            if(c2 == c3)
                {
                M(i, j) = M(i, j - 1) || M(i, j);
                }
            }
        }

    ret = M(len1, len2);

    delete [] match;
#undef M
    return ret;
    }

来源：https://stackoverflow.com/questions/22795589/dynamic-programming-problems-solution-to-interleaving-strings

标签

java

algorithm

Programmatically update certificates in tomcat 8 without server restart

扶醉桌前 — Sat, 20 Feb 2021 10:50:10 +0000

Programmatically update certificates in tomcat 8 without server restart 扶醉桌前 2021-02-20 18:50:10

问题

In order to update the certificate that I use for SSL for my server I have a code that does the import\export and validation that I need.

It works well, but In order for the changes to take effect I have to restart the tomcat.
I wish to avoid the restart, and update it without using external tools (keytool for example).
I looked up for some similar questions, and found a solution - restarting the 443 connector. I'm able to do so, and the connector is stopping and starting, but the certificate was not updated. Only server restart actually updates it.

Is there some connector initialisation procedure that I'm missing?
Some system cache or objects that I should clear?

This is the code that I use for restarting the connector:

MBeanServer mbeanServer = null;
ObjectName objectName = null;
final ObjectName objectNameQuery = new ObjectName("*:type=Connector,port=443,*");
for (final MBeanServer server : (ArrayList<MBeanServer>) MBeanServerFactory.findMBeanServer(null)) {
    if (server.queryNames(objectNameQuery, null).size() > 0) {
        mbeanServer = server;
        objectName = (ObjectName) server.queryNames(objectNameQuery,null).toArray()[0];
        break;
    }
}

mbeanServer.invoke(objectName, "stop", null, null);
Thread.sleep(1000);
mbeanServer.invoke(objectName, "start", null, null);

I see in the tomcat logs the following traces of the connector restart:
23-Apr-2017 15:42:00.292 INFO [BG-Task RestartTomcatConnector] org.apache.coyote.AbstractProtocol.stop Stopping ProtocolHandler ["http-nio-443"]
23-Apr-2017 15:42:01.349 INFO [BG-Task RestartTomcatConnector] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["http-nio-443"]

回答1:

The problem was solved, these are the components:

server.xml must include bindOnInit="false". This is the config I use

<Connector protocol="org.apache.coyote.http11.Http11NioProtocol"
        port="443" SSLEnabled="true" maxThreads="150"
        acceptCount="2000" scheme="https" secure="true"
        ciphers="TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, TLS_DHE_RSA_WITH_AES_256_CBC_SHA"
        keystoreFile="webapps/ServerKeyStore"
        keystorePass="***"
        clientAuth="false" sslProtocol="TLS"
        sslEnabledProtocols="TLSv1.1,TLSv1.2" compression="on"
        compressableMimeType="text/html,text/xml,application/xml,application/json,application/javascript,text/css,text/plain"
        server="Portal" useSendfile="false"
        compressionMinSize="1024" bindOnInit="false"
/>

The Java code for the connector restart:

public class TomcatConnectorRestarter implements Callable<Boolean> {

    private final int waitSeconds = 3;
    private final static ReentrantLock rl = new ReentrantLock();

    @Override
    public Boolean call() throws Exception {
        restartConnector();
        return true;
    }

    protected void restartConnector() throws Exception {
        try {
            if (tryLock()){
                mLogger.info("Acquired lock");
                try {
                    HTTPSConnectorMBean httpsConnector = null;
                    MBeanServer mbeanServer = null;
                    ObjectName objectName = null;
                    final ObjectName objectNameQuery = new ObjectName("*:type=Connector,port=443,*");

                    for (final MBeanServer server : (ArrayList<MBeanServer>) MBeanServerFactory.findMBeanServer(null)) {
                        if (server.queryNames(objectNameQuery, null).size() > 0) {
                            mbeanServer = server;
                            objectName = (ObjectName) server.queryNames(objectNameQuery, null).toArray()[0];
                            httpsConnector = new HTTPSConnectorMBean(objectName, mbeanServer);
                            break;
                        }
                    }

                    if (Objects.nonNull(httpsConnector)) {
                        mLogger.info("Stopping connector");
                        httpsConnector.stop();
                        mLogger.info("Waiting "+waitSeconds+" seconds after "+"stop"+" ...");
                        Thread.sleep(waitSeconds*1000);
                        mLogger.info("Starting connector");
                        httpsConnector.start();
                    }
                    else {
                        mLogger.error("Could not find connector object");
                    }
                }
                catch (Exception e) {
                    mLogger.error("Failed restarting connector",e);
                }
            }
            else {
                mLogger.warn("Operation is in process");
            }
        }
        finally {
            unlock();
        }
    }

    private void unlock() {
        if (rl.isHeldByCurrentThread()) {
            mLogger.debug("Releasing lock");
            rl.unlock();
        }
    }

    private boolean tryLock() {
        return !rl.isHeldByCurrentThread() && rl.tryLock();
    }

    private enum MBeanConnectorAction {
        start,stop,getState;
    }

    private abstract class MBeansObjectAction {
        private final ObjectName on;
        private final MBeanServer server;

        public MBeansObjectAction(ObjectName on, MBeanServer server) {
            this.on = on;
            this.server = server;
        }

        protected Object invoke(MBeanConnectorAction cmd) throws InstanceNotFoundException, ReflectionException, MBeanException {
            return server.invoke(on, cmd.toString(), null, null);
        }
    }

    private class HTTPSConnectorMBean extends MBeansObjectAction {

        public HTTPSConnectorMBean(ObjectName on, MBeanServer server) {
            super(on, server);
        }

        public void start() throws InstanceNotFoundException, ReflectionException, MBeanException {
            invoke(MBeanConnectorAction.start);
        }
        public void stop() throws InstanceNotFoundException, ReflectionException, MBeanException {
            invoke(MBeanConnectorAction.stop);
        }
        public Object status() throws InstanceNotFoundException, ReflectionException, MBeanException {
            return invoke(MBeanConnectorAction.getState);
        }
    }
}

来源：https://stackoverflow.com/questions/43571572/programmatically-update-certificates-in-tomcat-8-without-server-restart

标签

sonarqube 6.3 error could-not-complete-symbolic-execution-reached-limit-of-16000 steps

谁都会走 — Sat, 20 Feb 2021 10:48:34 +0000

sonarqube 6.3 error could-not-complete-symbolic-execution-reached-limit-of-16000 steps 谁都会走 2021-02-20 18:48:34

问题

We have a scan that aborts on the code below, with the exception:

org.sonar.java.se.ExplodedGraphWalker$MaximumStepsReachedException: reached limit of 16000 steps for method getServiceProviders#151 in class ServiceProviderService

We looked at rules S2259 and S2583 and would like to keep notifications about null pointers.

This happens in both "regular" and debug (-X) mode, so it's not issue 1406. In our case it really seems to be related to try/catch. (See sample method below.) Could it be a resurgence of issue 1295? https://jira.sonarsource.com/browse/SONARJAVA-1295 If so, is there a way to simply increase the stack from 16,000 so that we can move along?

SAMPLE METHOD:

public static List<ServiceProvider> getServiceProviders() throws DAOException {
    Connection con = null;
    PreparedStatement stmt = null;
    ResultSet rs = null;
    List<ServiceProvider> serviceProviderList = new ArrayList<>();

    try {
        con = DatabaseUtils.getConnection();
        if (con != null) {
            stmt = con.prepareStatement(sqlSelectServiceProviders);

            rs = stmt.executeQuery();
            while (rs.next()) {
                ServiceProvider serviceProvider = new ServiceProvider();
                serviceProvider.setId(rs.getLong(1));
                serviceProvider.setName(rs.getString(2));
                // etc.
                serviceProviderList.add(serviceProvider);
            }   
        } else {
            DAOException ourDAOException = new DAOException();
            ourDAOException.setMessageCode(Consts.ERROR_CANNOT_ESTABLISH_CONNECTIONS);
            throw ourDAOException;
        }   
    } catch (DAOException daoexcep) {
        throw daoexcep;

    } catch (Exception sqlex) {
        log.error(ErrorType.SYSTEM + ": " + Consts.ERROR_CANNOT_GET_SERVICE_PROVIDER + " - " + sqlex);
        log.error(sqlex);
        try {
            if (con != null) {
                con.rollback();
            }   
        } catch (SQLException ex) {
        }   
        DAOException ourDAOException = new DAOException(sqlex);
        ourDAOException.setMessageCode(Consts.ERROR_CANNOT_GET_SERVICE_PROVIDER);
        throw ourDAOException;
    } finally {
        if (con != null) {
            try {
                con.close();
            } catch (SQLException e) {
            }   
            con = null;
        }   
    }   
    return serviceProviderList;
}

回答1:

6.3 and later require Oracle Java 8. Our public Java 7 seems to be the most likely culprit. The actual cause might have been something else, but the upgrade fixed it.

来源：https://stackoverflow.com/questions/43189650/sonarqube-6-3-error-could-not-complete-symbolic-execution-reached-limit-of-16000

标签

java

sonarqube

try-catch-finally

sonarqube 6.3 error could-not-complete-symbolic-execution-reached-limit-of-16000 steps

泄露秘密 — Sat, 20 Feb 2021 10:47:14 +0000

sonarqube 6.3 error could-not-complete-symbolic-execution-reached-limit-of-16000 steps 泄露秘密 2021-02-20 18:47:14

问题

We have a scan that aborts on the code below, with the exception:

org.sonar.java.se.ExplodedGraphWalker$MaximumStepsReachedException: reached limit of 16000 steps for method getServiceProviders#151 in class ServiceProviderService

We looked at rules S2259 and S2583 and would like to keep notifications about null pointers.

SAMPLE METHOD:

public static List<ServiceProvider> getServiceProviders() throws DAOException {
    Connection con = null;
    PreparedStatement stmt = null;
    ResultSet rs = null;
    List<ServiceProvider> serviceProviderList = new ArrayList<>();

    try {
        con = DatabaseUtils.getConnection();
        if (con != null) {
            stmt = con.prepareStatement(sqlSelectServiceProviders);

            rs = stmt.executeQuery();
            while (rs.next()) {
                ServiceProvider serviceProvider = new ServiceProvider();
                serviceProvider.setId(rs.getLong(1));
                serviceProvider.setName(rs.getString(2));
                // etc.
                serviceProviderList.add(serviceProvider);
            }   
        } else {
            DAOException ourDAOException = new DAOException();
            ourDAOException.setMessageCode(Consts.ERROR_CANNOT_ESTABLISH_CONNECTIONS);
            throw ourDAOException;
        }   
    } catch (DAOException daoexcep) {
        throw daoexcep;

    } catch (Exception sqlex) {
        log.error(ErrorType.SYSTEM + ": " + Consts.ERROR_CANNOT_GET_SERVICE_PROVIDER + " - " + sqlex);
        log.error(sqlex);
        try {
            if (con != null) {
                con.rollback();
            }   
        } catch (SQLException ex) {
        }   
        DAOException ourDAOException = new DAOException(sqlex);
        ourDAOException.setMessageCode(Consts.ERROR_CANNOT_GET_SERVICE_PROVIDER);
        throw ourDAOException;
    } finally {
        if (con != null) {
            try {
                con.close();
            } catch (SQLException e) {
            }   
            con = null;
        }   
    }   
    return serviceProviderList;
}

回答1:

6.3 and later require Oracle Java 8. Our public Java 7 seems to be the most likely culprit. The actual cause might have been something else, but the upgrade fixed it.

来源：https://stackoverflow.com/questions/43189650/sonarqube-6-3-error-could-not-complete-symbolic-execution-reached-limit-of-16000

标签

java

sonarqube

try-catch-finally

java

腾讯开源 iOS 内存监控组件和OOM检测工具

用法

浅谈导出Execl的报表数据解决方案

Java ---- 遍历链表（递归与非递归实现）

Java程序员养成日记一（计算机基础）2.20

参照博客java程序员技能树（如有侵权马上删除）

经典回顾

操作系统（ operation system OS）

简介

主要的操作系统

编译原理

基本概念

编译器

编译的基本流程

计算机网络( computer networks )

定义（简介）

组成

功能

分类

性能

互联网协议​​​​​​​( Internet Protocol Suite )

Try-catch creates infinite loop [duplicate]

问题

回答1:

回答2:

visualvm - Local java applications cannot be detected

问题

回答1:

Dynamic programming problems solution to interleaving strings

问题

回答1:

回答2:

回答3:

Programmatically update certificates in tomcat 8 without server restart

问题

回答1:

sonarqube 6.3 error could-not-complete-symbolic-execution-reached-limit-of-16000 steps

问题

SAMPLE METHOD:

回答1:

sonarqube 6.3 error could-not-complete-symbolic-execution-reached-limit-of-16000 steps

问题

SAMPLE METHOD:

回答1:

互联网协议( Internet Protocol Suite )