<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title><![CDATA[Xiao Kun's Infra Insight Blog]]></title><description><![CDATA[Focus on interpreting FANG/Big Factory Engineering Blog, extracting practical experience of Infra that can be implemented]]></description><link>https://xiaok.me</link><generator>RSS for Node</generator><lastBuildDate>Thu, 19 Nov 2026 02:09:46 GMT</lastBuildDate><atom:link href="https://xiaok.me/rss.xml" rel="self" type="application/rss+xml"/><language><![CDATA[en]]></language><ttl>60</ttl><item><title><![CDATA[Google Best Practice For Java Libraries （JLBP-0）]]></title><description><![CDATA[Google Best Practice For Java Libraries Chinese Version]]></description><link>https://xiaok.me/google-best-practice-for-java-libraries-jlbp-0</link><guid isPermaLink="true">https://xiaok.me/google-best-practice-for-java-libraries-jlbp-0</guid><category><![CDATA[Java]]></category><dc:creator><![CDATA[xiao kun]]></dc:creator><pubDate>Wed, 22 Nov 2023 04:21:11 GMT</pubDate><content:encoded><![CDATA[<blockquote>
<p>this is a chinese tranlation from <code>Google Best Practice For Java Libraries</code></p>
</blockquote>
<h1 id="heading-google-java">Google Java库最佳实践</h1>
<p>Google Java库的最佳实践是一些规则，旨在减少使用相关的Java库时的问题。这些实践来自于多年来维护开源Java库的经验，并且受到了从错误中吸取的许多宝贵教训的启发。我们发现遵循这些规则可以得到质量更高的Java库，减少依赖冲突和其他类型的问题。这个规则列表是开放的，所以可能会不时地添加新的规则。</p>
<h2 id="heading-5pya5l2z5a6e6le1">最佳实践</h2>
<ul>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-1">JLBP-1</a>: 最小化依赖</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-2">JLBP-2</a>: 最小化 API 接口</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-3">JLBP-3</a>: 使用语义版本</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-4">JLBP-4</a>: 避免依赖不稳定的库或者特性</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-5">JLBP-5</a>: 不要将一个类包含在多个类路径条目中</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-6">JLBP-6</a>: 一起重命名构件和包</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-7">JLBP-7</a>: 使破坏性过渡变得容易</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-8">JLBP-8</a>: 将广泛使用的功能提升到稳定版本</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-9">JLBP-9</a>: 支持您的消费者的最低Java版本</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-10">JLBP-10</a>: 为了消费者的需要，保持API的稳定性</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-11">JLBP-11</a>: 保持依赖项的最新状态</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-12">JLBP-12</a>: 明确支持级别和API的稳定性</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-13">JLBP-13</a>: 在第一次机会中删除对依赖项中已弃用功能的引用</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-14">JLBP-14</a>: 指定每个依赖项的单个可覆盖版本</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-15">JLBP-15</a>: 为多模块项目发布BOM</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-16">JLBP-16</a>: 确保消费者的依赖项的上限版本对齐</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-17">JLBP-17</a>: 协调退出破坏性版本</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-18">JLBP-18</a>: 只把 shade 依赖作为最后手段</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-19">JLBP-19</a>: 每个包只在一个模块里</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-20">JLBP-20</a>: 给每个 jar 一个模块名</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-21">JLBP-21</a>: 把构件上传到 Maven 中央仓库</p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/JLBP-22">JLBP-22</a>: 声明所有的直接依赖</p>
</li>
</ul>
<h2 id="heading-5qac5b1">概念</h2>
<ul>
<li><p><a target="_blank" href="https://jlbp.dev/what-is-a-diamond-dependency-conflict">什么是钻石依赖冲突？</a></p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/why-doesnt-the-compiler-catch-diamond-dependency-conficts">为什么编译器不能捕获钻石依赖冲突？</a></p>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/how-does-version-resolution-work-in-maven-and-gradle">Maven 和 Gradle 的版本解析是怎么工作的？</a></p>
<h2 id="heading-5yc6icd">参考</h2>
</li>
<li><p><a target="_blank" href="https://jlbp.dev/glossary">术语表</a>: 最佳实践中的术语以及其他开源云Java仓库中的术语</p>
</li>
</ul>
]]></content:encoded></item><item><title><![CDATA[【阅读】uml精粹 类图]]></title><description><![CDATA[本书的整体脉络如下： class diagram 表示对象的类型以及其间存在的静态关系。用一个长方形表示类，用连线表示类之间的关系。 对象的类型，也就是类有三部分表示而成 属性 (attribute) 其中抽象来说，类的成员变量 可以有两种表示， 属性表示 和 关联表示。 属性表示：就是画在框里， 一般写…]]></description><link>https://xiaok.me/uml-class-diagram</link><guid isPermaLink="true">https://xiaok.me/uml-class-diagram</guid><category><![CDATA[UML]]></category><dc:creator><![CDATA[xiao kun]]></dc:creator><pubDate>Sun, 04 Sep 2022 10:17:51 GMT</pubDate><content:encoded><![CDATA[<p>本书的整体脉络如下：
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1660928063226/x06uUz3VW.png" alt="image.png" /></p>
<p>class diagram 表示对象的类型以及其间存在的静态关系。用一个长方形表示类，用连线表示类之间的关系。</p>
<h1 id="heading-5yw35l2t57g75zu">具体类图</h1>
<h2 id="heading-6zw5pa55b2i">长方形</h2>
<p>对象的类型，也就是类有三部分表示而成</p>
<ul>
<li>类名 (class name)</li>
<li>属性 (attribute)</li>
<li>操作 (operation)</li>
</ul>
<p>属性 (attribute)</p>
<p>其中抽象来说，类的成员变量 可以有两种表示， 属性表示 和 关联表示。</p>
<p>属性表示：就是画在框里， 一般写 包括 可见行， 类型，名称 ，也可以写默认值 和 注释。 也可以标注是否是 static的 。</p>
<p>关联表示：连线的方式表示，类A 拥有若干个 类 C，若干 的术语是 重数，可以是 0-1，也可以是 1个，也可以多 * 表示多个</p>
<p>操作 (operation)</p>
<p>操作：画在框里，一般写 可见行，返回值，名称 和 参数, 也可以写注释</p>
<h2 id="heading-6le57q">连线</h2>
<p>类和类之间，有关联关系的可以用线连接起来。</p>
<p>比较宽泛可以直接连线，就表示有关系。</p>
<h1 id="heading-5yw35l2t55qe5ywz57o7">具体的关系</h1>
<h2 id="heading-5ywz6igu">关联</h2>
<p>一个类使用到了另外一个类，就是有关联关系。例如</p>
<pre><code class="lang-erlang">class A {
public B get()
}

class B {
public int calc(A a) 
}
</code></pre>
<ul>
<li>用实线的情况，直接表示有关联</li>
<li>加普通箭头的情况，关联关系有方向，可以用箭头表示，一个使用了另外一方。</li>
</ul>
<pre><code class="lang-java"><span class="hljs-meta">@startuml</span>
B --- A

<span class="hljs-meta">@enduml</span>
</code></pre>
<p>通过线和箭头的变化，又可以表示更具体的关系.</p>
<h2 id="heading-5rob5yyw">泛化</h2>
<p>类之间具体还有实现接口的情况，成为泛化.  用虚线空心箭头表示</p>
<pre><code class="lang-erlang">class A implements B{
}
interface B {}
</code></pre>
<pre><code class="lang-java"><span class="hljs-meta">@startuml</span>

<span class="hljs-class"><span class="hljs-keyword">interface</span> <span class="hljs-title">B</span>
<span class="hljs-title">class</span> <span class="hljs-title">A</span>
<span class="hljs-title">A</span> ..|&gt; <span class="hljs-title">B</span>

@<span class="hljs-title">enduml</span></span>
</code></pre>
<h2 id="heading-5a6e546w">实现</h2>
<p>类之间还有继承的情况，成为实现。用实线空心箭头表示</p>
<pre><code class="lang-erlang">class A extend B {}
class B {}
</code></pre>
<pre><code class="lang-java"><span class="hljs-meta">@startuml</span>

<span class="hljs-class"><span class="hljs-keyword">interface</span> <span class="hljs-title">B</span>
<span class="hljs-title">class</span> <span class="hljs-title">A</span>
<span class="hljs-title">A</span> --|&gt; <span class="hljs-title">B</span>

@<span class="hljs-title">enduml</span></span>
</code></pre>
<h2 id="heading-57ue5zci">组合</h2>
<p>也就是属性关联表示的情况，用实线实心棱形箭头表示</p>
<pre><code class="lang-erlang">class A { 
private B b;
}
class B {}
</code></pre>
<p>关联表示法</p>
<pre><code class="lang-java">
<span class="hljs-meta">@startuml</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">A</span>
<span class="hljs-title">class</span> <span class="hljs-title">B</span>
<span class="hljs-title">A</span> --* "1" <span class="hljs-title">B</span>
@<span class="hljs-title">enduml</span></span>
</code></pre>
<p>属性表示法</p>
<pre><code class="lang-java"><span class="hljs-meta">@startuml</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">A</span> </span>{
- B b
}
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">B</span>
@<span class="hljs-title">enduml</span></span>
</code></pre>
<p>大概这些就够了。</p>
]]></content:encoded></item><item><title><![CDATA[【夜读源码】grpc-java  客户端发送 （一）]]></title><description><![CDATA[接上文，一次 grpc 的请求包括四个步骤，客户端发送请求到网络，是第一步。发送过程，Stub 把请求传给了ClientCall， ClientCall 传给了 ClientStream，ClientStream 有Netty 的实现，内部会把数据传输到网络上。 本文主要介绍…]]></description><link>https://xiaok.me/grpc-java-client-1</link><guid isPermaLink="true">https://xiaok.me/grpc-java-client-1</guid><category><![CDATA[Java]]></category><category><![CDATA[gRPC]]></category><dc:creator><![CDATA[xiao kun]]></dc:creator><pubDate>Sun, 04 Sep 2022 09:36:54 GMT</pubDate><enclosure url="https://cdn.hashnode.com/res/hashnode/image/upload/v1661081133639/m2ocEw_q_.webp" length="0" type="image/jpeg"/><content:encoded><![CDATA[<h2 id="heading-5br6ycf5zue6ag">快速回顾</h2>
<p>接上文，一次 grpc 的请求包括四个步骤，客户端发送请求到网络，是第一步。发送过程，Stub 把请求传给了ClientCall， ClientCall 传给了 ClientStream，ClientStream 有Netty 的实现，内部会把数据传输到网络上。</p>
<p>本文主要介绍 blockingUnaryCall 是如何使用 ClientCall ClientChannel 工作的， waitAndDrain 和 ClientCall 的方法如何对应。</p>
<h1 id="heading-stub">Stub 外层简述</h1>
<p>最外层的Stub，echo方法是生成的代码，里面只有一行，使用静态方法<code>ClientCalls.blockingUnaryCall</code></p>
<p>blockingUnaryCall 的实现，</p>
<ol>
<li>使用ClientChannel 创建 ClientCall， 这个ClientCall 的类型就是 Pendingcall；</li>
<li>使用ClientCall 创建 <code>ListenableFuture</code> 存放 response</li>
<li>执行发送过程 </li>
<li>response 取出结果</li>
</ol>
<p>无论这里时序如何，还是会执行 PendingCall 发消息，最后通过观察者模式，把结果取回来。</p>
<p><strong>小结：Pendingcall 发送客户端消息</strong></p>
<h1 id="heading-clientcall">ClientCall 做了什么</h1>
<p>ClientCall  有四个主要的方法，start，request，sendMessage, halfClose</p>
<p>Channel 相当于  ClientCall 的工厂，下面具体到类型进行分析。</p>
<h1 id="heading-pendingcall">PendingCall  结构</h1>
<p>PendingCall 的实现如下图</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1661095237864/uvlJPJynI.png" alt="image.png" /></p>
<p>PendingCall 是一个 DelayClientCall，通过realChannel 创建了 ClientCallImpl 作为成员变量，因此 PendingCall 的 最终会执行  ClientCallImpl 的对应方法。</p>
<p><strong>小结： PendingCall 代理了 ClientCallImpl，PendingCall 借助  ManagedChannelImpl 的RealChannel 创建realCall </strong></p>
<h1 id="heading-managedchannelimpl">ManagedChannelImpl 的创建</h1>
<p>Channel 那一块,由一下代码创建出 ManagedChannelImpl</p>
<pre><code class="lang-java">ManagedChannel channel = ManagedChannelBuilder.forAddress(<span class="hljs-string">"localhost"</span>, <span class="hljs-number">8080</span>).usePlaintext().build();
</code></pre>
<p><code>ManagedChannelImpl</code> 里面包含  <code>ManagedChannelImpl.RealChannel</code>  和上图串起来了。</p>
<p><code>https://cdn.hashnode.com/res/hashnode/image/upload/v1662278195441/NnO2uNjhW.png</code></p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1662284383497/QltOjH69Y.png" alt="image.png" />
<strong>小结： 静态方法通过SPI 创建了ManagedChannelImpl  </strong></p>
<h1 id="heading-pendingcall">PendingCall 如何创建的</h1>
<p>在  <code>blockingUnaryCall</code> 里 <code>channel.newCall</code> 因此是 ManagedChannelOrphanWrapper   创建了  PendingCall,  ManagedChannelOrphanWrapper 委托给 ManageChannelImpl ，   ManageChannelImpl 委托给   <code>interceptorChannel</code> ， <code>interceptorChannel</code> 的创建方式是</p>
<p><code>ClientInterceptors.intercept(channel, interceptors)</code>， <code>interceptorChannel</code> 就是包了realchannel，</p>
<p>ManagedChannelImpl 的是实现中，</p>
<pre><code>  @Override
  <span class="hljs-keyword">public</span> <span class="hljs-operator">&lt;</span>ReqT, RespT<span class="hljs-operator">&gt;</span> ClientCall<span class="hljs-operator">&lt;</span>ReqT, RespT<span class="hljs-operator">&gt;</span> newCall(MethodDescriptor<span class="hljs-operator">&lt;</span>ReqT, RespT<span class="hljs-operator">&gt;</span> method,
      CallOptions callOptions) {
    <span class="hljs-keyword">return</span> interceptorChannel.newCall(method, callOptions);
  }
</code></pre><p>** 小结： ManagedChannelImpl 使用带拦截的RealChannel 创建的 PendingCall</p>
<h2 id="heading-pendingcall-clientcallimpl">PendingCall 为什么要包 ClientCallImpl</h2>
<p>大概思考一下，如果底层是Channel，Channel通常要进行网络连接，这个会放在另外一个线程里。
createChannel 之后有一个netty 线程进行连，等到ready 之后才把pending 的任务都执行一下。</p>
<p>接口上，这里主要是包了一个reprocess 方法， 可以和 InternalConfigSelector 进行配合。（todo)
reprocess 的作用就是 给 PendingCall 初始化 ClientCallImpl </p>
<p>PendingCall  的大部分方法还是 DelayClientCall，那么主要看 DelayClientCall 的作用</p>
<blockquote>
<p>A call that queues requests before a real call is ready to be delegated to.</p>
</blockquote>
<p>再 realCall 准备完成之前，把请求放到队列里。</p>
<pre><code><span class="hljs-operator">-</span> List<span class="hljs-operator">&lt;</span>Runnable<span class="hljs-operator">&gt;</span> pendingRunnables
<span class="hljs-operator">-</span> boolean passThrough
</code></pre><p>请求指的是 Runnable 的任务， 当任务执行完成之后，标志位 passThrough 为 true；再执行 DelayClientCall,  就会执行 ClientCallImpl；</p>
<p>通过断点可以看到，   Runnable 任务有四个，分别是执行ClientCallImpl 的   start，request，sendMessage, halfClose。</p>
<p>因此，PendingCall 执行方法的时候时候，不会真的执行，而且把方法放入list 中，等到万事具备，执行  DelayClientCall 的 setCall 方法返回一个Runable的 drainPendingCalls，可以依次执行这些任务。</p>
<p>TODO passThrough 什么时候 为true ？</p>
<h2 id="heading-pendingrunnables">哪个线程池执行了 pendingRunnables</h2>
<p>Stub 中会有线程池，ClientCall 和 channel 也会用到线程池，下面梳理一下线程池，用于后面分析这些pending任务的时序。下面发现有两个</p>
<h3 id="heading-57q56il5rgg5yib5bu6">线程池创建</h3>
<p>ManageChannelImpl 里有有 <code>executor</code> ,默认值是 <code>executorPool</code> get出来的。</p>
<p><code>executorPool</code> 相当于一个ExecutorFactory, 默认值在GrpcUtil里有一个static 成员变量</p>
<pre><code class="lang-erlang">return Executors.newCachedThreadPool(getThreadFactory(grpc-default-executor + "-%d", true));
</code></pre>
<p>这样，就可以用在<code>ManageChannelImpl</code> 一些任务的执行。</p>
<p>任务1</p>
<pre><code class="lang-erlang">new Runnable() {
        @Override
        public void run() {
          exitIdleMode();
        }
      }
</code></pre>
<p>另外netty 有两个线程 ， <code>ThreadPerTaskExecutor</code> 这个是，NettyChannelBuilder 先弄了一个 <code>executorPool</code>，再从 <code>executorPool</code> 里创建出来的。 <code>executorPool</code> 的默认值是  <code>SharedResourcePool.forResource(Utils.*DEFAULT_WORKER_EVENT_LOOP_GROUP*);</code>
名称是 grpc-default-worker-ELG, 这个是</p>
<p>因此 DelayedClientCall 的 pendings 任务还是 main 主线程执行的，用了<strong>一个无线程的线程池</strong>.</p>
<ul>
<li>先制造任务</li>
<li>再执行任务</li>
</ul>
<h2 id="heading-blockingunarycall">blockingUnaryCall 二次分析</h2>
<p>目前已经了解到Channel 和 ClientCall 的创建和相互关系，也了解到线程池和时序。</p>
<p>那么futureUnaryCall 这个异步 和 drain 的过程是怎么实现的呢？</p>
<pre><code class="lang-java">ListenableFuture&lt;RespT&gt; responseFuture = futureUnaryCall(call, req);
</code></pre>
<p>相当于 创建了四个 Runnable的任务, 这四个任务，pendingCall 执行了四个方法，但是最终的ClientCallImpl 并没有执行这四个方法，而且变成 Runnable 放入List 中。</p>
<pre><code class="lang-java">executor.waitAndDrain();
</code></pre>
<p>executor 的 drain 方法，才会执行这四个方法</p>
<pre><code class="lang-java">getUnchecked(responseFuture);
</code></pre>
<ul>
<li><code>ThreadlessExecutor</code> 怎么工作</li>
<li>Runnable 任务怎么构造，放在哪个实例的List 里了，后续Drain 是怎么把Runnable 取出来的</li>
<li><code>ListenableFuture</code> 怎么接住结果的</li>
</ul>
<h3 id="heading-threadlessexecutor">ThreadlessExecutor 代码分析</h3>
<p>execute 方法把runnable 放进队列里， 
waiter 在RPC 结束后会变成SHUTDOWN 常量</p>
<ol>
<li>如果 SHUTDOWN ，就从队列移除</li>
<li>如果 不是SHUTDOWN， 就会让 waiter unpark， 如果wait 是null ，就什么都不会发生。</li>
</ol>
<p>execute 就是一个 unpark通知，那waiter 是进入park 状态， waiter 醒来之后会干什么？</p>
<pre><code>    @Override
    <span class="hljs-keyword">public</span> void execute(Runnable runnable) {
      add(runnable);
      Object waiter <span class="hljs-operator">=</span> <span class="hljs-built_in">this</span>.waiter;
      <span class="hljs-keyword">if</span> (waiter <span class="hljs-operator">!</span><span class="hljs-operator">=</span> SHUTDOWN) {
        LockSupport.unpark((Thread) waiter); <span class="hljs-comment">// no-op if null</span>
      } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (remove(runnable) <span class="hljs-operator">&amp;</span><span class="hljs-operator">&amp;</span> rejectRunnableOnExecutor) {
        <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> RejectedExecutionException();
      }
    }
</code></pre><p>看 waitAndDrain 方法</p>
<p>1 先队列取任务
2.如果没有任务，waiter = Thread.currentThread(); 并且继续取任务，进入park 状态，循环等待，取到了任务，就把waiter 设置为空</p>
<ol>
<li>只要有任务，就把队列里的任务执行完，当前线程执行，并且吞异常.</li>
</ol>
<p>如果一直没有任务，就会hang住，除非中断，也没有new thread；</p>
<p>用法应该先</p>
<ol>
<li>用execute 把任务放队列里，然后waiter 为null， 就一直放。 比如放了四个任务</li>
<li>用waitAndDrain 拿到任务了</li>
</ol>
<p>或者 </p>
<ol>
<li>用waitAndDrain 等待，另外一个线程，用execute 把任务放进去, 然后唤醒了.</li>
</ol>
<p><strong> 小结: ThreadlessExecutor 的作用是使用unpark 协调两个线程的任务,形成生产消费的模式 </strong></p>
<h3 id="heading-threadlessexecutor">ThreadlessExecutor 结合上下文</h3>
<p><code>execute</code>方法 是放任务并唤醒，<code>waiterAndDrain</code>方法是等待，一次性取完, </p>
<p>虽然waiterAndDrain 是一次性执行完，但 responseFuture 只要不是Done， 就会一直执行下去。</p>
<p>根据断点，执行了以下五个任务，分别由不同的线程生产</p>
<p>任务1. penndingCall的reprocess 里的组合任务 DelayedPendingCall.drainPendingCalls  和 PendingCallRemoval （grpc-default-executor-0 生产 main 执行） ???</p>
<p>任务2. DelayedPendingCall里的drainPendingCalls 的最后一步 DrainListenerRunnable 任务 （main 生产 main 执行） 貌似是main 执行上一个任务的最后产生的，就是让listener也清空一下call</p>
<p>任务3. DelayedClientTransport.reprocess 里 stream.createRealStream(transport); (grpc-nio-worker-ELG-1-2)</p>
<p>任务4. ClientCallImpl$ClientStreamListenerImpl 的 headersRead 的任务 （grpc-nio-worker-ELG-1-2）</p>
<p>任务5  ClientCallImpl$ClientStreamListenerImpl 的 MessagesAvailable 的任务 （grpc-nio-worker-ELG-1-2）</p>
<p>3，4，5 都是传输时候的，一个建stream连接，两个读消息, 读完了消息需要 drain 一下任务，返回给listener，</p>
<p>可以看到这些任务里并没有 clientCall 的四个任务, 这四个任务是在任务1里执行。</p>
<p>放入时机： Main 线程 <code>ListenableFuture&lt;RespT&gt; responseFuture = futureUnaryCall(call, req);</code> Stub 直接使用 DelayedClientCall 实例依次 执行了 四个方法，放入了四个任务
取出时机： Main 线程 Stub 在 waitAndDrain 的时候，执行了任务1， DelayedPendingCall.drainPendingCalls  , DelayedPendingCall.drainPendingCalls 会把四个方法都执行.</p>
<h2 id="heading-blockingunarycall">blockingUnaryCall 小结</h2>
<p>串起来起来，就是运行的时候，</p>
<p>创建Channel 套娃， Channel 套娃创建 ClientCall套娃 外层，PendingCall  在 reprocess 的时候， 使用realChannel 创建clientCallImpl ， clientCallImpl 有四个方法，发起客户端的请求.</p>
<p>时序上大体：</p>
<ol>
<li>Main 在准备Listener的时候， 在PendingCall 的字段里准备四个方法的任务</li>
<li>grpc-default 执行Pending 的reprocess， 完成 创建clientCallImpl的创建，并通过 ThreadlessExecutor 给 Main 线程传递 drainPendingCalls 的任务</li>
<li>main 醒来执行 ThreadlessExecutor 的任务， 也就是 DelayedPendingCall 的 drainPendingCalls 方法，</li>
</ol>
<p>1和2 是同时执行的，但是3 和 1 同一段代码里，顺序已经保证了， 3 会等2， 因此 ，3 最后执行就行。</p>
<p>断点日志如下：</p>
<pre><code>trace 线程 main  添加任务  realCall.start()
trace 线程 grpc<span class="hljs-operator">-</span>default<span class="hljs-operator">-</span>executor<span class="hljs-number">-0</span>  添加任务 drainingPendingCall
trace 线程 main  添加任务  realCall.<span class="hljs-built_in">send</span>()
trace 线程 main  执行任务 drainingPendingCall
</code></pre><p>因此，PendingCall有四个方法要执行，主线程准备好任务，grpc 线程创建 创建clientCallImpl 之后，通知主线程执行 drainPendingCalls。 借助于 ThreadlessExecutor 完成了 IPC</p>
<p>// TODO 画一个时序图</p>
<h2 id="heading-5oc757ut">总结</h2>
<ol>
<li>上一篇，梳理了客户端发送包括 Stub， ClientCall，ClientStream</li>
<li>见类图，ClientCall 和ClientChannel 创建的过程见类图，多层嵌套之后，最底层有一个realChannel，一切源于Channel的创建</li>
<li>见时序图，ClientCall 四个方法包装成任务，借助 ThreadlessExecutor 实现了线程的协调，即 grpc-default-executor线程准备任务， main线程 执行任务。</li>
</ol>
<p>MORE：</p>
<p>整理清楚了，其实还挺简单的。</p>
<p>更深入， 
Stub 层：
 为什么需要 grpc-default-executor 来准备任务，grpc-default  应该是有一些准备底层的工作，把 clientCallImpl 设置好之后，比如联通了，才让调用开始执行。</p>
<ul>
<li>DelayCall 什么时候会passthrough
-Stream 层：可以看一下 Stream这一层是做什么，</li>
</ul>
]]></content:encoded></item><item><title><![CDATA[【夜读源码】grpc-java 概览]]></title><description><![CDATA[gRPC 是 Google 开源的一套语言无关基于HTTP2协议的 RPC 框架，其中 Java 的实现称为 grpc-java，代码地址在 RPC （remote process call）的含义是程序执行本地的一个方法（看上去像本地执行），实际上会在远程程序代码内执行，这个过程会涉及到网络通讯和传输协议。…]]></description><link>https://xiaok.me/grpc-java</link><guid isPermaLink="true">https://xiaok.me/grpc-java</guid><category><![CDATA[gRPC]]></category><category><![CDATA[Java]]></category><dc:creator><![CDATA[xiao kun]]></dc:creator><pubDate>Tue, 16 Aug 2022 17:17:54 GMT</pubDate><enclosure url="https://cdn.hashnode.com/res/hashnode/image/unsplash/TLxaYmixZ3k/upload/v1660228435275/yYxI0ngfL.jpeg" length="0" type="image/jpeg"/><content:encoded><![CDATA[<p>gRPC 是 Google 开源的一套语言无关基于HTTP2协议的 RPC 框架，其中 Java 的实现称为 grpc-java，代码地址在 https://github.com/grpc/grpc-java。</p>
<p>RPC （remote process call）的含义是程序执行本地的一个方法（看上去像本地执行），实际上会在远程程序代码内执行，这个过程会涉及到网络通讯和传输协议。gRPC作为 RPC 一种实现，传输的网络协议是HTTP2，传输的内容按照 Protocol Buffer 进行编码，并且支持各种语言的实现。</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1660231145754/TDYnQjZAb.png" alt="image.png" /></p>
<h1 id="heading-5qac6lw">概述</h1>
<p>grpc-java 是一个 RPC 库和框架，运行在 JDK 8 上，项目包括两部分：代码生成和运行库。
代码生成由C++编写，用于生成一部分Java 代码, 生成的部分，称为 stub，包括 client stub 和 server stub。
运行库由Java 编写，Java 项目可以引用这些运行库。</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1660231754973/BCuYW_Ki5.png" alt="image.png" /></p>
<p>在了解 stub 和 运行库的内容之前，运行一个完整的例子，把它运行起来。</p>
<h1 id="heading-grpc">gRPC 实例</h1>
<p>创建一个 Maven 作为项目管理工具的 Java 项目。</p>
<h2 id="heading-5re75yqg5l6d6lww">添加依赖</h2>
<p>把 grpc 的 运行库 都加进来</p>
<pre><code><span class="hljs-operator">&lt;</span>dependencies<span class="hljs-operator">&gt;</span>
  <span class="hljs-operator">&lt;</span>dependency<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>groupId<span class="hljs-operator">&gt;</span>io.grpc&lt;<span class="hljs-operator">/</span>groupId<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>artifactId<span class="hljs-operator">&gt;</span>grpc<span class="hljs-operator">-</span>netty<span class="hljs-operator">-</span>shaded<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>artifactId<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>version<span class="hljs-operator">&gt;</span><span class="hljs-number">1.48</span><span class="hljs-number">.1</span><span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>version<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>scope<span class="hljs-operator">&gt;</span>runtime<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>scope<span class="hljs-operator">&gt;</span>
  <span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>dependency<span class="hljs-operator">&gt;</span>
  <span class="hljs-operator">&lt;</span>dependency<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>groupId<span class="hljs-operator">&gt;</span>io.grpc&lt;<span class="hljs-operator">/</span>groupId<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>artifactId<span class="hljs-operator">&gt;</span>grpc<span class="hljs-operator">-</span>protobuf<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>artifactId<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>version<span class="hljs-operator">&gt;</span><span class="hljs-number">1.48</span><span class="hljs-number">.1</span><span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>version<span class="hljs-operator">&gt;</span>
  <span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>dependency<span class="hljs-operator">&gt;</span>
  <span class="hljs-operator">&lt;</span>dependency<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>groupId<span class="hljs-operator">&gt;</span>io.grpc&lt;<span class="hljs-operator">/</span>groupId<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>artifactId<span class="hljs-operator">&gt;</span>grpc<span class="hljs-operator">-</span>stub<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>artifactId<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>version<span class="hljs-operator">&gt;</span><span class="hljs-number">1.48</span><span class="hljs-number">.1</span><span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>version<span class="hljs-operator">&gt;</span>
  <span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>dependency<span class="hljs-operator">&gt;</span>
  <span class="hljs-operator">&lt;</span>dependency<span class="hljs-operator">&gt;</span> <span class="hljs-operator">&lt;</span><span class="hljs-operator">!</span><span class="hljs-operator">-</span><span class="hljs-operator">-</span> necessary <span class="hljs-keyword">for</span> Java <span class="hljs-number">9</span><span class="hljs-operator">+</span> <span class="hljs-operator">-</span><span class="hljs-operator">-</span><span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>groupId<span class="hljs-operator">&gt;</span>org.apache.tomcat&lt;<span class="hljs-operator">/</span>groupId<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>artifactId<span class="hljs-operator">&gt;</span>annotations<span class="hljs-operator">-</span>api<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>artifactId<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>version<span class="hljs-operator">&gt;</span><span class="hljs-number">6.0</span><span class="hljs-number">.53</span><span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>version<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>scope<span class="hljs-operator">&gt;</span>provided<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>scope<span class="hljs-operator">&gt;</span>
  <span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>dependency<span class="hljs-operator">&gt;</span>
<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>dependencies<span class="hljs-operator">&gt;</span>
</code></pre><h2 id="heading-5luj56cb55sf5oiq5os5lu2">代码生成插件</h2>
<p>为了能 生成代码，也就是生成Stub, 添加 maven 插件</p>
<pre><code><span class="hljs-operator">&lt;</span>build<span class="hljs-operator">&gt;</span>
  <span class="hljs-operator">&lt;</span>extensions<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>extension<span class="hljs-operator">&gt;</span>
      <span class="hljs-operator">&lt;</span>groupId<span class="hljs-operator">&gt;</span>kr.motd.maven&lt;<span class="hljs-operator">/</span>groupId<span class="hljs-operator">&gt;</span>
      <span class="hljs-operator">&lt;</span>artifactId<span class="hljs-operator">&gt;</span>os<span class="hljs-operator">-</span>maven<span class="hljs-operator">-</span>plugin<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>artifactId<span class="hljs-operator">&gt;</span>
      <span class="hljs-operator">&lt;</span>version<span class="hljs-operator">&gt;</span><span class="hljs-number">1.6</span><span class="hljs-number">.2</span><span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>version<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>extension<span class="hljs-operator">&gt;</span>
  <span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>extensions<span class="hljs-operator">&gt;</span>
  <span class="hljs-operator">&lt;</span>plugins<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span>plugin<span class="hljs-operator">&gt;</span>
      <span class="hljs-operator">&lt;</span>groupId<span class="hljs-operator">&gt;</span>org.xolstice.maven.plugins&lt;<span class="hljs-operator">/</span>groupId<span class="hljs-operator">&gt;</span>
      <span class="hljs-operator">&lt;</span>artifactId<span class="hljs-operator">&gt;</span>protobuf<span class="hljs-operator">-</span>maven<span class="hljs-operator">-</span>plugin<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>artifactId<span class="hljs-operator">&gt;</span>
      <span class="hljs-operator">&lt;</span>version<span class="hljs-operator">&gt;</span><span class="hljs-number">0</span><span class="hljs-number">.6</span><span class="hljs-number">.1</span><span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>version<span class="hljs-operator">&gt;</span>
      <span class="hljs-operator">&lt;</span>configuration<span class="hljs-operator">&gt;</span>
        <span class="hljs-operator">&lt;</span>protocArtifact<span class="hljs-operator">&gt;</span>com.google.protobuf:protoc:<span class="hljs-number">3.21</span><span class="hljs-number">.1</span>:exe:${os.detected.classifier}<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>protocArtifact<span class="hljs-operator">&gt;</span>
        <span class="hljs-operator">&lt;</span>pluginId<span class="hljs-operator">&gt;</span>grpc<span class="hljs-operator">-</span>java<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>pluginId<span class="hljs-operator">&gt;</span>
        <span class="hljs-operator">&lt;</span>pluginArtifact<span class="hljs-operator">&gt;</span>io.grpc:protoc<span class="hljs-operator">-</span>gen<span class="hljs-operator">-</span>grpc<span class="hljs-operator">-</span>java:<span class="hljs-number">1.48</span><span class="hljs-number">.1</span>:exe:${os.detected.classifier}<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>pluginArtifact<span class="hljs-operator">&gt;</span>
      <span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>configuration<span class="hljs-operator">&gt;</span>
      <span class="hljs-operator">&lt;</span>executions<span class="hljs-operator">&gt;</span>
        <span class="hljs-operator">&lt;</span>execution<span class="hljs-operator">&gt;</span>
          <span class="hljs-operator">&lt;</span>goals<span class="hljs-operator">&gt;</span>
            <span class="hljs-operator">&lt;</span>goal<span class="hljs-operator">&gt;</span>compile<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>goal<span class="hljs-operator">&gt;</span>
            <span class="hljs-operator">&lt;</span>goal<span class="hljs-operator">&gt;</span>compile<span class="hljs-operator">-</span>custom<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>goal<span class="hljs-operator">&gt;</span>
          <span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>goals<span class="hljs-operator">&gt;</span>
        <span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>execution<span class="hljs-operator">&gt;</span>
      <span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>executions<span class="hljs-operator">&gt;</span>
    <span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>plugin<span class="hljs-operator">&gt;</span>
  <span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>plugins<span class="hljs-operator">&gt;</span>
<span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span>build<span class="hljs-operator">&gt;</span>
</code></pre><h2 id="heading-grpc">grpc 接口描述</h2>
<p>需要写一个描述文件 <code>src/main/proto/hello.proto</code>，按照protocol buffer的语法，定义 方法的名称和参数的数据格式。
代码生成插件，读取 hello.proto，生成 stub</p>
<pre><code>syntax = "proto3";

<span class="hljs-keyword">option</span> java_package = "org.shalk.grpc";

message <span class="hljs-keyword">Info</span> {
  int32 id = <span class="hljs-number">1</span>;
  string <span class="hljs-type">name</span> = <span class="hljs-number">2</span>;
  <span class="hljs-type">bool</span> ready = <span class="hljs-number">3</span>;
}

service Hello{
  rpc echo(<span class="hljs-keyword">Info</span>) <span class="hljs-keyword">returns</span> (<span class="hljs-keyword">Info</span>);
  rpc clientStream (<span class="hljs-keyword">Info</span>) <span class="hljs-keyword">returns</span> (stream <span class="hljs-keyword">Info</span>);
  rpc serverStream (stream <span class="hljs-keyword">Info</span>) <span class="hljs-keyword">returns</span> (<span class="hljs-keyword">Info</span>);
  rpc biStream (stream <span class="hljs-keyword">Info</span>) <span class="hljs-keyword">returns</span> (stream <span class="hljs-keyword">Info</span>);
}
</code></pre><h2 id="heading-55sf5oiq5luj56cb">生成代码</h2>
<pre><code><span class="hljs-attribute">mvn</span> compile
</code></pre><h2 id="heading-57yw5yaz5pyn5yqh56uv5luj56cb">编写服务端代码</h2>
<p>服务端需要写两部分代码，server stub implement （服务端 stub 实现）和 server start （服务端启动）
服务端 stub 实现，就是对<code>rpc echo(Info) returns (Info);</code> 的实现。
服务端启动，是启动一个端口，对外提供网络服务，这样客户端就可以通过网络请求把请求数据发过来，服务端在执行完请求后，把执行结果发送回去。</p>
<pre><code><span class="hljs-comment">//  服务端 stub 实现</span>
<span class="hljs-keyword">public</span> class HelloImpl extends HelloGrpc.HelloImplBase {
    @Override
    <span class="hljs-keyword">public</span> void echo(HelloOuterClass.Info request, StreamObserver<span class="hljs-operator">&lt;</span>HelloOuterClass.Info&gt; responseObserver) {
        System.out.printf(<span class="hljs-string">"request info Id:%d\n"</span>, request.getId());
        responseObserver.onNext(request);
        responseObserver.onCompleted();
    }
}
</code></pre><p>服务端启动</p>
<pre><code><span class="hljs-keyword">import</span> <span class="hljs-title">io</span>.<span class="hljs-title">grpc</span>.<span class="hljs-title">Server</span>;
<span class="hljs-keyword">import</span> <span class="hljs-title">io</span>.<span class="hljs-title">grpc</span>.<span class="hljs-title">ServerBuilder</span>;
<span class="hljs-keyword">import</span> <span class="hljs-title">java</span>.<span class="hljs-title">io</span>.<span class="hljs-title">IOException</span>;

<span class="hljs-keyword">public</span> class SimpleServer {
    <span class="hljs-keyword">public</span> static void main(String[] args) throws IOException, InterruptedException {
        Server server <span class="hljs-operator">=</span> ServerBuilder.forPort(<span class="hljs-number">8080</span>).addService(<span class="hljs-keyword">new</span> HelloImpl()).build();
        server.start();
        System.out.println(<span class="hljs-string">"server started"</span>);
        server.awaitTermination();
        System.out.println(<span class="hljs-string">"server stoped"</span>);

    }
}
</code></pre><h2 id="heading-57yw5yaz5a6i5oi356uv5luj56cb">编写客户端代码</h2>
<p>客户端需要些两部分代码，client stub initial (客户端 stub 初始化） 和 client stub call （客户端 stub 调用）</p>
<pre><code>
<span class="hljs-keyword">import</span> <span class="hljs-title">io</span>.<span class="hljs-title">grpc</span>.<span class="hljs-title">Channel</span>;
<span class="hljs-keyword">import</span> <span class="hljs-title">io</span>.<span class="hljs-title">grpc</span>.<span class="hljs-title">ManagedChannelBuilder</span>;

<span class="hljs-keyword">public</span> class SimpleClient {
    <span class="hljs-keyword">public</span> static void main(String[] args) {
        <span class="hljs-comment">// 客户端 stub  初始化</span>
        Channel channel <span class="hljs-operator">=</span> ManagedChannelBuilder.forAddress(<span class="hljs-string">"localhost"</span>, <span class="hljs-number">8080</span>).usePlaintext().build();
        HelloGrpc.HelloBlockingStub helloBlockingStub <span class="hljs-operator">=</span> HelloGrpc.newBlockingStub(channel);
        <span class="hljs-comment">// 客户端 stub 调用</span>
        <span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i <span class="hljs-operator">=</span> <span class="hljs-number">0</span>; i <span class="hljs-operator">&lt;</span> <span class="hljs-number">100</span>; i<span class="hljs-operator">+</span><span class="hljs-operator">+</span>) {
            HelloOuterClass.Info request <span class="hljs-operator">=</span> HelloOuterClass.Info.newBuilder().setId(i).setName(<span class="hljs-string">"hi"</span>).setReady(<span class="hljs-literal">true</span>).build();
            HelloOuterClass.Info response <span class="hljs-operator">=</span> helloBlockingStub.echo(request);
            System.out.printf(<span class="hljs-string">"get response A:%d\n"</span>, response.getId());
        }
    }

}
</code></pre><h2 id="heading-6lq6kgm">运行</h2>
<p>服务端先启动，客户端运行可以看到结果</p>
<pre><code><span class="hljs-keyword">get</span> response A:<span class="hljs-number">96</span>
<span class="hljs-keyword">get</span> response A:<span class="hljs-number">97</span>
<span class="hljs-keyword">get</span> response A:<span class="hljs-number">98</span>
<span class="hljs-keyword">get</span> response A:<span class="hljs-number">99</span>
</code></pre><h1 id="heading-5pw05l2t5p625p6e">整体架构</h1>
<p>整体架构，纵向上，gRPC可以分为 服务端和客户端，横向上，可以划分为传输层，通道层 和 Stub 层三层。第一层，Stub 层 是提供给开发者的接口和数据模型，这个和proto 文件描述的是一致的。第二层，通道层（Channel）是在传输层之上，提供给Stub 层用的。主要作用是做一些拦截器和装饰器，一般通信传输会做一些拦截，可以做 日志，权限和监控等等。第三层，传输层是用于接收和发送数据的层次，它的接口一般不对外暴露。</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1660574982821/TrCPQoXj_.png" alt="image.png" /></p>
<h1 id="heading-5lia5qyh6lcd55so55qe5pe25bqp">一次调用的时序</h1>
<p>回顾前面的示例代码，客户端 <code>helloBlockingStub</code> 的一次调用，服务端响应请求。第一步，请求从客户端的Stub层，依次穿过客户端的通道层，传输层，到达网络上。其次，数据通过网络到达服务端的传输层，依次穿过服务端的通道层，最后到达Stub 层 ，也就是服务端的实现。最后，服务端的实现中Stub 响应结果，逆向把数据传输到客户端的Stub 层。</p>
<h2 id="heading-5a6i5oi356uv5yr6ycb6k35rgc">客户端发送请求</h2>
<ol>
<li>stub 执行echo 方法</li>
<li>echo 方法 执行静态方法blockingUnarycall</li>
<li>blockingUsnaryCall中，构造了一个ClientCall，ClientCall 准备了了一个listenablefuture，等Listenablefuture 状态是Done，就把结果从ListenableFuture 中返回。</li>
<li>准备listenableFuture时，DelayedClientCall  里准备了 四个pendingRunnables 的任务等待执行。
5 等待状态时Done的时候，exector.waitAndDrain  把这四个任务拿到，分别执行一下。</li>
<li>任务1 realCall.start(finalListener, headers);</li>
<li>任务2  realCall.request(numMessages);</li>
<li>任务3 realCall.sendMessage(message);</li>
<li>任务4 realCall.halfClose();</li>
<li>DelayedClientCall 代理 realCall， realCall 是ClientCallImpl
11  realCall 代理 ClientStream ， clientStream 有接口 <code>void start(ClientStreamListener listener);</code> <code>void request(int numMessages);</code> <code>void writeMessage(InputStream message);</code> 和 <code>halfClose()</code>
12  ClientCallImpl 中又把这四个方法，代理给 Stream，Stream的类型是 RetriableStream
13 RetriableStream 又执行过程创建DelayStream，代理给DelayStream
14 DelayStream 又创建四个任务。 （request，writeMessage，flush 和 halfCLose）
15 DelayStream 把任务代理给realStream，这个realStream 是 NettyClientStream</li>
</ol>
<p>整理来看 Stub 把请求传给了ClientCall， ClientCall 传给了 ClientStream</p>
<p>ClientStream 有Netty 的实现，内部会把数据传输到网络上。</p>
<p>这里面Transport 和 Framer 的逻辑还没明白，第一篇大概就先看到这里。</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1660667983311/LS3EJ2EP-.png" alt="image.png" /></p>
<h2 id="heading-5pyn5yqh56uv5o6l5ps26k35rgc">服务端接收请求</h2>
<p>类似的，服务端也有 ServerCall 和ServerStream, 并且把deramer 解数据的任务扔到线程池。
deframer 把解开的数据，找到listener，执行到 Stub 的实现里，数据送达。</p>
<p>ServerCall =&gt; ServerStream =&gt; Deframer</p>
<h2 id="heading-5pyn5yqh56uv5zue5asn5zon5bqu">服务端回复响应</h2>
<p>类似于客户端发请求</p>
<h2 id="heading-5a6i5oi356uv5o6l5ps25zon5bqu">客户端接收响应</h2>
<p>类似于服务端收请求</p>
<h1 id="heading-next">Next</h1>
<p>一次调用中，客户端和服务端处理请求的过程，可以按照层次和时许，把过程梳理更清晰一点。
下一篇文章，将深入<code>客户端发送请求</code>，把客户端中 ClientCall 的作用，ClientStream的作用，时序线程池，以及Netty 怎么把数据发送出去，以及数据包的格式 细致的展开写一写。</p>
]]></content:encoded></item><item><title><![CDATA[喝一杯mockito]]></title><description><![CDATA[mockito 是最常用的 java mock 库， 用于模拟创建各种对象和行为。本文会介绍一下 基础库 mockitio的用法，进行一些练习。mockitio 通常不单独使用，配合 Junit一起使用。 下面列举一下用法, 创建mock 对象，并且可以要求，这个对象的成员方法符合我们的行为要求。…]]></description><link>https://xiaok.me/mockito</link><guid isPermaLink="true">https://xiaok.me/mockito</guid><category><![CDATA[Java]]></category><category><![CDATA[mockito]]></category><category><![CDATA[write code]]></category><dc:creator><![CDATA[xiao kun]]></dc:creator><pubDate>Wed, 20 Jul 2022 16:35:26 GMT</pubDate><enclosure url="https://cdn.hashnode.com/res/hashnode/image/unsplash/xBFTjrMIC0c/upload/v1658328930346/cqtyECWn5.jpeg" length="0" type="image/jpeg"/><content:encoded><![CDATA[<p>mockito 是最常用的 java mock 库， 用于模拟创建各种对象和行为。本文会介绍一下 基础库 mockitio的用法，进行一些练习。mockitio 通常不单独使用，配合 Junit一起使用。</p>
<p>下面列举一下用法,</p>
<h1 id="heading-5qih5ouf5a56lgh">模拟对象</h1>
<p>创建mock 对象，并且可以要求，这个对象的成员方法符合我们的行为要求。</p>
<pre><code>    Foo foo<span class="hljs-operator">=</span> Mockito.mock(Foo.class);
</code></pre><hr />
<h1 id="heading-55u05o6l6lu5zue">直接返回</h1>
<p>直接返回，我们需要的值</p>
<p>when thenReturn</p>
<pre><code>  @Test
  void returnWhatIWant() {
    Foo mock <span class="hljs-operator">=</span> Mockito.mock(Foo.class);
    Mockito.when(mock.say()).thenReturn(<span class="hljs-string">"nice to meet you"</span>);
    String result <span class="hljs-operator">=</span> mock.say();
    Assertions.assertEquals(<span class="hljs-string">"nice to meet you"</span>, result);
  }
</code></pre><hr />
<h1 id="heading-5a6a5yi25pa55rov">定制方法</h1>
<p>定制方法，改变方法的实现
when thenAnswer</p>
<pre><code>@Test
void returnBaseOneParamOrSomething() {
  Foo mock <span class="hljs-operator">=</span> Mockito.mock(Foo.class);
  Mockito.when(mock.echo(anyString()))
      .thenAnswer(
          <span class="hljs-keyword">new</span> Answer<span class="hljs-operator">&lt;</span>String<span class="hljs-operator">&gt;</span>() {
            @Override
            <span class="hljs-keyword">public</span> String answer(InvocationOnMock invocationOnMock) throws Throwable {
              String argument <span class="hljs-operator">=</span> invocationOnMock.getArgument(<span class="hljs-number">0</span>, String.class);
              <span class="hljs-keyword">return</span> <span class="hljs-string">"hi,"</span><span class="hljs-operator">+</span>argument;
            }
          });
  String result <span class="hljs-operator">=</span> mock.echo(<span class="hljs-string">"all"</span>);
  Assertions.assertEquals(<span class="hljs-string">"hi,all"</span>, result);
}
</code></pre><hr />
<h1 id="heading-6aqm6kb5pa55rov5omn6kgm5qyh5pwwiowsjcdml7bpl7q">验证方法执行次数 和 时间</h1>
<pre><code>  @Test
  void verifyMethod() {
    Foo foo <span class="hljs-operator">=</span> Mockito.mock(Foo.class);
    foo.say();

    Mockito.verify(foo).say();
    Mockito.verify(foo, Mockito.times(<span class="hljs-number">1</span>)).say();
    Mockito.verify(foo, Mockito.timeout(<span class="hljs-number">1000</span>)).say();
  }
</code></pre><hr />
<h1 id="heading-5qih5ouf6z2z5ocb5pa55rov">模拟静态方法</h1>
<p>改变静态方法的行为（使用 mockito-inline 作为依赖）</p>
<pre><code>@Test
  void mockStaticMethod() {
    <span class="hljs-keyword">try</span> (MockedStatic<span class="hljs-operator">&lt;</span>Foo<span class="hljs-operator">&gt;</span> fooMockedStatic <span class="hljs-operator">=</span> Mockito.mockStatic(Foo.class)) {
      fooMockedStatic.when(() <span class="hljs-operator">-</span><span class="hljs-operator">&gt;</span> Foo.hold()).thenReturn(<span class="hljs-string">"hi"</span>);
      String result <span class="hljs-operator">=</span> Foo.hold();
      Assertions.assertEquals(<span class="hljs-string">"hi"</span>, result);
    }

    <span class="hljs-keyword">try</span>(MockedStatic<span class="hljs-operator">&lt;</span>Foo<span class="hljs-operator">&gt;</span> fooMockedStatic <span class="hljs-operator">=</span> Mockito.mockStatic(Foo.class)) {
      fooMockedStatic.when(()<span class="hljs-operator">-</span><span class="hljs-operator">&gt;</span>Foo.reply(anyString())).thenAnswer(
          <span class="hljs-keyword">new</span> Answer<span class="hljs-operator">&lt;</span>String<span class="hljs-operator">&gt;</span>() {
            @Override
            <span class="hljs-keyword">public</span> String answer(InvocationOnMock invocationOnMock) throws Throwable {
              String arg <span class="hljs-operator">=</span> invocationOnMock.getArgument(<span class="hljs-number">0</span>,String.class);
              <span class="hljs-keyword">return</span> <span class="hljs-string">"hi,"</span> <span class="hljs-operator">+</span> arg;
            }
          }
      );
      String result <span class="hljs-operator">=</span> Foo.reply(<span class="hljs-string">"1024"</span>);
      Assertions.assertEquals(<span class="hljs-string">"hi,1024"</span>,result);
    }
  }
</code></pre><hr />
<h1 id="heading-5qih5ouf5p6e6ycg5ye95pww">模拟构造函数</h1>
<p>改名构造函数的行为，使得创建出来的都是模拟对象。</p>
<pre><code>@Test
  void mockConstruction() {
    <span class="hljs-keyword">try</span> (MockedConstruction<span class="hljs-operator">&lt;</span>Foo<span class="hljs-operator">&gt;</span> fooMockedConstruction <span class="hljs-operator">=</span> Mockito.mockConstruction(Foo.class)) {
      Foo foo <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> Foo();
      foo.say();
      Mockito.verify(foo).say();
    }

    <span class="hljs-keyword">try</span> (MockedConstruction<span class="hljs-operator">&lt;</span>Foo<span class="hljs-operator">&gt;</span> fooMockedConstruction <span class="hljs-operator">=</span>
        Mockito.mockConstruction(
            Foo.class,
            <span class="hljs-keyword">new</span> MockedConstruction.MockInitializer&lt;Foo<span class="hljs-operator">&gt;</span>() {
              @Override
              <span class="hljs-keyword">public</span> void prepare(Foo foo1, MockedConstruction.Context context) {
                Mockito.when(foo1.say()).thenReturn(<span class="hljs-string">"mock"</span>);
              }
            })) {
      Foo foo3 <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> Foo();
      String result <span class="hljs-operator">=</span> foo3.say();
      Mockito.verify(foo3, Mockito.times(<span class="hljs-number">1</span>)).say();

      Assertions.assertEquals(<span class="hljs-string">"mock"</span>, result);
    }
  }
</code></pre><h1 id="heading-5yc5pww5yy56ywn">参数匹配</h1>
<p>只对某个方法的特定参数进行模拟，其他参数不模拟</p>
<pre><code>  @Test
  void mockSpecificArgument() {
    Foo foo <span class="hljs-operator">=</span> Mockito.mock(Foo.class);
    Mockito.when(foo.echo(eq(<span class="hljs-string">"hello"</span>))).thenReturn(<span class="hljs-string">"nonono"</span>);
    Assertions.assertEquals(<span class="hljs-string">"nonono"</span>, foo.echo(<span class="hljs-string">"hello"</span>));
    Mockito.verify(foo).echo(<span class="hljs-string">"hello"</span>);

    Assertions.assertNull(foo.echo(<span class="hljs-string">"other"</span>));
    Mockito.verify(foo).echo(<span class="hljs-string">"other"</span>);
  }
</code></pre><h1 id="heading-5b6f57ut">待续</h1>
<p>TBD</p>
<p>总结，上面是我常用的一些 mockito 方法。</p>
]]></content:encoded></item><item><title><![CDATA[Log 框架 设计]]></title><description><![CDATA[Log 日志框架，从使用者角度 有两个部分，配置和接口。 支持五种级别的日志打印，ERROR/WARN/INFO/DEBUG 支持日志命名空间隔离 支持对每个命名空间的日志，级别选择 支持对每个命名空间的日志，配置输出目标 支出输出目标到控制台 和 文件 支持日志格式控制 （级别，线程，命名空间，消息，时间）]]></description><link>https://xiaok.me/log</link><guid isPermaLink="true">https://xiaok.me/log</guid><category><![CDATA[logging]]></category><dc:creator><![CDATA[xiao kun]]></dc:creator><pubDate>Mon, 23 Aug 2021 15:50:55 GMT</pubDate><content:encoded><![CDATA[<p>Log 日志框架，从使用者角度 有两个部分，配置和接口。</p>
<h1 id="5o6l5yj6k66k6h">接口设计</h1>
<p>支持五种级别的日志打印，ERROR/WARN/INFO/DEBUG
支持日志命名空间隔离</p>
<h1 id="6ywn572u6k66k6h">配置设计</h1>
<p>支持对每个命名空间的日志，级别选择
支持对每个命名空间的日志，配置输出目标
支出输出目标到控制台 和 文件
支持日志格式控制  （级别，线程，命名空间，消息，时间）</p>
<p>实现：</p>
<ol>
<li>LoggerFactory 按命名空间创建Logger</li>
<li>Logger 按级别打印日志，把日志封装成LogMessage</li>
<li>LoggerTarget  控制日志的输出目标，关联Logger</li>
<li>LoggerFormat 控制日志的输出格式，关联Target，Format格式化LogMessage</li>
<li>LoggerConfig，其中包括Target和Logger的关联，Logger和Format的关联，Format的初始化</li>
</ol>
<p>Q1： LogMessage 如果把很多信息都保存下来，那么每次创建Message耗费大量内存
A1： 对于同一个Logger，相同的信息可以缓存下来，LogMessage只是持有引用。</p>
<p>Q2:   Logger 打印如果提高性能，避免同步打印
A2:   打印文件可以设置buffer，然后单独进行刷；或者设计ringbuffer； 或者增加异步的Target，也就是输出线程和打印线程分离。</p>
]]></content:encoded></item><item><title><![CDATA[802. Find Eventual Safe States]]></title><description><![CDATA[在有向图中，以某个节点为起始节点，从该点出发，每一步沿着图中的一条有向边行走。如果到达的节点是终点（即它没有连出的有向边），则停止。 对于一个起始节点，如果从该节点出发，无论每一步选择沿哪条有向边行走，最后必然在有限步内到达终点，则将该起始节点称作是 安全 的。…]]></description><link>https://xiaok.me/802-find-eventual-safe-states</link><guid isPermaLink="true">https://xiaok.me/802-find-eventual-safe-states</guid><category><![CDATA[algorithms]]></category><dc:creator><![CDATA[xiao kun]]></dc:creator><pubDate>Thu, 05 Aug 2021 14:17:06 GMT</pubDate><content:encoded><![CDATA[<p>https://leetcode-cn.com/problems/find-eventual-safe-states</p>
<h1 id="problem">problem</h1>
<blockquote>
<p>在有向图中，以某个节点为起始节点，从该点出发，每一步沿着图中的一条有向边行走。如果到达的节点是终点（即它没有连出的有向边），则停止。</p>
<p>对于一个起始节点，如果从该节点出发，无论每一步选择沿哪条有向边行走，最后必然在有限步内到达终点，则将该起始节点称作是 安全 的。</p>
<p>返回一个由图中所有安全的起始节点组成的数组作为答案。答案数组中的元素应当按 升序 排列。</p>
<p>该有向图有 n 个节点，按 0 到 n - 1 编号，其中 n 是 graph 的节点数。图以下述形式给出：graph[i] 是编号 j 节点的一个列表，满足 (i, j) 是图的一条有向边。</p>
</blockquote>
<h1 id="example">example</h1>
<p>示例 1：</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1628172332032/vMdtYPfd7.png" alt="image.png" /></p>
<pre><code><span class="hljs-string">输入：graph</span> <span class="hljs-string">=</span> [[<span class="hljs-number">1</span>,<span class="hljs-number">2</span>],[<span class="hljs-number">2</span>,<span class="hljs-number">3</span>],[<span class="hljs-number">5</span>],[<span class="hljs-number">0</span>],[<span class="hljs-number">5</span>],[],[]]
<span class="hljs-string">输出：[2,4,5,6]</span>
<span class="hljs-string">解释：示意图如上。</span>
</code></pre><p>示例 2：</p>
<pre><code><span class="hljs-string">输入：graph</span> <span class="hljs-string">=</span> [[<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>],[<span class="hljs-number">1</span>,<span class="hljs-number">2</span>],[<span class="hljs-number">3</span>,<span class="hljs-number">4</span>],[<span class="hljs-number">0</span>,<span class="hljs-number">4</span>],[]]
<span class="hljs-string">输出：[4]</span>
</code></pre><h1 id="solution">solution</h1>
<pre><code><span class="hljs-comment">/**
 try each node, if node can depth-first search without loop , node is safe.
 dfs 时候由于会遇到访问过的节点，因此需要分情况，这分情况标记：
           0 表示未访问
           1 表示已访问，在父节点上，或者 之前的环 （危险和潜在不安全的节点）
           2 表示已访问，已知的安全节点
 有时会遇到之前访问过的节点，这个时候要看这个节点是否为父节点，或者不安全的节点。
 当安全返回时，需要把父节点的标记，置为安全。
 当非安全返回时，保持父节点的标记，为不安全。
 */</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span> </span>{
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">List</span>&lt;<span class="hljs-keyword">Integer</span>&gt; eventualSafeNodes(<span class="hljs-keyword">int</span>[][] graph) {
        <span class="hljs-keyword">int</span> n = graph.length;
        <span class="hljs-keyword">int</span>[] visit = <span class="hljs-keyword">new</span> <span class="hljs-keyword">int</span>[n];
        <span class="hljs-keyword">List</span>&lt;<span class="hljs-keyword">Integer</span>&gt; ret = <span class="hljs-keyword">new</span> ArrayList&lt;&gt;();

        <span class="hljs-keyword">for</span>(<span class="hljs-keyword">int</span> i = <span class="hljs-number">0</span> ; i &lt; n; i++) {

            <span class="hljs-keyword">if</span> (dfs(i, graph, visit)) {
                ret.add(i);
            }
        }
        <span class="hljs-keyword">return</span> ret;
    }

    <span class="hljs-keyword">public</span> <span class="hljs-keyword">boolean</span> dfs(<span class="hljs-keyword">int</span> i , <span class="hljs-keyword">int</span>[][] graph, <span class="hljs-keyword">int</span>[] visit) {
        <span class="hljs-comment">// when loop</span>
        <span class="hljs-keyword">if</span> (visit[i] == <span class="hljs-number">0</span>) {
        } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span>(visit[i] == <span class="hljs-number">1</span>) {
            <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
        } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span>(visit[i] == <span class="hljs-number">2</span>) {
            <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
        }
        <span class="hljs-comment">// push i</span>
        visit[i] = <span class="hljs-number">1</span>;
        <span class="hljs-keyword">int</span>[] neigh = graph[i];
        <span class="hljs-keyword">for</span>(<span class="hljs-keyword">int</span> n: neigh) {
            <span class="hljs-keyword">if</span>(!dfs(n, graph, visit)) {
                <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
            }
        }
        <span class="hljs-comment">// pop i;</span>
        visit[i] = <span class="hljs-number">2</span>;
        <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    }
}
</code></pre>]]></content:encoded></item><item><title><![CDATA[611. Valid Triangle Number]]></title><description><![CDATA[Given an integer array nums, return the number of triplets chosen from the array that can make triangles if we take them as side lengths of a triangle…]]></description><link>https://xiaok.me/611-valid-triangle-number</link><guid isPermaLink="true">https://xiaok.me/611-valid-triangle-number</guid><category><![CDATA[algorithms]]></category><dc:creator><![CDATA[xiao kun]]></dc:creator><pubDate>Wed, 04 Aug 2021 14:12:24 GMT</pubDate><content:encoded><![CDATA[<h1 id="problem">problem</h1>
<blockquote>
<p>Given an integer array nums, return the number of triplets chosen from the array that can make triangles if we take them as side lengths of a triangle.</p>
</blockquote>
<h1 id="example">example</h1>
<p>Example 1:</p>
<pre><code><span class="hljs-attr">Input:</span> <span class="hljs-string">nums</span> <span class="hljs-string">=</span> [<span class="hljs-number">2</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>]
<span class="hljs-attr">Output:</span> <span class="hljs-number">3</span>
<span class="hljs-attr">Explanation: Valid combinations are:</span> 
<span class="hljs-number">2</span><span class="hljs-string">,3,4</span> <span class="hljs-string">(using</span> <span class="hljs-string">the</span> <span class="hljs-string">first</span> <span class="hljs-number">2</span><span class="hljs-string">)</span>
<span class="hljs-number">2</span><span class="hljs-string">,3,4</span> <span class="hljs-string">(using</span> <span class="hljs-string">the</span> <span class="hljs-string">second</span> <span class="hljs-number">2</span><span class="hljs-string">)</span>
<span class="hljs-number">2</span><span class="hljs-string">,2,3</span>
</code></pre><p>Example 2:</p>
<pre><code><span class="hljs-attr">Input:</span> <span class="hljs-string">nums</span> <span class="hljs-string">=</span> [<span class="hljs-number">4</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>]
<span class="hljs-attr">Output:</span> <span class="hljs-number">4</span>
</code></pre><p>Constraints:</p>
<pre><code><span class="hljs-number">1</span> <span class="hljs-string">&lt;=</span> <span class="hljs-string">nums.length</span> <span class="hljs-string">&lt;=</span> <span class="hljs-number">1000</span>
<span class="hljs-number">0</span> <span class="hljs-string">&lt;=</span> <span class="hljs-string">nums[i]</span> <span class="hljs-string">&lt;=</span> <span class="hljs-number">1000</span>
</code></pre><h1 id="solution">solution</h1>
<pre><code><span class="hljs-comment">/**
find all a &lt;= b &lt;= c   make triangles, so a &lt; c - b
iterate all c , iterate all b , than binary seach a 
time complexity O(n^2 log n)
 */</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span> {</span>
    <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">int</span> <span class="hljs-title">triangleNumber</span><span class="hljs-params">(<span class="hljs-keyword">int</span>[] nums)</span> </span>{
        <span class="hljs-keyword">int</span> n = nums.length;
        <span class="hljs-keyword">int</span> ret = <span class="hljs-number">0</span>;
        Arrays.sort(nums);
        <span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = n<span class="hljs-number">-1</span>; i &gt;= <span class="hljs-number">0</span>; i--) {
            <span class="hljs-keyword">int</span> c = nums[i];
            <span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> k = i - <span class="hljs-number">1</span>; k &gt;=<span class="hljs-number">1</span>; k--) {
                <span class="hljs-keyword">int</span> b = nums[k];
                <span class="hljs-comment">// find the smallest index j </span>
                <span class="hljs-comment">// satisfy nums[j] =  a  &gt; c - b = target;</span>
                <span class="hljs-keyword">int</span> j = binarySearch(nums, <span class="hljs-number">0</span>, k<span class="hljs-number">-1</span>, c - b);
                ret += (k - j);
            }
        }
        <span class="hljs-keyword">return</span> ret;
    }

    <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">int</span> <span class="hljs-title">binarySearch</span><span class="hljs-params">(<span class="hljs-keyword">int</span>[] arr,<span class="hljs-keyword">int</span> left, <span class="hljs-keyword">int</span> right, <span class="hljs-keyword">int</span> t)</span> </span>{
        <span class="hljs-keyword">while</span>(left &lt;= right) {
            <span class="hljs-keyword">int</span> mid = left + (right - left)/<span class="hljs-number">2</span>;
            <span class="hljs-keyword">if</span> (arr[mid] &gt; t) {
                right = mid - <span class="hljs-number">1</span>;
            } <span class="hljs-keyword">else</span> {
                left = mid +<span class="hljs-number">1</span>;
            }
        }
        <span class="hljs-keyword">return</span> left;
    }
}
</code></pre><pre><code><span class="hljs-comment">/**
two pointer
 */</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span> {</span>
    <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">int</span> <span class="hljs-title">triangleNumber</span><span class="hljs-params">(<span class="hljs-keyword">int</span>[] nums)</span> </span>{
        <span class="hljs-keyword">int</span> n = nums.length;
        <span class="hljs-keyword">int</span> ret = <span class="hljs-number">0</span>;
        Arrays.sort(nums);
        <span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = <span class="hljs-number">0</span>; i &lt; n; i++) {
            <span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> j = i + <span class="hljs-number">1</span>, k = j; j &lt; n<span class="hljs-number">-1</span> &amp;&amp; k &lt; n; j++) {
                <span class="hljs-comment">// find the max k , nums[k] &lt; a + b</span>
                <span class="hljs-keyword">if</span> (k &lt; j) {
                    k = j;
                }
                <span class="hljs-keyword">while</span>(k+<span class="hljs-number">1</span> &lt; n &amp;&amp; nums[k+<span class="hljs-number">1</span>] &lt; nums[i] + nums[j]) {
                    k++;
                }
                ret += (k-j);
            }
        }
        <span class="hljs-keyword">return</span> ret;
    }

}
</code></pre>]]></content:encoded></item><item><title><![CDATA[581. Shortest Unsorted Continuous Subarray]]></title><description><![CDATA[Given an integer array nums, you need to find one continuous subarray that if you only sort this subarray in ascending order, then the whole array will be…]]></description><link>https://xiaok.me/581-shortest-unsorted-continuous-subarray</link><guid isPermaLink="true">https://xiaok.me/581-shortest-unsorted-continuous-subarray</guid><category><![CDATA[algorithms]]></category><dc:creator><![CDATA[xiao kun]]></dc:creator><pubDate>Tue, 03 Aug 2021 16:43:09 GMT</pubDate><content:encoded><![CDATA[<p>https://leetcode-cn.com/problems/shortest-unsorted-continuous-subarray/</p>
<h1 id="problem">problem</h1>
<blockquote>
<p>Given an integer array nums, you need to find one continuous subarray that if you only sort this subarray in ascending order, then the whole array will be sorted in ascending order.</p>
<p>Return the shortest such subarray and output its length.</p>
</blockquote>
<h1 id="example">example</h1>
<p>Example 1:</p>
<pre><code><span class="hljs-attr">Input:</span> <span class="hljs-string">nums</span> <span class="hljs-string">=</span> [<span class="hljs-number">2</span>,<span class="hljs-number">6</span>,<span class="hljs-number">4</span>,<span class="hljs-number">8</span>,<span class="hljs-number">10</span>,<span class="hljs-number">9</span>,<span class="hljs-number">15</span>]
<span class="hljs-attr">Output:</span> <span class="hljs-number">5</span>
<span class="hljs-attr">Explanation:</span> <span class="hljs-string">You</span> <span class="hljs-string">need</span> <span class="hljs-string">to</span> <span class="hljs-string">sort</span> [<span class="hljs-number">6</span>, <span class="hljs-number">4</span>, <span class="hljs-number">8</span>, <span class="hljs-number">10</span>, <span class="hljs-number">9</span>] <span class="hljs-string">in</span> <span class="hljs-string">ascending</span> <span class="hljs-string">order</span> <span class="hljs-string">to</span> <span class="hljs-string">make</span> <span class="hljs-string">the</span> <span class="hljs-string">whole</span> <span class="hljs-string">array</span> <span class="hljs-string">sorted</span> <span class="hljs-string">in</span> <span class="hljs-string">ascending</span> <span class="hljs-string">order.</span>
</code></pre><p>Example 2:</p>
<pre><code><span class="hljs-attr">Input:</span> <span class="hljs-string">nums</span> <span class="hljs-string">=</span> [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>]
<span class="hljs-attr">Output:</span> <span class="hljs-number">0</span>
</code></pre><p>Example 3:</p>
<pre><code><span class="hljs-attr">Input:</span> <span class="hljs-string">nums</span> <span class="hljs-string">=</span> [<span class="hljs-number">1</span>]
<span class="hljs-attr">Output:</span> <span class="hljs-number">0</span>
</code></pre><p>Constraints:</p>
<pre><code><span class="hljs-number">1</span> <span class="hljs-string">&lt;=</span> <span class="hljs-string">nums.length</span> <span class="hljs-string">&lt;=</span> <span class="hljs-number">104</span>
<span class="hljs-number">-105</span> <span class="hljs-string">&lt;=</span> <span class="hljs-string">nums[i]</span> <span class="hljs-string">&lt;=</span> <span class="hljs-number">105</span>
</code></pre><h1 id="solution">solution</h1>
<pre><code><span class="hljs-comment">/**
* from n-1 find last lo  rightPart less than lo;
* from 0  find last hi  leftpart larger than b,
*/</span> 
<span class="hljs-keyword">class</span> Solution {
    <span class="hljs-built_in">public</span> <span class="hljs-type">int</span> findUnsortedSubarray(<span class="hljs-type">int</span>[] nums) {
        <span class="hljs-type">int</span> n = nums.length;
        <span class="hljs-type">int</span> rightMin = <span class="hljs-type">Integer</span>.MAX_VALUE;
        <span class="hljs-type">int</span> lo = <span class="hljs-number">-1</span>;
        <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = n<span class="hljs-number">-1</span> ;i &gt;= <span class="hljs-number">0</span>; i<span class="hljs-comment">--) {</span>
            <span class="hljs-keyword">if</span>( nums[i] &gt; rightMin ) {
                lo = i;
            } <span class="hljs-keyword">else</span> {
                rightMin = nums[i];
            }
        }

        <span class="hljs-keyword">if</span> ( lo == <span class="hljs-number">-1</span>) {
            <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;
        }

        <span class="hljs-type">int</span> leftMax = <span class="hljs-type">Integer</span>.MIN_VALUE;
        <span class="hljs-type">int</span> hi = <span class="hljs-number">-1</span>;
        <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span> ; i &lt; n; i++) {
            <span class="hljs-keyword">if</span> (nums[i] &lt; leftMax) {
                hi = i;
            } <span class="hljs-keyword">else</span> {
                leftMax = nums[i];
            }
        }
        <span class="hljs-keyword">return</span> hi - lo + <span class="hljs-number">1</span>;
    }
}
</code></pre>]]></content:encoded></item><item><title><![CDATA[743. Network Delay Time]]></title><description><![CDATA[You are given a network of n nodes, labeled from 1 to n. You are also given times, a list of travel times as directed edges times[i] = (ui, vi, wi), where…]]></description><link>https://xiaok.me/743-network-delay-time</link><guid isPermaLink="true">https://xiaok.me/743-network-delay-time</guid><category><![CDATA[algorithms]]></category><dc:creator><![CDATA[xiao kun]]></dc:creator><pubDate>Mon, 02 Aug 2021 12:22:10 GMT</pubDate><content:encoded><![CDATA[<p>https://leetcode-cn.com/problems/network-delay-time/</p>
<h1 id="problem">problem</h1>
<blockquote>
<p>You are given a network of n nodes, labeled from 1 to n. You are also given times, a list of travel times as directed edges times[i] = (ui, vi, wi), where ui is the source node, vi is the target node, and wi is the time it takes for a signal to travel from source to target.</p>
<p>We will send a signal from a given node k. Return the time it takes for all the n nodes to receive the signal. If it is impossible for all the n nodes to receive the signal, return -1.</p>
</blockquote>
<h1 id="example">example</h1>
<p>Example 1:</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1627906676196/0ld2i2rbM.png" alt="image.png" /></p>
<pre><code><span class="hljs-attr">Input:</span> <span class="hljs-string">times</span> <span class="hljs-string">=</span> [[<span class="hljs-number">2</span>,<span class="hljs-number">1</span>,<span class="hljs-number">1</span>],[<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">1</span>],[<span class="hljs-number">3</span>,<span class="hljs-number">4</span>,<span class="hljs-number">1</span>]]<span class="hljs-string">,</span> <span class="hljs-string">n</span> <span class="hljs-string">=</span> <span class="hljs-number">4</span><span class="hljs-string">,</span> <span class="hljs-string">k</span> <span class="hljs-string">=</span> <span class="hljs-number">2</span>
<span class="hljs-attr">Output:</span> <span class="hljs-number">2</span>
<span class="hljs-attr">Example 2:</span>

<span class="hljs-attr">Input:</span> <span class="hljs-string">times</span> <span class="hljs-string">=</span> [[<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">1</span>]]<span class="hljs-string">,</span> <span class="hljs-string">n</span> <span class="hljs-string">=</span> <span class="hljs-number">2</span><span class="hljs-string">,</span> <span class="hljs-string">k</span> <span class="hljs-string">=</span> <span class="hljs-number">1</span>
<span class="hljs-attr">Output:</span> <span class="hljs-number">1</span>
<span class="hljs-attr">Example 3:</span>

<span class="hljs-attr">Input:</span> <span class="hljs-string">times</span> <span class="hljs-string">=</span> [[<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">1</span>]]<span class="hljs-string">,</span> <span class="hljs-string">n</span> <span class="hljs-string">=</span> <span class="hljs-number">2</span><span class="hljs-string">,</span> <span class="hljs-string">k</span> <span class="hljs-string">=</span> <span class="hljs-number">2</span>
<span class="hljs-attr">Output:</span> <span class="hljs-number">-1</span>
</code></pre><p>Constraints:</p>
<pre><code><span class="hljs-number">1</span> <span class="hljs-string">&lt;=</span> <span class="hljs-string">k</span> <span class="hljs-string">&lt;=</span> <span class="hljs-string">n</span> <span class="hljs-string">&lt;=</span> <span class="hljs-number">100</span>
<span class="hljs-number">1</span> <span class="hljs-string">&lt;=</span> <span class="hljs-string">times.length</span> <span class="hljs-string">&lt;=</span> <span class="hljs-number">6000</span>
<span class="hljs-string">times[i].length</span> <span class="hljs-string">==</span> <span class="hljs-number">3</span>
<span class="hljs-number">1</span> <span class="hljs-string">&lt;=</span> <span class="hljs-string">ui,</span> <span class="hljs-string">vi</span> <span class="hljs-string">&lt;=</span> <span class="hljs-string">n</span>
<span class="hljs-string">ui</span> <span class="hljs-type">!=</span> <span class="hljs-string">vi</span>
<span class="hljs-number">0</span> <span class="hljs-string">&lt;=</span> <span class="hljs-string">wi</span> <span class="hljs-string">&lt;=</span> <span class="hljs-number">100</span>
<span class="hljs-string">All</span> <span class="hljs-string">the</span> <span class="hljs-string">pairs</span> <span class="hljs-string">(ui,</span> <span class="hljs-string">vi)</span> <span class="hljs-string">are</span> <span class="hljs-string">unique.</span> <span class="hljs-string">(i.e.,</span> <span class="hljs-literal">no</span> <span class="hljs-string">multiple</span> <span class="hljs-string">edges.)</span>
</code></pre><h1 id="solution">solution</h1>
<pre><code><span class="hljs-comment">/**
source k , target 1...k-1 k+1..n
dist[i] present time cost (the shortest path) from k to i
 (use  dijkstra algorithm)
result is  Math.max(dist[i])
 */</span>
<span class="hljs-keyword">class</span> Solution {
    <span class="hljs-built_in">public</span> <span class="hljs-type">int</span> networkDelayTime(<span class="hljs-type">int</span>[][] times, <span class="hljs-type">int</span> n, <span class="hljs-type">int</span> k) {
          final <span class="hljs-type">int</span> INF = <span class="hljs-type">Integer</span>.MAX_VALUE / <span class="hljs-number">2</span>;
        <span class="hljs-type">int</span>[][] g = <span class="hljs-built_in">new</span> <span class="hljs-type">int</span>[n][n];
        <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span> ; i &lt; n; i++) {
            <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> j = <span class="hljs-number">0</span>; j &lt; n; j++) {
                g[i][j] = INF;
            }
        }
        <span class="hljs-keyword">for</span>(<span class="hljs-type">int</span>[] t: times) {
            <span class="hljs-type">int</span> u = t[<span class="hljs-number">0</span>] <span class="hljs-number">-1</span>;
            <span class="hljs-type">int</span> v = t[<span class="hljs-number">1</span>] <span class="hljs-number">-1</span>;
            g[u][v] = t[<span class="hljs-number">2</span>];
        }
        <span class="hljs-type">int</span>[] dist = <span class="hljs-built_in">new</span> <span class="hljs-type">int</span>[n];
        Arrays.fill(dist,  INF);
        dist[k<span class="hljs-number">-1</span>] = <span class="hljs-number">0</span>;
        <span class="hljs-type">boolean</span>[] used = <span class="hljs-built_in">new</span> <span class="hljs-type">boolean</span>[n];
        <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i &lt; n; ++i) {
            <span class="hljs-type">int</span> x = <span class="hljs-number">-1</span>;
            <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> y = <span class="hljs-number">0</span>; y &lt; n; y++) {
                <span class="hljs-keyword">if</span> ((!used[y] )&amp;&amp;( x == <span class="hljs-number">-1</span> || dist[y] &lt; dist[x] )) {
                    x = y;
                }
            }
            used[x] = <span class="hljs-keyword">true</span>;
            <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> y = <span class="hljs-number">0</span> ; y &lt; n; y++) {
                dist[y] = Math.min(dist[y], dist[x] + g[x][y]);
            }
        }
       <span class="hljs-type">int</span> ans = Arrays.stream(dist).max().getAsInt();
        <span class="hljs-keyword">return</span> ans == INF ? <span class="hljs-number">-1</span> : ans;

     }
}
</code></pre>]]></content:encoded></item><item><title><![CDATA[987. Vertical Order Traversal of a Binary Tree]]></title><description><![CDATA[Given the root of a binary tree, calculate the vertical order traversal of the binary tree. For each node at position (row, col), its left and right…]]></description><link>https://xiaok.me/987-vertical-order-traversal-of-a-binary-tree</link><guid isPermaLink="true">https://xiaok.me/987-vertical-order-traversal-of-a-binary-tree</guid><category><![CDATA[algorithms]]></category><dc:creator><![CDATA[xiao kun]]></dc:creator><pubDate>Sat, 31 Jul 2021 14:51:42 GMT</pubDate><content:encoded><![CDATA[<p>https://leetcode-cn.com/problems/vertical-order-traversal-of-a-binary-tree/</p>
<h1 id="problems">problems</h1>
<blockquote>
<p>Given the root of a binary tree, calculate the vertical order traversal of the binary tree.</p>
<p>For each node at position (row, col), its left and right children will be at positions (row + 1, col - 1) and (row + 1, col + 1) respectively. The root of the tree is at (0, 0).</p>
<p>The vertical order traversal of a binary tree is a list of top-to-bottom orderings for each column index starting from the leftmost column and ending on the rightmost column. There may be multiple nodes in the same row and same column. In such a case, sort these nodes by their values.</p>
<p>Return the vertical order traversal of the binary tree.</p>
</blockquote>
<h1 id="example">example</h1>
<p>Example 1:</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1627742862159/19avQRzX3.png" alt="image.png" /></p>
<pre><code><span class="hljs-attr">Input:</span> <span class="hljs-string">root</span> <span class="hljs-string">=</span> [<span class="hljs-number">3</span>,<span class="hljs-number">9</span>,<span class="hljs-number">20</span>,<span class="hljs-literal">null</span>,<span class="hljs-literal">null</span>,<span class="hljs-number">15</span>,<span class="hljs-number">7</span>]
<span class="hljs-attr">Output:</span> [[<span class="hljs-number">9</span>],[<span class="hljs-number">3</span>,<span class="hljs-number">15</span>],[<span class="hljs-number">20</span>],[<span class="hljs-number">7</span>]]
<span class="hljs-attr">Explanation:</span>
<span class="hljs-attr">Column -1:</span> <span class="hljs-string">Only</span> <span class="hljs-string">node</span> <span class="hljs-number">9</span> <span class="hljs-string">is</span> <span class="hljs-string">in</span> <span class="hljs-string">this</span> <span class="hljs-string">column.</span>
<span class="hljs-attr">Column 0:</span> <span class="hljs-string">Nodes</span> <span class="hljs-number">3</span> <span class="hljs-string">and</span> <span class="hljs-number">15</span> <span class="hljs-string">are</span> <span class="hljs-string">in</span> <span class="hljs-string">this</span> <span class="hljs-string">column</span> <span class="hljs-string">in</span> <span class="hljs-string">that</span> <span class="hljs-string">order</span> <span class="hljs-string">from</span> <span class="hljs-string">top</span> <span class="hljs-string">to</span> <span class="hljs-string">bottom.</span>
<span class="hljs-attr">Column 1:</span> <span class="hljs-string">Only</span> <span class="hljs-string">node</span> <span class="hljs-number">20</span> <span class="hljs-string">is</span> <span class="hljs-string">in</span> <span class="hljs-string">this</span> <span class="hljs-string">column.</span>
<span class="hljs-attr">Column 2:</span> <span class="hljs-string">Only</span> <span class="hljs-string">node</span> <span class="hljs-number">7</span> <span class="hljs-string">is</span> <span class="hljs-string">in</span> <span class="hljs-string">this</span> <span class="hljs-string">column.</span>
</code></pre><p>Example 2:</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1627742873101/jXCEPJ_Iu.png" alt="image.png" /></p>
<pre><code><span class="hljs-attr">Input:</span> <span class="hljs-string">root</span> <span class="hljs-string">=</span> [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>,<span class="hljs-number">5</span>,<span class="hljs-number">6</span>,<span class="hljs-number">7</span>]
<span class="hljs-attr">Output:</span> [[<span class="hljs-number">4</span>],[<span class="hljs-number">2</span>],[<span class="hljs-number">1</span>,<span class="hljs-number">5</span>,<span class="hljs-number">6</span>],[<span class="hljs-number">3</span>],[<span class="hljs-number">7</span>]]
<span class="hljs-attr">Explanation:</span>
<span class="hljs-attr">Column -2:</span> <span class="hljs-string">Only</span> <span class="hljs-string">node</span> <span class="hljs-number">4</span> <span class="hljs-string">is</span> <span class="hljs-string">in</span> <span class="hljs-string">this</span> <span class="hljs-string">column.</span>
<span class="hljs-attr">Column -1:</span> <span class="hljs-string">Only</span> <span class="hljs-string">node</span> <span class="hljs-number">2</span> <span class="hljs-string">is</span> <span class="hljs-string">in</span> <span class="hljs-string">this</span> <span class="hljs-string">column.</span>
<span class="hljs-attr">Column 0:</span> <span class="hljs-string">Nodes</span> <span class="hljs-number">1</span><span class="hljs-string">,</span> <span class="hljs-number">5</span><span class="hljs-string">,</span> <span class="hljs-string">and</span> <span class="hljs-number">6</span> <span class="hljs-string">are</span> <span class="hljs-string">in</span> <span class="hljs-string">this</span> <span class="hljs-string">column.</span>
          <span class="hljs-number">1</span> <span class="hljs-string">is</span> <span class="hljs-string">at</span> <span class="hljs-string">the</span> <span class="hljs-string">top,</span> <span class="hljs-string">so</span> <span class="hljs-string">it</span> <span class="hljs-string">comes</span> <span class="hljs-string">first.</span>
          <span class="hljs-number">5</span> <span class="hljs-string">and</span> <span class="hljs-number">6</span> <span class="hljs-string">are</span> <span class="hljs-string">at</span> <span class="hljs-string">the</span> <span class="hljs-string">same</span> <span class="hljs-string">position</span> <span class="hljs-string">(2,</span> <span class="hljs-number">0</span><span class="hljs-string">),</span> <span class="hljs-string">so</span> <span class="hljs-string">we</span> <span class="hljs-string">order</span> <span class="hljs-string">them</span> <span class="hljs-string">by</span> <span class="hljs-string">their</span> <span class="hljs-string">value,</span> <span class="hljs-number">5</span> <span class="hljs-string">before</span> <span class="hljs-number">6</span><span class="hljs-string">.</span>
<span class="hljs-attr">Column 1:</span> <span class="hljs-string">Only</span> <span class="hljs-string">node</span> <span class="hljs-number">3</span> <span class="hljs-string">is</span> <span class="hljs-string">in</span> <span class="hljs-string">this</span> <span class="hljs-string">column.</span>
<span class="hljs-attr">Column 2:</span> <span class="hljs-string">Only</span> <span class="hljs-string">node</span> <span class="hljs-number">7</span> <span class="hljs-string">is</span> <span class="hljs-string">in</span> <span class="hljs-string">this</span> <span class="hljs-string">column.</span>
</code></pre><p>Example 3:</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1627742883895/EabjtDGx_.png" alt="image.png" /></p>
<pre><code><span class="hljs-attr">Input:</span> <span class="hljs-string">root</span> <span class="hljs-string">=</span> [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>,<span class="hljs-number">6</span>,<span class="hljs-number">5</span>,<span class="hljs-number">7</span>]
<span class="hljs-attr">Output:</span> [[<span class="hljs-number">4</span>],[<span class="hljs-number">2</span>],[<span class="hljs-number">1</span>,<span class="hljs-number">5</span>,<span class="hljs-number">6</span>],[<span class="hljs-number">3</span>],[<span class="hljs-number">7</span>]]
<span class="hljs-attr">Explanation:</span>
<span class="hljs-string">This</span> <span class="hljs-string">case</span> <span class="hljs-string">is</span> <span class="hljs-string">the</span> <span class="hljs-string">exact</span> <span class="hljs-string">same</span> <span class="hljs-string">as</span> <span class="hljs-string">example</span> <span class="hljs-number">2</span><span class="hljs-string">,</span> <span class="hljs-string">but</span> <span class="hljs-string">with</span> <span class="hljs-string">nodes</span> <span class="hljs-number">5</span> <span class="hljs-string">and</span> <span class="hljs-number">6</span> <span class="hljs-string">swapped.</span>
<span class="hljs-string">Note</span> <span class="hljs-string">that</span> <span class="hljs-string">the</span> <span class="hljs-string">solution</span> <span class="hljs-string">remains</span> <span class="hljs-string">the</span> <span class="hljs-string">same</span> <span class="hljs-string">since</span> <span class="hljs-number">5</span> <span class="hljs-string">and</span> <span class="hljs-number">6</span> <span class="hljs-string">are</span> <span class="hljs-string">in</span> <span class="hljs-string">the</span> <span class="hljs-string">same</span> <span class="hljs-string">location</span> <span class="hljs-string">and</span> <span class="hljs-string">should</span> <span class="hljs-string">be</span> <span class="hljs-string">ordered</span> <span class="hljs-string">by</span> <span class="hljs-string">their</span> <span class="hljs-string">values.</span>
</code></pre><p>Constraints:</p>
<pre><code><span class="hljs-string">The</span> <span class="hljs-string">number</span> <span class="hljs-string">of</span> <span class="hljs-string">nodes</span> <span class="hljs-string">in</span> <span class="hljs-string">the</span> <span class="hljs-string">tree</span> <span class="hljs-string">is</span> <span class="hljs-string">in</span> <span class="hljs-string">the</span> <span class="hljs-string">range</span> [<span class="hljs-number">1</span>, <span class="hljs-number">1000</span>]<span class="hljs-string">.</span>
<span class="hljs-number">0</span> <span class="hljs-string">&lt;=</span> <span class="hljs-string">Node.val</span> <span class="hljs-string">&lt;=</span> <span class="hljs-number">1000</span>
</code></pre><h1 id="solution">solution</h1>
<p>思路：</p>
<ol>
<li>把所有节点的坐标遍历记录下来。</li>
<li>按照纵坐标顺序，行坐标从小到大</li>
<li>细节，同样的坐标，值从小到到。
可以用嵌套的TreeMap
纵坐标为外层 key，横坐标为内层坐标key，这样遍历坐标符合从小到大。由于坐标可能重叠，用List 保存值，读取的时候需要注意顺序。</li>
</ol>
<pre><code><span class="hljs-comment">/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span> </span>{
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">List</span>&lt;<span class="hljs-keyword">List</span>&lt;<span class="hljs-keyword">Integer</span>&gt;&gt; verticalTraversal(TreeNode root) {
        TreeMap&lt;<span class="hljs-keyword">Integer</span>, TreeMap&lt;<span class="hljs-keyword">Integer</span>, <span class="hljs-keyword">List</span>&lt;<span class="hljs-keyword">Integer</span>&gt;&gt;&gt; map = <span class="hljs-keyword">new</span> TreeMap&lt;&gt;();
        dfs(root,<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, map);
        <span class="hljs-comment">//</span>
        <span class="hljs-keyword">List</span>&lt;<span class="hljs-keyword">List</span>&lt;<span class="hljs-keyword">Integer</span>&gt;&gt; ret = <span class="hljs-keyword">new</span> ArrayList&lt;&gt;();
        <span class="hljs-keyword">for</span> (Map.Entry&lt;<span class="hljs-keyword">Integer</span>, TreeMap&lt;<span class="hljs-keyword">Integer</span>, <span class="hljs-keyword">List</span>&lt;<span class="hljs-keyword">Integer</span>&gt;&gt;&gt; entry: map.entrySet()) {
            <span class="hljs-keyword">List</span>&lt;<span class="hljs-keyword">Integer</span>&gt; tmp = <span class="hljs-keyword">new</span> ArrayList&lt;&gt;();
            <span class="hljs-keyword">for</span> (Map.Entry&lt;<span class="hljs-keyword">Integer</span>, <span class="hljs-keyword">List</span>&lt;<span class="hljs-keyword">Integer</span>&gt;&gt; entry1: entry.getValue().entrySet()) {
                <span class="hljs-keyword">List</span>&lt;<span class="hljs-keyword">Integer</span>&gt; <span class="hljs-keyword">list</span> = entry1.getValue();
                Collections.sort(<span class="hljs-keyword">list</span>);
                tmp.addAll(<span class="hljs-keyword">list</span>);
            }
            <span class="hljs-keyword">if</span> (tmp.size() &gt;<span class="hljs-number">0</span>) {
                ret.add(tmp);
            }
        }
        <span class="hljs-keyword">return</span> ret;
    }
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> dfs(TreeNode n, <span class="hljs-keyword">int</span> x, <span class="hljs-keyword">int</span> y, TreeMap&lt;<span class="hljs-keyword">Integer</span>, TreeMap&lt;<span class="hljs-keyword">Integer</span>, <span class="hljs-keyword">List</span>&lt;<span class="hljs-keyword">Integer</span>&gt;&gt;&gt; m) {
        <span class="hljs-keyword">if</span> (n == <span class="hljs-literal">null</span>) {
            <span class="hljs-keyword">return</span>;
        }
        <span class="hljs-comment">//vist n;</span>
        m.putIfAbsent(y, <span class="hljs-keyword">new</span> TreeMap&lt;&gt;());
        TreeMap&lt;<span class="hljs-keyword">Integer</span>, <span class="hljs-keyword">List</span>&lt;<span class="hljs-keyword">Integer</span>&gt;&gt; sub = m.get(y);
        sub.putIfAbsent(x, <span class="hljs-keyword">new</span> ArrayList&lt;<span class="hljs-keyword">Integer</span>&gt;());
        m.get(y).get(x).add(n.val);
        <span class="hljs-comment">// vist left;</span>
        dfs(n.left, x+<span class="hljs-number">1</span>, y<span class="hljs-number">-1</span>, m);
        <span class="hljs-comment">// vist right;</span>
        dfs(n.right, x+<span class="hljs-number">1</span>, y+<span class="hljs-number">1</span>, m);
    }
}
</code></pre>]]></content:encoded></item><item><title><![CDATA[171. Excel Sheet Column Number]]></title><description><![CDATA[Given a string columnTitle that represents the column title as appear in an Excel sheet, return its corresponding column number. For example:]]></description><link>https://xiaok.me/171-excel-sheet-column-number</link><guid isPermaLink="true">https://xiaok.me/171-excel-sheet-column-number</guid><category><![CDATA[algorithms]]></category><dc:creator><![CDATA[xiao kun]]></dc:creator><pubDate>Fri, 30 Jul 2021 03:15:36 GMT</pubDate><content:encoded><![CDATA[<p>https://leetcode-cn.com/problems/excel-sheet-column-number/</p>
<h2 id="problem">problem</h2>
<blockquote>
<p>Given a string columnTitle that represents the column title as appear in an Excel sheet, return its corresponding column number.</p>
<p> For example:</p>
<pre><code>A -&gt; <span class="hljs-number">1</span>
B -&gt; <span class="hljs-number">2</span>
C -&gt; <span class="hljs-number">3</span>
...
Z -&gt; <span class="hljs-number">26</span>
AA -&gt; <span class="hljs-number">27</span>
AB -&gt; <span class="hljs-number">28</span> 
...
</code></pre></blockquote>
<h2 id="example">example</h2>
<pre><code><span class="hljs-attr">Example 1:</span>

<span class="hljs-attr">Input:</span> <span class="hljs-string">columnTitle</span> <span class="hljs-string">=</span> <span class="hljs-string">"A"</span>
<span class="hljs-attr">Output:</span> <span class="hljs-number">1</span>

<span class="hljs-attr">Example 2:</span>

<span class="hljs-attr">Input:</span> <span class="hljs-string">columnTitle</span> <span class="hljs-string">=</span> <span class="hljs-string">"AB"</span>
<span class="hljs-attr">Output:</span> <span class="hljs-number">28</span>

<span class="hljs-attr">Example 3:</span>

<span class="hljs-attr">Input:</span> <span class="hljs-string">columnTitle</span> <span class="hljs-string">=</span> <span class="hljs-string">"ZY"</span>
<span class="hljs-attr">Output:</span> <span class="hljs-number">701</span>

<span class="hljs-attr">Example 4:</span>

<span class="hljs-attr">Input:</span> <span class="hljs-string">columnTitle</span> <span class="hljs-string">=</span> <span class="hljs-string">"FXSHRXW"</span>
<span class="hljs-attr">Output:</span> <span class="hljs-number">2147483647</span>


<span class="hljs-attr">Constraints:</span>
<span class="hljs-bullet">-</span>  <span class="hljs-number">1</span> <span class="hljs-string">&lt;=</span> <span class="hljs-string">columnTitle.length</span> <span class="hljs-string">&lt;=</span> <span class="hljs-number">7</span>
<span class="hljs-bullet">-</span>  <span class="hljs-string">columnTitle</span> <span class="hljs-string">consists</span> <span class="hljs-string">only</span> <span class="hljs-string">of</span> <span class="hljs-string">uppercase</span> <span class="hljs-string">English</span> <span class="hljs-string">letters.</span>
<span class="hljs-bullet">-</span>  <span class="hljs-string">columnTitle</span> <span class="hljs-string">is</span> <span class="hljs-string">in</span> <span class="hljs-string">the</span> <span class="hljs-string">range</span> [<span class="hljs-string">"A"</span>, <span class="hljs-string">"FXSHRXW"</span>]<span class="hljs-string">.</span>
</code></pre><h2 id="solution">solution</h2>
<pre><code><span class="hljs-comment">/**
 * 26 进制表示 
 * 26-based express
 */</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span> {</span>
    <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">int</span> <span class="hljs-title">titleToNumber</span><span class="hljs-params">(String columnTitle)</span> </span>{
        <span class="hljs-keyword">int</span> ret = <span class="hljs-number">0</span>;
        <span class="hljs-keyword">for</span>(<span class="hljs-keyword">char</span> c: columnTitle.toCharArray()) {
            ret = ret * <span class="hljs-number">26</span> + (<span class="hljs-keyword">int</span>)(c - <span class="hljs-string">'A'</span> + <span class="hljs-number">1</span>);
        }
        <span class="hljs-keyword">return</span> ret;
    }
}
</code></pre>]]></content:encoded></item><item><title><![CDATA[1104. Path In Zigzag Labelled Binary Tree]]></title><description><![CDATA[题目： 在一棵无限的二叉树上，每个节点都有两个子节点，树中的节点 逐行 依次按 “之” 字形进行标记。 如下图所示，在奇数行（即，第一行、第三行、第五行……）中，按从左到右的顺序进行标记；]]></description><link>https://xiaok.me/1104-path-in-zigzag-labelled-binary-tree</link><guid isPermaLink="true">https://xiaok.me/1104-path-in-zigzag-labelled-binary-tree</guid><category><![CDATA[algorithms]]></category><dc:creator><![CDATA[xiao kun]]></dc:creator><pubDate>Thu, 29 Jul 2021 14:03:00 GMT</pubDate><content:encoded><![CDATA[<p>题目： https://leetcode-cn.com/problems/path-in-zigzag-labelled-binary-tree/</p>
<blockquote>
<p>在一棵无限的二叉树上，每个节点都有两个子节点，树中的节点 逐行 依次按 “之” 字形进行标记。</p>
<p>如下图所示，在奇数行（即，第一行、第三行、第五行……）中，按从左到右的顺序进行标记；</p>
<p>而偶数行（即，第二行、第四行、第六行……）中，按从右到左的顺序进行标记。</p>
<p>给你树上某一个节点的标号 label，请你返回从根节点到该标号为 label 节点的路径，该路径是由途经的节点标号所组成的。</p>
</blockquote>
<pre><code><span class="hljs-string">示例</span> <span class="hljs-number">1</span><span class="hljs-string">：</span>

<span class="hljs-string">输入：label</span> <span class="hljs-string">=</span> <span class="hljs-number">14</span>
<span class="hljs-string">输出：[1,3,4,14]</span>

<span class="hljs-string">示例</span> <span class="hljs-number">2</span><span class="hljs-string">：</span>

<span class="hljs-string">输入：label</span> <span class="hljs-string">=</span> <span class="hljs-number">26</span>
<span class="hljs-string">输出：[1,2,6,10,26]</span>
</code></pre><p>思路： 数学计算，先计算出深度，再自下而上计算每一层的数字。由于满二叉树的性质，可以容易计算出，每一层的数字范围[2<sup>i-1</sup> , 2<sup>i</sup>-1] , 满二叉树，节点 j 的父节点是 j/2 , 由于逆序，所以  j 的父节点  =  2<sup>i-1</sup>  + 2<sup>i</sup>-1 - j/2;  </p>
<pre><code><span class="hljs-comment">/**
* 1. 计算出深度
* 2. 求父节点不逆序的位置i，计算出一层从的开头a和结尾b的位置， 得到实际位置 a+b-i
**/</span>
<span class="hljs-keyword">class</span> Solution {
    <span class="hljs-built_in">public</span> List&lt;<span class="hljs-type">Integer</span>&gt; pathInZigZagTree(<span class="hljs-type">int</span> label) {

        <span class="hljs-type">int</span> depth = <span class="hljs-number">1</span>;
        <span class="hljs-keyword">while</span>(label &gt;=  (<span class="hljs-number">1</span>&lt;&lt;depth) ){
            depth++;
        }

        List&lt;<span class="hljs-type">Integer</span>&gt; ret = <span class="hljs-built_in">new</span> ArrayList&lt;&gt;();
        ret.<span class="hljs-keyword">add</span>(<span class="hljs-number">0</span>,label);
        depth<span class="hljs-comment">--;</span>
        <span class="hljs-keyword">while</span>(depth &gt;= <span class="hljs-number">1</span>) {
            <span class="hljs-type">int</span> end =  (<span class="hljs-number">1</span> &lt;&lt;depth)<span class="hljs-number">-1</span>;
            <span class="hljs-type">int</span> start = <span class="hljs-number">1</span> &lt;&lt;(depth<span class="hljs-number">-1</span>);
            <span class="hljs-type">int</span> parent = (<span class="hljs-keyword">end</span>+<span class="hljs-keyword">start</span>) - (label / <span class="hljs-number">2</span>);
            label = parent;
            ret.<span class="hljs-keyword">add</span>(<span class="hljs-number">0</span>, parent);
            depth<span class="hljs-comment">--;</span>
        }
        <span class="hljs-keyword">return</span> ret;
    }
}
</code></pre>]]></content:encoded></item><item><title><![CDATA[Hello HashNode]]></title><description><![CDATA[this is my first blog. just a test]]></description><link>https://xiaok.me/hello-hashnode</link><guid isPermaLink="true">https://xiaok.me/hello-hashnode</guid><dc:creator><![CDATA[xiao kun]]></dc:creator><pubDate>Tue, 20 Jul 2021 15:22:29 GMT</pubDate><content:encoded><![CDATA[<p>this is my first blog.</p>
<p>just a test</p>
]]></content:encoded></item></channel></rss>