window下解决端口占用问题

window下解决端口进程的命令:

  1. netstat -ano | findStr 8080 找到对应的线程pid,比如10025
  2. 使用taskKill /F /pid 10025杀死线程
阅读更多

什么是协程

协程(Coroutine)又称为微线程,我们知道线程是CPU的执行的最小单位,线程执行的最小代码单位是方法。

比如在执行的时候,一个线程从程序的入口调用Main方法,Main调用A方法,A方法又调用B方法,整个函数的执行完成的顺序是B->A->Main。这个调用的顺序是明确的,是通过压栈和出栈的方式确定的。

而协程不同, Main调用B,在调用B的过程中可以中断,Main函数继续执行一会,Main再中断,B继续再执行一会, 继续执行的代码是上次中断的地方。

用伪代码表示两个方法:

funcA(){
     funcB();
     print 4;
     print 5;
     print 6;
}
funcB(){
     print 1;
     print 2;
     print 3;
}

如果是用正常的单线程线程来执行的时候,打印结果是123456,如果采用协程,打印结果就有可能是142536.

协程的执行的结果有点和多线程类似,但本质与多线程不同,线程有上下文切换,存在变量的拷贝,而协程只是轻量级的方法中断,所以切换效率是高于线程。

协程所有的变量都是共享内存,访问不需要加锁,使用时只需简单的判断,不存在线程不安全问题。

在Java中,还不支持协程的机制,所以用C#来演示下协程的过程。

     static void Main(string[] args)
     {
          System.Console.WriteLine("执行方法:Main");
          IEnumerable<int> intList = Xc.GetList();
          foreach (int i in intList)
          {
               System.Console.WriteLine("协程1:执行");
               Console.WriteLine("协程1:获得返回的结果是:" + i);
          }
     }

     class Xc
     {
          public static IEnumerable<int> GetList()
          {
               System.Console.WriteLine("执行方法:GetList");
               for (int i = 0; i < 10; i++)
               {
                    yield return i;
                    System.Console.WriteLine("协程2: 执行");
                    System.Console.WriteLine("协程2:doSomething");
                    Thread.Sleep(1000);
               }
          }
     }
阅读更多

C10K的问题

什么是C10K问题

随着互联网的普及,web的访问呈几何倍数的增长,我们知道一个请求和响应的过程的背后是连接的互换数据,最初的服务器都是基于进程/线程模型的,新到来一个TCP连接,就需要分配1个进程(或者线程)。

而进程和线程又是系统昂贵的资源,一台机器创建的线程数量和进程数量是有限的,不可能无限制的创建。

C10K的核心问题就是即使在硬件资源都满足的情况先,系统也难以承载有10000个客户端连接请求

造成C10K问题的原因

造成C10K问题的本质其实是操作系统的问题,对于传统的阻塞I/O处理方式,当线程或进程创建的足够多时,即使服务器硬件条件满足,也会导致系统的卡顿和崩溃。所以要解决C10K的问题,就应该尽可能的降低CPU的开销和进程的创建。

怎么解决C10K的问题

上面分析了C10K的本质,所以解决办法就围绕着,降低进程的开销,比如让一个进程能够管理多个连接。而如何是一个进程管理多个连接呢?因为在服务端无法知道到底是哪个端口会发来数据。我个人理解具体方法有下面几种:

  1. 同步轮询(select

    方法很简单,直接挨个检查处理各个连接,当所有连接都有数据的时候,方法没有问题,如果有一个连接没有数据,那整个流程就阻塞在哪里,端口就无法进行获得。如果一个进程出来的过多,也会带来性能问题。

  2. 智能跳过轮询 (poll

    这个方法在上面的方法又改进了一步,在读取前先判断当前句柄是否已经是ready状态,如果不是则跳过。

  1. 轮询标记有数据,然后再轮询(epoll

    既然逐个排查所有文件句柄状态效率不高,可以先标记哪些句柄有变化,然后再读取变化的数据。

阅读更多

深入volatile关键字

在Java多线程中,有一个特殊的关键字volatile,这个通常成为一个“轻量级锁”,下面我们就来深入的了解这个关键的作用和原理。

线程的内存备份

首先看一段代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class VolatileThread extends Thread {
private boolean isRuning=true;
private void setRuning(boolean runing){
this.isRuning=runing;
}

public void run(){
System.out.println("进入Run方法");
while (isRuning){

}
System.out.println("线程结束");
}

public static void main(String[] args) throws InterruptedException {
VolatileThread volatileThread = new VolatileThread();
volatileThread.start();
Thread.sleep(3000);
volatileThread.setRuning(false);
System.out.println("runing设置成false,让线程停止");
Thread.sleep(1000);
System.out.println(volatileThread.isRuning);
}
}

在上面的代码并没有打印出“线程结束”的信息,因为我在主线程更改了isRuning 的值,并没有影响到线程中的数据。

产生这个的原因是因为JDK在创建线程的时候,都会从主内存中拷贝一份数据,所以线程的读取的变量的具有一定延迟

深入volatile关键字

使用volatile

对上面的代码进行修改,把isRuning变量使用volatile 关键字修饰,这样我们就能看到线程能够正常的停止了。下面我们总结下volatile的作用

1
2
3

如果变量被volatile关键字修饰, 则当变量改变的时候强制线程从主内存中读取和写入变量

阅读更多

CPU是如何实现运算

CPU的构成

我们知道CPU是芯片的集合,主要成分是硅。CPU的最小构成单位是一个PN节点,也就是我们常说的二极管。下面我们就聊一聊什么是二极管

PN节点 (二极管)

PN节点是一个硅晶体进行掺杂,分别在两侧掺入硼和磷,这样的硅晶体具有单项导电性,这样就形成一个PN节点。具体如下图:

CPU运算

由于具有单项导电性的特点,我们就能根据收到的电压变化,来确定输出的结果,我们假设收到高电压是1 ,低电压是0,PN节点的具体表现:

CPU运算

实现基本运算

根据上面的分析,我们可以尝试实现一个与门的电路实现,首先我们要清楚与门的具体逻辑。

有两个输入参数,只有同时为1的时候,才输出1,具体表示如下:

阅读更多

程序如何运行的

在写代码的时候,我们直接在没有编译报错的时候,直接点击运行后,ide会直接把程序的结果输出到控制台上,代码如下:

1
2
3
4
5
6
7
  public static void main(String[] args) { 
int i=17;
int j=5;
int sum=i+j;
System.out.println(sum);
}

这段代码最终的结果是在控制台上面打印出:22,但是这个结果到底是怎么被执行的呢?

CPU能做什么

在硬件的世界里面,只有0和1,就是这么简单的0和1,到底是怎么做加法的呢?

我们知道CPU的功能是执行指令,有三个简单的基本操作:与,非,或三种运算。在加上位的运算一种有5种:&,|,~,<<,>>. 利用这个几个运算如何实现代码中的15+5的运算?

首先,把加法拆解,分成两个部分: 把个位和个位相加,如果有进1的话,就用进1的值十位与另一个十位相加。得到的和在进行相加。

  1. 把15+5进行拆解就是 7+5=12,发现5+5有进位10;
  2. 利用进位的十位与10+10 =20
  3. 再把两个的和相加,20+2=22 ,没有再进位,运算结束。

    根据上面的分析,我们可以使用递归的方法,写出加法的位运算代码如下:

    1
    2
    3
    4
    5
    6
    7
    static int add(int i, int j){
    if(j == 0)
    return i;
    int sum = i ^ j;//得到个位相加
    int carry = (i & j) << 1;//得到进位相加
    return add(sum, carry);
    }

    对这个算法进行封装成一个CPU指令,我们就可以利用二进制进行进行运算。

Java代码最终的编译结果

我们知道Java的代码最终是经过编译器,转换成字节码最终由JVM解释执行,具体过程如下:

阅读更多

Tomcat不安全字符的处理

做项目的时候碰到一个问题,就是Tomcat在处理含有|,{,}的字符的Url时候,发现请求没有到达指定的Controller上面,而在Access_log中写入了get null null 400的错误信息,从网上也翻了几个资料最终确定是tomcat的一个问题(个人觉得也是一个缺陷)

问题的由来

Tomcat根据rfc的规范Url中不能有类似|,{,}等不安全字符串,但在实际的操作中有时为了数据完整性和加密的方式都需要有|,{,}出现,这样的话Tomcat会直接告诉客户端Bad Request.

对于这个问题,很多人也提出很多不同的看法:https://bz.apache.org/bugzilla/show_bug.cgi?id=60594,经过修改,最终Tomcat把权限开放出来,通过tomcat.util.http.parser.HttpParser. requestTargetAllow这个配置选项,允许不安全字符的出现。Tomcat详细配置

解决方法

经过几次探索,有以下几个方法能够解决这个问题:

  1. 把请求的Url进行编码,这个对源头进行处理,来规避这个问题,如果是第三方来调用的url就无能无力。

  2. 修改Tomcat的配置文件(Tomcat\conf\catalina.properties),适用tomcat 7以上的版本

    1
    2
    3

    tomcat.util.http.parser.HttpParser.requestTargetAllow=|{}

  3. 使用其它服务器进行中转,比如IIS和Apache

阅读更多

详解.net中IL语言

什么是IL语言

中间语言,又称(IL语言)。充当Clr与.net 平台的中间语言,比如用C#编写程序,编译器首先是把C#代码转译成IL语言,最终由Clr解释执行,下面我们学习下IL语言。

如何读懂IL语言

  • 写一个helloworld的.net 程序,编译运行完成。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    		static void Main(string[] args)
    {
    Console.WriteLine("hello world");
    }
    ```

    - 使用ildasm.exe(C:\Program Files (x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.6 Tools)反编译代码,得到IL代码如下:

    ```IL
    .method private hidebysig static void Main(string[] args) cil managed
    {
    .entrypoint
    // 代码大小 13 (0xd)
    .maxstack 8
    IL_0000: nop
    IL_0001: ldstr "hello world"
    IL_0006: call void [mscorlib]System.Console::WriteLine(string)
    IL_000b: nop
    IL_000c: ret
    } // end of method Program::Main
    ```

    - 查找对应的[指令表](http://blog.csdn.net/xiaouncle/article/details/71248830),来确定对应的含义


    <table class="table">
    <thead>
    <tr>
    <th>指令名称</th>
    <th>说明</th>
    </tr>
    </thead>
    <tbody>
    <tr>
    <td>Ldstr</td>
    <td>推送对元数据中存储的字符串的新对象引用。</td>
    </tr>
    <tr>
    <td>Nop</td>
    <td>如果修补操作码,则填充空间。尽管可能消耗处理周期,但未执行任何有意义的操作。</td>
    </tr>
    <tr>
    <td>Call</td>
    <td>调用由传递的方法说明符指示的方法。</td>
    </tr>
    <tr>
    <td>Ret</td>
    <td>从当前方法返回,并将返回值(如果存在)从调用方的计算堆栈推送到被调用方的计算堆栈上。</td>
    </tr>
    </tbody>
    </table>

    - 其它几个名词的的解释

    **hidebysig**: 与之对就的是hidebyname,这个是确定使用方法的签名还是使用方法的名称来确定调用哪个方法.


    - 整个的IL语言解释

    ```IL
    .method private hidebysig static void Main(string[] args) cil managed
    {
    .entrypoint //代码入口
    // 代码大小 13 (0xd)
    .maxstack 8 //整个程序的堆栈大小
    IL_0000: nop //无实在意义
    IL_0001: ldstr "hello world" //定义字符
    IL_0006: call void [mscorlib]System.Console::WriteLine(string) //调用WriteLine变量
    IL_000b: nop
    IL_000c: ret //返回
    } // end of method Program::Main
    ```


    ### 更复杂的Demo

    - 添加编写如下C#代码:

    ``` C#
    class Program
    {
    static void Main(string[] args)
    {
    var a = 0;
    var b = 1;
    var c = Add(a, b);
    Console.WriteLine(c.ToString());
    }

    public static int Add(int x,int y)
    {
    return x + y;
    }
    }

    ```

    - 生成相关的IL代码及解释

    ``` IL
    .method private hidebysig static void Main(string[] args) cil managed
    {
    .entrypoint
    // 代码大小 27 (0x1b)
    .maxstack 2
    .locals init ([0] int32 a,
    [1] int32 b,
    [2] int32 c) //定义3个变量
    IL_0000: nop
    IL_0001: ldc.i4.0 //将整数值 0 作为 int32 推送到计算堆栈上。
    IL_0002: stloc.0 //从计算堆栈的顶部弹出当前值并将其存储到索引 0 处的局部变量列表中。
    IL_0003: ldc.i4.1 //将整数值 1 作为 int32 推送到计算堆栈上。
    IL_0004: stloc.1 //从计算堆栈的顶部弹出当前值并将其存储到索引 1 处的局部变量列表中。
    IL_0005: ldloc.0 //将索引 0 处的局部变量加载到计算堆栈上,这里指a。
    IL_0006: ldloc.1 //将索引 1 处的局部变量加载到计算堆栈上,这里指b。
    IL_0007: call int32 ILTest.Program::Add(int32,
    int32) //调用Add方法
    IL_000c: stloc.2 //将索引 2 处的局部变量加载到计算堆栈上,这里指c。
    IL_000d: ldloca.s c //将位于特定索引处的局部变量的地址加载到计算堆栈上(短格式)。
    IL_000f: call instance string [mscorlib]System.Int32::ToString()
    IL_0014: call void [mscorlib]System.Console::WriteLine(string)
    IL_0019: nop
    IL_001a: ret
    } // end of method Program::Main

    ```

    Add方法:

    ``` IL
    .method public hidebysig static int32 Add(int32 x,int32 y) cil managed
    {
    // 代码大小 9 (0x9)
    .maxstack 2
    .locals init ([0] int32 V_0) //创建一个V_0的局部变量
    IL_0000: nop
    IL_0001: ldarg.0 //将索引为 0 的参数加载到计算堆栈上。
    IL_0002: ldarg.1 //将索引为 1 的参数加载到计算堆栈上。
    IL_0003: add //将两个值相加并将结果推送到计算堆栈上。
    IL_0004: stloc.0
    IL_0005: br.s IL_0007 //无条件地将控制转移到目标指令(短格式)
    IL_0007: ldloc.0 //将索引 0 处的局部变量加载到计算堆栈上。
    IL_0008: ret
    } // end of method Program::Add
阅读更多

服务器CPU居高不下--解决问题历程

基本的概述

在一个服务器的集群上面,服务器的CPU长时间居高不下,响应的时间也一直很慢,即使扩容了服务器CPU的下降效果也不是很明显。

对于CPU过高的原因,可以总结到以下原因:

  • 太多的循环或者死循环

  • 加载了过多的数据,导致产生了很多的大对象

  • 产生了过多的对象,GC回收过于频繁(如:字符串拼接)

对于上面的情况,难点不是优化代码,难点在于定位到问题的所在,下面我们就用Dump抓包的方式来定位到问题的所在。介绍这个内容之前,我们要先回顾下.Net中垃圾回收的基础知识和一个工具的准备。


基础知识


垃圾回收触发条件

  • 代码显示调用System.GC的静态方法

  • windows报告低内存情况

  • CLR正在卸载AppDoamin

  • CLR正在关闭

阅读更多

如何使用正则表达式

说到正则,可能很多人会很头疼这个东西,除了计算机好像很难快速的读懂这个东西,更不用说如果使用了。下面我们由浅入深来探索下正则表达式:

ps:此文适用于还有没有入门正则表达基础的读者

正则表达式可以简的定义成为一种字符串的匹配方式,至于来源可以参考:正则表达式{:target=_blank}

简单的使用

有这么一段字符串ABC12345ABC1234AB12C,对于这个字符串,如果想提取其中的字母,应该怎么办呢?

1
2
3
4
5
6
1. 可以找出所有的字母列表组成一个数组,[A,B,C...Z]     

2. 把字符串转成字符的数组,进行遍历

3. 如果是字母则继续,如果不是则直接继续下一个匹配

以上的分析过程则大概的讲述了不用正则表达式的过程,如果使用正则,怎么去写呢?

首先,我们是要匹配字母,那我要知道正则中用什么来表式字母呢?

1
2
3
4
5
6
7
8

[a-z] //匹配所有的小写字母
[A-Z] //匹配所有的大写字母
[a-zA-Z] //匹配所有的字母
[0-9] //匹配所有的数字
[0-9\.\-] //匹配所有的数字,句号和减号
[ \f\r\t\n] //匹配所有的白字符

阅读更多