发表于
字数统计 569 字 | 阅读时长 2 分钟

我们业务里有一张表存储的是图关系结构，今天，我们需要查询出和某个节点有联系的所有节点。图是有向图。

业务抽象出的表结构很简单：

1
2
3
4
5
6
7
create table if not exists tests(
   id serial not null,
   point1 int not null,
   point2 int not null,

   primary key(id)
);

其中，我们定义point1是起始点，point2是终点。举个例子：(1, 2)代表从1节点到2节点。

然后我们模拟一些测试数据：

1
2
3
4
5
6
7
8
insert into tests (point1, point2) values(1, 4),
(1, 5),
(4, 6),
(5, 6),
(2, 5),
(2, 7),
(7, 8),
(3, 9);

这些节点对应的图如下：

1
2
3
4
5
6
7
8
9
10
11
           1                            2                                      3
           +                            +                                      +
           |                            |                                      |
+----------+--------+                   |                                      |
|                   |                   |                                      |
|                   |                   |                                      |
|                   |                   |                                      |
v                   v                   |                                      |
4                   5<------------------+---------->7            9<------------+
+                   +                               +
+--------->6<-------+                         8<----+

也就是说，我这里产生了9个节点，8条边。

如果我想查询节点1有联系的其他节点，那么可以通过如下SQL语句查出来：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
WITH RECURSIVE results AS
(
  SELECT
    id,
    point1,
    point2
  FROM  tests
  WHERE point1 = 1
  UNION ALL
  SELECT
    origin.id,
    origin.point1,
    origin.point2
  FROM results
  JOIN tests origin
  ON results.point2 = origin.point1
)
SELECT
  id,
  point1,
  point2
FROM results;

其中，

WITH被称为通用表表达式(Common Table Expressions)，作用是把复杂查询语句拆分成多个简单的部分。用法比较简单，大家可以搜一下这个的用法。

RECURSIVE修饰符来引入它自己，从而实现递归。

WITH RECURSIVE语句包含了非递归部分：

1
2
3
4
5
6
SELECT
id,
point1,
point2
FROM  tests
WHERE point1 = 1

和递归部分：

1
2
3
4
5
6
7
SELECT
origin.id,
origin.point1,
origin.point2
FROM results
JOIN tests origin
ON results.point2 = origin.point1

然后UNION ALL用来结合这两部分的结果，最终得到我们的图：

1
2
3
4
5
6
7
8
9
postgres=# WITH RECURSIVE results AS (   SELECT     id,     point1,     point2   FROM  tests   WHERE point1 = 1   UNION ALL   SELECT     origin.id,     origin.point1,     origin.point2   FROM results   JOIN tests origin   ON results.point2 = origin.point1 ) SELECT   id,   point1,   point2 FROM results;

 id | point1 | point2
----+--------+--------
  1 |      1 |      4
  2 |      1 |      5
  3 |      4 |      6
  4 |      5 |      6
(4 rows)

然后，我们也可以根据有向图的反方向进行搜索，SQL语句如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
WITH RECURSIVE results AS
(
  SELECT
    id,
    point1,
    point2
  FROM  tests
  WHERE point2 = 6
  UNION ALL
  SELECT
    origin.id,
    origin.point1,
    origin.point2
  FROM results
  JOIN tests origin
  ON origin.point2 = results.point1
)
SELECT
  id,
  point2,
  point1
FROM results;

这样我们就会得到图：

1
2
3
4
5
6
7
8
9
10
postgres=# WITH RECURSIVE results AS (   SELECT     id,     point1,     point2   FROM  tests   WHERE point2 = 6   UNION ALL   SELECT     origin.id,     origin.point1,     origin.point2   FROM results   JOIN tests origin   ON origin.point2 = results.point1 ) SELECT   id,   point2,   point1 FROM results;

 id | point2 | point1
----+--------+--------
  3 |      6 |      4
  4 |      6 |      5
  1 |      4 |      1
  2 |      5 |      1
  5 |      5 |      2
(5 rows)

发表于
字数统计 193 字 | 阅读时长 1 分钟

Composer自动加载类型

1
2
3
4
1、files
2、classmap
3、psr-0
4、psr-4

建议：项目代码用psr-4自动加载，helper用files自动加载，生产环境用classmap自动加载。psr-0已经被抛弃了，历史遗留代码有部分使用。

我们现在来测试一下，我们先创建一个测试根目录autoloads，然后进入：

1
2
~/codeDir/phpCode # mkdir autoloads ; cd autoloads
~/codeDir/phpCode/autoloads #

files

我们创建目录libraries，然后进入：

1
2
~/codeDir/phpCode/autoloads # mkdir libraries ; cd libraries
~/codeDir/phpCode/autoloads/libraries #

然后创建文件functions.php：

1
2
~/codeDir/phpCode/autoloads/libraries # touch functions.php
~/codeDir/phpCode/autoloads/libraries #

内容如下：

1
2
3
4
5
<?php

function func1 () {
    return 'in func1.';
}

然后，我们在目录autoloads下面创建一个composer.json文件：

1
~/codeDir/phpCode/autoloads/libraries # cd .. ; touch composer.json

内容如下：

1
2
3
4
5
{
    "autoload": {
        "files": ["libraries/functions.php"]
    }
}

发表于
字数统计 1.8k 字 | 阅读时长 8 分钟

作业(job) 控制

现代的shell解释器中存在作业控制功能

1、按ctrl+ Z将向当前进程发送SIGSTOP信号，如果当前进程没有实现SIGSTOP的特定逻辑，默认的行为是当前进程暂停并置入后台

2、使用命令fg来使恢复后台进程的前台运行

3、使用命令bg来使暂停的后台进程后台继续运行

4、使用命令jobs来显示后台作业

5、作业号不同于进程号

举个例子，比如我要查看Docker容器的输出日志：

1
2
3
4
5
6
hantaohuang@~ docker logs -f php
log1
log2
log3
^Z
[1]+  Stopped                 docker logs -f php

这个时候，我按下了ctrl + z。容器就会停止打印日志。

这里

1
[1]+  Stopped                 docker logs -f php

中的1就是作业号。如果我们想要恢复作业的执行，可以输入命令：

1
2
3
hantaohuang@~ bg %1
log4
log5

虽然还在打印日志，但是我们可以在这个时候执行命令，因为这个作业是跑在后台的（尽管它的输出是STDOUT）

1
2
3
4
hantaohuang@~ ls
Applications		Downloads		Music			Public			data			dockerfileDir		huanghantao.github.io
Desktop			Library			Pictures		cert			db			eclipse			tmp
Documents		Movies			Postman			codeDir			dev			eclipse-workspace	var

再举个例子，假设我在编辑一个文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
hantaohuang@~ vim test.txt

~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
"test.txt" [New File]

这个时候，我会进入vim编辑器。此时，我们写hello world：

1
2
3
4
5
6
7
8
9
10
11
12
hello world
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
-- INSERT --

接着，我想写一下open()这个函数的用法，但是我忘了。这个时候，我们可以不需要另起一个终端，我们先按esc退出vim的编辑模式，然后按下ctrl + z：

1
2
3
4
hantaohuang@~ vim test.txt

[1]+  Stopped                 vim test.txt
hantaohuang@~

这个时候，我们再查看文档：

1
2
3
hantaohuang@~ man open
NAME
     open -- open files and directories

然后，我们再通过命令fg把作业拉回前台：

1
2
3
4
5
6
7
8
9
10
11
hantaohuang@~ fg %1
hello world
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~

然后写下open()函数的用法：

1
2
3
4
5
6
7
8
9
10
11
hello world
open -- open files and directories
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~                                                                                                                                                                                                           
~ 
-- INSERT --

然后再关闭文件。

（如果你是通过bg命令来恢复vim的话，是不可以编辑的，小伙伴们可以尝试一下）

通过分号来分隔多条命令

之前，我一直是通过&&来分隔多条命令的：

1
2
3
4
~/codeDir/phpCode/swoole-src-4.4.4 # echo 1 && echo 2
1
2
~/codeDir/phpCode/swoole-src-4.4.4 #

其实也可以通过;来分隔多条命令：

1
2
3
4
~/codeDir/phpCode/swoole-src-4.4.4 # echo 1 ; echo 2
1
2
~/codeDir/phpCode/swoole-src-4.4.4 #

用&后台执行条命令

我们上面举了一个在后台输出Docker容器日志的例子。其实，ctrl + z和bg %1可以用命令后面加&来完成。来测试一下：

1
2
3
4
5
6
7
8
9
10
hantaohuang@~ docker logs -f php &
log1
log2
log3
hantaohuang@~ ls
Applications		Downloads		Music			Public			data			dockerfileDir		huanghantao.github.io
Desktop			Library			Pictures		cert			db			eclipse			tmp
Documents		Movies			Postman			codeDir			dev			eclipse-workspace	var
log4
log5

实际上，通过命令加&也会生成一个作业号。当然，我们就可以去控制这个作业了。

pipeline

1
2
3
4
|
>
<
>>

|

|会把前一个命令的输出作为后一条命令的输入。

例如：

1
2
3
~/codeDir/phpCode/swoole-src-4.4.4 # echo hello | base64
aGVsbG8K
~/codeDir/phpCode/swoole-src-4.4.4 #

我们把echo命令的输出作为base64命令的输入，所以这里会把hello字符串进行base64编码。

如果我们需要把aGVsbG8K解码，可以做类似的操作：

1
2
3
~/codeDir/phpCode/swoole-src-4.4.4 # echo aGVsbG8K | base64 -d
hello
~/codeDir/phpCode/swoole-src-4.4.4 #

成功解码。

>

把输出内容写入文件里面，举个例子：

1
2
~/codeDir/phpCode/swoole-src-4.4.4 # echo hello > test.txt
~/codeDir/phpCode/swoole-src-4.4.4 #

然后查看内容：

1
2
3
~/codeDir/phpCode/swoole-src-4.4.4 # cat test.txt 
hello
~/codeDir/phpCode/swoole-src-4.4.4 #

>>

以追加模式打开文件内容，然后把输出内容追加到文件末尾，举个例子：

1
2
~/codeDir/phpCode/swoole-src-4.4.4 # echo world >> test.txt 
~/codeDir/phpCode/swoole-src-4.4.4 #

然后查看内容：

1
2
3
4
~/codeDir/phpCode/swoole-src-4.4.4 # cat test.txt 
hello
world
~/codeDir/phpCode/swoole-src-4.4.4 #

<

可以把文件里面的内容作为左边命令的标准输入，举个例子：

1
2
3
~/codeDir/phpCode/swoole-src-4.4.4 # base64 < test.txt 
aGVsbG8Kd29ybGQK
~/codeDir/phpCode/swoole-src-4.4.4 #

我们解码一下：

1
2
3
4
~/codeDir/phpCode/swoole-src-4.4.4 # echo aGVsbG8Kd29ybGQK | base64 -d
hello
world
~/codeDir/phpCode/swoole-src-4.4.4 #

Heredoc

在命令后使用<<来使用heredoc功能。

1
2
3
4
5
~/codeDir/phpCode/swoole-src-4.4.4 # base64 <<EOF
> hello
> EOF
aGVsbG8K
~/codeDir/phpCode/swoole-src-4.4.4 #

我们发现Heredoc可以作为标准输入。

我们在<<的后面输入一个终结符EOF，但是终结符可以用其他任意的字符串，例如：

1
2
3
4
5
~/codeDir/phpCode/swoole-src-4.4.4 # base64 <<EO
> hello
> EO
aGVsbG8K
~/codeDir/phpCode/swoole-src-4.4.4 #

但是，开头和结尾必须要匹配：

1
2
3
4
5
6
~/codeDir/phpCode/swoole-src-4.4.4 # base64 <<EO
> hello
> Eo
> EO
aGVsbG8KRW8K
~/codeDir/phpCode/swoole-src-4.4.4 #

我们发现，大小写要一致。

那么，我们能否直接用<呢？小伙伴们发现，<<和<很类似对吧，我们来测试一下：

1
2
3
~/codeDir/phpCode/swoole-src-4.4.4 # base64 < hello
sh: can't open hello: no such file
~/codeDir/phpCode/swoole-src-4.4.4 #

我们发现不行，因为<的右边得是一个文件名字而不是字符串。

我们再举一个比较高级一点的例子，cat命令可以打开一个文件、读取里面的内容，然后输出到stdout。

举个例子：

1
2
3
4
~/codeDir/phpCode/swoole-src-4.4.4 # echo hello > test.txt 
~/codeDir/phpCode/swoole-src-4.4.4 # cat test.txt 
hello
~/codeDir/phpCode/swoole-src-4.4.4 #

我们先往文件test.txt里面写入字符串hello，然后通过命令cat读取到test.txt文件的内容输出到stdout。但是，如果cat命令后面没有接文件名会怎么样？

1
~/codeDir/phpCode/swoole-src-4.4.4 # cat

我们发现，这个进程会阻塞起来。然后，如果我们输入一些字符串按下回车：

1
2
3
~/codeDir/phpCode/swoole-src-4.4.4 # cat
hello
hello

我们发现，会打印出我们敲入的字符串hello。这说明了什么问题？说明cat后面不接文件名，那么就会读取stdin的内容，然后输出到stdout。

我们继续来看这个例子：

1
2
3
4
5
~/codeDir/phpCode/swoole-src-4.4.4 # echo in > in.txt
~/codeDir/phpCode/swoole-src-4.4.4 # cat in.txt > out.txt
~/codeDir/phpCode/swoole-src-4.4.4 # cat out.txt 
in
~/codeDir/phpCode/swoole-src-4.4.4 #

我们把文件in.txt里面的内容通过cat命令输出后通过>重定向到了文件out.txt里面，所以我们可以在文件out.txt里面看到内容in。

我们再来看一个例子：

1
~/codeDir/phpCode/swoole-src-4.4.4 # cat > test.txt

使用了>意味着我们想把第一个命令的stdout重定向到文件test.txt里面对吧。我们输入内容：

1
2
3
4
5
6
~/codeDir/phpCode/swoole-src-4.4.4 # cat > test.txt 
hello
^C
~/codeDir/phpCode/swoole-src-4.4.4 # cat test.txt 
hello
~/codeDir/phpCode/swoole-src-4.4.4 #

我们输入hello之后按下回车键，然后按下ctrl + c关闭进程。可以看到，文件test.txt里面有了内容hello。

最后，我们来完成一个高级的例子：

1
2
3
4
5
6
~/codeDir/phpCode/swoole-src-4.4.4 # cat > test.txt << EOF
> world
> EOF
~/codeDir/phpCode/swoole-src-4.4.4 # cat test.txt 
world
~/codeDir/phpCode/swoole-src-4.4.4 #

通过上面的例子，我相信大家可以很好的例子这条命令了。我们通过heredoc语法把world字符串作为stdin，然后因为cat命令后面没有根文件名，所以会去读取stdin里面的内容，即world，然后输出到stdout，最后通过>重定向到文件test.txt里面。

发表于
字数统计 3k 字 | 阅读时长 12 分钟

TCP关闭的过程（四次握手）

1
2
3
4
1、客户端 发送FIN包给 服务端，此时客户端处于FIN_WAIT1状态
2、服务端 发送ACK包给 客户端，此时服务器处于CLOSE_WAIT状态，并且客户端在等待ACK包的时候，处于FIN_WAIT2状态
3、服务端 发送FIN包给 客户端，此时服务端处于LAST_ACK状态
4、客户端 发送ACK包给 服务端，此时客户端处于TIME_WAIT状态

第一次握手细节

客户端在应用层调用close方法时，操作系统底层会放送FIN包给服务端，此时客户端处于FIN_WAIT1状态。然后当服务端收到了FIN包之后，服务端在应用层的表现是调用recv方法得到的返回值是0，代表客户端关闭了连接。在Swoole中的表现是会触发OnClose回调函数。然后我们可以在OnClose回调函数里面写一些清除用户信息的代码。

第二次握手细节

服务端发送ACK包给客户端，此时服务端处于CLOSE_WAIT状态。顾名思义，就是服务端也要去调用close函数，才能把这个连接彻底的关闭（因为TCP是一个全双工的协议，客户端可以给服务端发，服务端也可以给客户端发）。所以这段等待的状态就叫做CLOSE_WAIT。

第三次握手细节

服务端应用层调用close函数，操作系统底层发送FIN包给客户端，此时服务端处于LAST_ACK状态。顾名思义，服务端需要去等待客户端发来的ACK。

第四次握手细节

客户端发送ACK包给服务端，此时客户端处于TIME_WAIT状态，而TIME_WAIT状态的时间长达1分钟。服务端收到了ACK包之后，整个TCP连接的生命周期就算结束了。

TIME_WAIT状态

为什么要有TIME_WAIT状态

那么，这里客户端在发送ACK包之后为什么需要处于一个TIME_WAIT状态，而不是立马结束了呢？（我们知道，如果连接处于TIME_WAIT状态的话，一般情况下是不可以重新使用同一个IP和端口的。这在一些情况下就会给我们造成不愉快。）

因为服务端可能会没有收到客户端发来的ACK包。如果，服务端没有收到ACK包，那么服务端会重发一个FIN包给客户端，如果没有TIME_WAIT状态，那么客户端就会丢失服务端重传的FIN包。而客户端发送ACK包以及服务端重传FIN包的时间，就是TIME_WAIT的时长。如果在这个时长（1分钟）里面，客户端没有收到服务端重传的FIN包，那么客户端就认为服务端收到了ACK包，可以结束TIME_WAIT状态了。

为什么TIME_WAIT状态持续1分钟

那么，为什么TIME_WAIT的时长是1分钟之久呢？

因为一个IP存活的时间是1分钟，为了防止下一个连接收到之前连接的数据包。

如果客户端在发送完ACK包之后，立马结束掉。但是，紧接着又重新使用了同一个IP和端口，那么很有可能就会收到上一个连接发来的数据。（因为由于网络的原因，服务端发送的数据包到达客户端可能会有一些延迟）。收到上一个连接的包，这显然是我们不希望看到的。

所以，客户端在发送ACK包之后，会去处于一个TIME_WAIT状态，等待1分钟。而这1分钟内，一般情况下，客户端是不可以立马重用同一个IP和端口的。这样，就避免了客户端起了第二个连接，却收到了之前的连接的包。因为1分钟结束后，之前连接的包已经不存在了。

Cannot assign requested address

这个问题是针对客户端随机选取一个端口的时候，发现没有端口可用会报这个错误，即所谓的端口用光了。

如果我们客户端并发连接数很大，而每个连接最后都处于TIME_WAIT状态，那么我们机器的端口迟早会被用完，因为我们的机器端口数量是有限的。

所以，端口用光的根本原因是有大量处于TIME_WAIT状态的连接。

而PHP传统的FPM模式下，会比较常见这种问题，因为客户端每次请求结束，我们服务的连接数据库的连接也会断开。而一旦并发量大了上来，就会出现端口不够的情况了。

Address already in use

Address already in use是我们自己决定使用某个端口，发现它被占用的时候会报这个问题。与Cannot assign requested address是有区别的，因为Cannot assign requested address是系统帮我们随机选择一个端口，发现没有端口可以选择了，才会报Cannot assign requested address的问题，即所谓的端口用光了。

可以通过SO_RESUADDR来解决。

CLOSE_WAIT状态

如果我们被动关闭的一方没有调用close函数，那么被动关闭方就会处于close_wait状态。

Swoole服务器在触发完OnClose回调函数之后，维护连接的那个进程会自动的帮我们执行close函数。所以，就很少会见到CLOSE_WAIT状态。

但是，如果我们在OnClose回调函数里面阻塞了或者说在OnReceive里面阻塞了（只要主动关闭方关闭了连接，被动关闭方的OnClose回调函数无法顺利执行完或者没有被执行），那就会出现CLOSE_WAIT状态。

举个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php

$server = new \Swoole\Server('127.0.0.1', 9501, SWOOLE_PROCESS);

$server->set([
    'work_num' => 2,
]);

$server->on('connect', function ($server, $fd)
{
});

$server->on('receive', function ($server, $fd, $reactor_id, $data)
{
});

$server->on('close', function ()
{
    sleep(1000);
});

$server->start();

此时服务器在OnClose回调函数里面阻塞了，导致这个函数无法正常结束，导致Swoole底层无法在OnClose回调函数结束之后，自动帮我们执行close函数（本质上，是worker进程无法通知主进程去close）。

客户端代码：

1
2
3
4
5
<?php

$client = new \Swoole\Client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_SYNC);
$client->connect('127.0.0.1', 9501);
$client->close();

这里，客户端连接完服务器之后，主动关闭了连接。

执行服务器：

1
~/codeDir/phpCode/hyperf-skeleton # php server.php

执行客户端：

1
2
~/codeDir/phpCode/hyperf-skeleton # php client.php 
~/codeDir/phpCode/hyperf-skeleton #

然后查看网络状态：

1
2
3
4
5
6
7
8
~/codeDir/phpCode/hyperf-skeleton # netstat -antp
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 127.0.0.1:9501          0.0.0.0:*               LISTEN      23308/php
tcp        0      0 127.0.0.11:37569        0.0.0.0:*               LISTEN      -
tcp        0      0 127.0.0.1:54004         127.0.0.1:9501          FIN_WAIT2   -
tcp        0      0 127.0.0.1:9501          127.0.0.1:54004         CLOSE_WAIT  23308/php
~/codeDir/phpCode/hyperf-skeleton #

我们发现：

1
tcp        0      0 127.0.0.1:9501          127.0.0.1:54004         CLOSE_WAIT  23308/php

此时，服务端这边的状态是CLOSE_WAIT。因为服务端没有发生FIN包，所以客户端这边处于FIN_WAIT2状态。

我们过一段时间，例如2分钟再次查看网络状态：

1
2
3
4
5
6
7
~/codeDir/phpCode/hyperf-skeleton # netstat -antp
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 127.0.0.1:9501          0.0.0.0:*               LISTEN      23308/php
tcp        0      0 127.0.0.11:37569        0.0.0.0:*               LISTEN      -
tcp        0      0 127.0.0.1:9501          127.0.0.1:54004         CLOSE_WAIT  23308/php
~/codeDir/phpCode/hyperf-skeleton #

我们发现服务端这边还是处于CLOSE_WAIT状态，一直没有消失。这个就叫做连接泄漏。

我们再换一种测试方法，我们在OnClose回调函数里面执行die，或者抛出异常，或者有致命错误导致worker进程直接结束了，此时Swoole底层也无法帮我们执行close方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php

$server = new \Swoole\Server('127.0.0.1', 9501, SWOOLE_PROCESS);

$server->set([
    'work_num' => 2,
]);

$server->on('connect', function ($server, $fd)
{
});

$server->on('receive', function ($server, $fd, $reactor_id, $data)
{
});

$server->on('close', function ()
{
    die;
});

$server->start();

我们重新启动服务器：

1
~/codeDir/phpCode/hyperf-skeleton # php server.php

然后，我们确认下网络状态：

1
2
3
4
5
6
~/codeDir/phpCode/hyperf-skeleton # netstat -antp
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 127.0.0.1:9501          0.0.0.0:*               LISTEN      26276/php
tcp        0      0 127.0.0.11:37569        0.0.0.0:*               LISTEN      -
~/codeDir/phpCode/hyperf-skeleton #

此时服务端处于LISTEN状态。

然后，我们执行刚才的客户端代码：

1
~/codeDir/phpCode/hyperf-skeleton # php client.php

此时，服务端报错：

1
2
3
4
5
6
7
8
9
10
11
~/codeDir/phpCode/hyperf-skeleton # php server.php 

Fatal error: Uncaught Swoole\ExitException: swoole exit in /root/codeDir/phpCode/hyperf-skeleton/server.php:19
Stack trace:
#0 {main}
  thrown in /root/codeDir/phpCode/hyperf-skeleton/server.php on line 19
[2019-08-22 08:08:54 *26286.0]	ERROR	php_swoole_server_rshutdown (ERRNO 503): Fatal error: Uncaught Swoole\ExitException: swoole exit in /root/codeDir/phpCode/hyperf-skeleton/server.php:19
Stack trace:
#0 {main}
  thrown in /root/codeDir/phpCode/hyperf-skeleton/server.php on line 19
[2019-08-22 08:08:54 $26277.0]	WARNING	swManager_check_exit_status: worker#0[pid=26286] abnormal exit, status=255, signal=0

然后，我们查看一下网络状态：

1
2
3
4
5
6
7
8
~/codeDir/phpCode/hyperf-skeleton # netstat -antp
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 127.0.0.1:9501          0.0.0.0:*               LISTEN      26276/php
tcp        0      0 127.0.0.11:37569        0.0.0.0:*               LISTEN      -
tcp        0      0 127.0.0.1:54006         127.0.0.1:9501          FIN_WAIT2   -
tcp        0      0 127.0.0.1:9501          127.0.0.1:54006         CLOSE_WAIT  26276/php
~/codeDir/phpCode/hyperf-skeleton #

此时，服务端这边处于CLOSE_WAIT状态，成功的导致了连接泄漏。

这是我们Swoole的服务器处于SWOOLE_PROCESS模式下会出现的问题。但是，SWOOLE_BASE模式下不会出现这个问题。

因为SWOOLE_PROCESS模式下连接是和master进程里面建立的，而SWOOLE_BASE模式下连接是和worker进程直接建立的，worker进程结束之后，操作系统底层会自动发一个FIN包给客户端。

我们来测试一下，服务端的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php

$server = new \Swoole\Server('127.0.0.1', 9501, SWOOLE_BASE);

$server->set([
    'work_num' => 2,
]);

$server->on('connect', function ($server, $fd)
{
});

$server->on('receive', function ($server, $fd, $reactor_id, $data)
{
});

$server->on('close', function ()
{
    die;
});

$server->start();

然后重新启动服务器：

1
~/codeDir/phpCode/hyperf-skeleton # php server.php

此时确认网络状态：

1
2
3
4
5
6
~/codeDir/phpCode/hyperf-skeleton # netstat -antp
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 127.0.0.1:9501          0.0.0.0:*               LISTEN      30174/php
tcp        0      0 127.0.0.11:37569        0.0.0.0:*               LISTEN      -
~/codeDir/phpCode/hyperf-skeleton #

服务端的连接处于LISTEN状态。

然后启动客户端：

1
2
~/codeDir/phpCode/hyperf-skeleton # php client.php 
~/codeDir/phpCode/hyperf-skeleton #

然后查看网络状态：

1
2
3
4
5
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 127.0.0.11:37569        0.0.0.0:*               LISTEN      -
tcp        0      0 127.0.0.1:54008         127.0.0.1:9501          TIME_WAIT   -
~/codeDir/phpCode/hyperf-skeleton #

此时，服务器端的状态没了，因此没出现CLOSE_TIME状态。因为服务端发送了FIN包，所以客户端这边不再是FIN_WAIT2状态，而是TIME_WAIT状态了。

我们看看服务器端的输出：

1
2
3
4
5
6
7
8
9
10
11
~/codeDir/phpCode/hyperf-skeleton # php server.php 

Fatal error: Uncaught Swoole\ExitException: swoole exit in /root/codeDir/phpCode/hyperf-skeleton/server.php:19
Stack trace:
#0 {main}
  thrown in /root/codeDir/phpCode/hyperf-skeleton/server.php on line 19
[2019-08-22 08:19:27 *30174.0]	ERROR	php_swoole_server_rshutdown (ERRNO 503): Fatal error: Uncaught Swoole\ExitException: swoole exit in /root/codeDir/phpCode/hyperf-skeleton/server.php:19
Stack trace:
#0 {main}
  thrown in /root/codeDir/phpCode/hyperf-skeleton/server.php on line 19
~/codeDir/phpCode/hyperf-skeleton #

我们发现，报错之后，Swoole服务器直接退出了。

同理，在SWOOLE_BASE模式下，因为连接的accept是在Worker进程里面进行的，所以worker进程一旦业务逻辑里面出现了阻塞，那么backlog就很容易塞满。但是SWOOLE_PROCESS模式下，因为accept是在主进程进行的，所以，如果我们在worker进程里面阻塞了，是不会影响到backlog的。这也是为什么Swoole会把连接的处理和业务逻辑的处理分成多个进程来处理。

（我们要清楚的知道，常用的事件回调函数是在主进程里面调用的还是worker进程里面调用的）

发表于
字数统计 1.5k 字 | 阅读时长 6 分钟

这篇文章是总结自Swoole微课程《Swoole与TCP三次握手》。可以说，这套视频教程非常的棒，Swoole官方每天都会分享一个10到20分钟的视频，一天只需要1块钱！是夯实基础的好课程。微信搜索：Swoole微课程。

握手常见问题

1
2
3
4
1、连接拒绝
2、Operation now in progress
	多是因为丢包、错误ip、backlog满了&阻塞&tcp_abort_on_overflow=0
3、min(maxconn, backlog) ss -lt

连接拒绝

在TCP三次握手的时候，客户端发送SYN这个包给服务端，服务端不接受这个请求，操作系统直接返回了一个RST的包，来拒绝连接的请求。

最常见的情况就是客户端去请求某个服务器，服务端没有绑定对应的端口。

测试代码如下，服务端代码：

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
<?php

$server = new \Swoole\Server('127.0.0.1', 9501);

$server->set([
    'work_num' => 2,
    'backlog' => 128,
]);

$server->on('connect', function ($server, $fd)
{
    echo "Client: Connect.\n";
});

$server->on('receive', function ($server, $fd, $reactor_id, $data)
{
    var_dump($data);
});

$server->on('close', function ()
{
    var_dump('close');
});

$server->start();

这里，服务端绑定的端口是9501。

启动服务器：

1
~/codeDir/phpCode/hyperf-skeleton # php server.php

客户端代码：

1
2
3
4
<?php

$client = new \Swoole\Client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_SYNC);
var_dump($client->connect('127.0.0.1', 9500));

这里，客户端请求的端口是9500。

启动客户端：

1
2
3
4
5
~/codeDir/phpCode/hyperf-skeleton # php client.php 

Warning: Swoole\Client::connect(): connect to server[127.0.0.1:9500] failed, Error: Connection refused[111] in /root/codeDir/phpCode/hyperf-skeleton/client.php on line 4
bool(false)
~/codeDir/phpCode/hyperf-skeleton #

我们发现，报错：

1
Error: Connection refused[111]

Operation now in progress

这个错误的绝大部分原因是因为连接超时了。

丢包

例如路由器、网关出现了故障，包被丢了。

错误ip

例如客户端请求了一个错误的ip，那么路由器自然也就路由不到。

测试代码如下，客户端代码：

1
2
3
4
<?php

$client = new \Swoole\Client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_SYNC);
var_dump($client->connect('8.8.8.8', 9501));

这里，我访问的是谷歌的DNS服务器。因为我没有翻墙，所以是访问不了这个IP的。因此，我们发送的包是到达不了8.8.8.8服务器的。

启动客户端：

1
2
3
4
5
~/codeDir/phpCode/hyperf-skeleton # php client.php 

Warning: Swoole\Client::connect(): connect to server[8.8.8.8:9501] failed, Error: Operation in progress[115] in /root/codeDir/phpCode/hyperf-skeleton/client.php on line 4
bool(false)
~/codeDir/phpCode/hyperf-skeleton #

我们发现，报错：

1
Error: Operation in progress[115]

backlog

服务器在三次握手的最后一次，即收到客户端发来的ACK包的时候，会把建立好的连接放到backlog队列里面。如果Swoole一直不accept连接，那么这个backlog队列很快就会满。backlog队列满了之后，服务端就会丢弃三次握手的SYN包，让客户端重新去连接服务端。

测试代码如下，服务端代码：

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
<?php

$server = new \Swoole\Server('127.0.0.1', 9501, SWOOLE_BASE);

$server->set([
    'work_num' => 2,
    'backlog' => 128,
]);

$server->on('connect', function ($server, $fd)
{
    echo "Client: Connect.\n";
    sleep(1000);
});

$server->on('receive', function ($server, $fd, $reactor_id, $data)
{
    var_dump($data);
});

$server->on('close', function ()
{
    var_dump('close');
});

$server->start();

要想测试backlog问题必须在Swoole的SWOOLE_BASE模式下，默认的SWOOLE_PROCESS模式是没有这个问题的。

这里，我们的backlog大小是128。

然后，我们通过sleep(1000);来阻塞住进程，使得Swoole不会继续accept连接，从而导致backlog队列在某个时刻变满。

客户端代码：

1
2
3
4
5
6
7
8
9
10
11
<?php

$i = 0;
while (true)
{
    $client = new \Swoole\Client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_SYNC);
    if ($client->connect('127.0.0.1', 9501) == false)
    {
        break;
    }
}

我们启动服务器：

1
~/codeDir/phpCode/hyperf-skeleton # php server.php

然后启动客户端：

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
~/codeDir/phpCode/hyperf-skeleton # php client.php 
省略了其他的输出
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)

Warning: Swoole\Client::connect(): connect to server[127.0.0.1:9501] failed, Error: Operation in progress[115] in /root/codeDir/phpCode/hyperf-skeleton/client.php on line 7
bool(false)

Warning: Swoole\Client::connect(): connect to server[127.0.0.1:9501] failed, Error: Operation in progress[115] in /root/codeDir/phpCode/hyperf-skeleton/client.php on line 7
bool(false)
^C
~/codeDir/phpCode/hyperf-skeleton #

我们会发现，过一段时间，客户端这边会报错：

1
Error: Operation in progress[115]

服务端这边输出：

1
2
~/codeDir/phpCode/hyperf-skeleton # php server.php 
Client: Connect.

因为当Swoole服务器从backlog队列里面accept一个连接的时候，才会触发onReceive回调函数。所以，当服务端accept一个连接之后，Swoole自己就会陷入阻塞，不会再accept了。但是需要注意的是，尽管Swoole服务器自身是阻塞的，操作系统还会继续去把建立好的连接放入backlog队列里面。所以，backlog队列会满。

SYN Flood

除了三次握手成功之后会使用到的backlog队列，还有一个SYN队列。也就是在三次握手时候，客户端给服务端发送了SYN包，服务端会有一个SYN队列来维护。

与其有关的内核配置：

1
2
3
tcp_max_syn_backlog
tcp_synack_retries
tcp_syncookies

其中，tcp_max_syn_backlog就是这个SYN队列的长度。如果大量的SYN包把SYN队列塞满了，那么其他正常的连接过来，服务端就无法处理。

SYN Flood攻击就是客户端疯狂的给服务端发送SYN包，然后服务端每次都会把请求放到SYN队列里面。但是，客户端不给服务端回ACK包。如果客户端不回ACK包，那么服务端就会给客户端回SYN + ACK包，即第二次握手发送的包。而回复SYN + ACK包的次数就是由tcp_synack_retries参数决定的。如果把tcp_synack_retries设置为0，那么如果服务端没有收到ACK包，那么服务端就不会重试发送SYN + ACK包了，这样就减少了SYN队列里面那个请求的存活时间。

tcp_syncookies的原理就是，客户端发送SYN包的时候，不会维护SYN队列，而是返回一个cookie给客户端。然后客户端发送第三次握手的时候，携带这个cookie值，只有这个cookie验证通过，服务端才会给连接分配资源。

发表于
字数统计 285 字 | 阅读时长 1 分钟

模拟

系统压力测试

stress，可以模拟很多的系统压力测试，例如CPU密集型场景、IO密集型场景等等。

模拟系统多线程调度切换

sysbench，多线程的基准测试工具。

碰到上下文切换次数过多的问题时，我们可以借助vmstat、pidstat和/proc/interrupts等工具，来辅助排查性能问题的根源。

模拟磁盘和文件的 I/O

dd

查看

平均负载

uptime

多核CPU性能分析

mpstat，可以实时查看每个CPU的性能指标，以及所有CPU的平均指标。

进程性能分析

pidstat，可以实时查看进程的CPU、内存、I/O以及上下文切换等性能指标。

系统的内存使用情况分析

vmstat，主要用来分析系统的内存使用情况，也常用来分析CPU上下文切换和中断的次数。

CPU上下文切换和中断的次数分析

vmstat

查看系统缓存命中情况

cachestat 提供了整个操作系统缓存的读写命中情况。
cachetop 提供了每个进程的缓存命中情况。

发表于
字数统计 1.1k 字 | 阅读时长 5 分钟

如果你在安装了Swoole扩展之后，查看PHP脚本对应的opcode的时候，可能会发现出现很多的opcode。我举个例子吧。PHP脚本如下：

1
2
3
4
5
6
7
8
<?php

function test()
{
    echo "test";
}

echo "main";

这是一个很简单的脚本，按理来说只会生成两组opcode。但是，如果我们查看它的opcode的话，就会有如下情况：

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
function name: (null)
L1-9 {main}() /root/codeDir/phpCode/test/swoole/test.php - 0x7f82eae77840 + 5 ops
 L3    #0     EXT_STMT                                                                              
 L3    #1     NOP                                                                                   
 L8    #2     EXT_STMT                                                                              
 L8    #3     ECHO                    "main"                                                        
 L9    #4     RETURN<-1>              1                                                             

# 省略了其他的opcode

function name: _array
L16-19 _array() @swoole-src/library/functions.php - 0x7f82eae6c480 + 8 ops
 L16   #0     RECV_INIT               1                    array(0)             $array              
 L18   #1     NEW<1>                  "Swoole\\ArrayObje"+                      @0                  
 L18   #2     SEND_VAR_EX             $array               1                                        
 L18   #3     DO_FCALL                                                                              
 L18   #4     VERIFY_RETURN_TYPE      @0                                                            
 L18   #5     RETURN                  @0                                                            
 L19   #6     VERIFY_RETURN_TYPE                                                                    
 L19   #7     RETURN<-1>              null                                                          

function name: scheduler
L24-31 scheduler() @swoole-src/library/functions.php - 0x7f82eae6c700 + 8 ops
 L26   #0     BIND_STATIC<1>          $scheduler           "scheduler"                              
 L27   #1     BOOL_NOT                $scheduler                                ~0                  
 L27   #2     JMPZ                    ~0                   J6                                       
 L28   #3     NEW                     "Swoole\\Coroutine"+                      @1                  
 L28   #4     DO_FCALL                                                                              
 L28   #5     ASSIGN                  $scheduler           @1                                       
 L30   #6     RETURN                  $scheduler                                                    
 L31   #7     RETURN<-1>              null                                                          

function name: test
L3-6 test() /root/codeDir/phpCode/test/swoole/test.php - 0x7f82eae77780 + 5 ops
 L3    #0     EXT_NOP                                                                               
 L5    #1     EXT_STMT                                                                              
 L5    #2     ECHO                    "test"                                                        
 L6    #3     EXT_STMT                                                                              
 L6    #4     RETURN<-1>              null                                                          

# 省略其他的opcode

我们发现，除了main和test的两组opcode，还生成了其他大量的opcode。

为什么呢？因为Swoole4引入了一个实现扩展的技巧：通过在C/C++扩展来直接执行PHP代码，从而实现扩展的部分功能。

核心函数是php_swoole_library.h：

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
/**
 * 执行PHP代码：
 * 1、constants.php 定义常量SWOOLE_LIBRARY为true
 * 2、array.php 定义swoole_array_walk和swoole_array_walk_recursive函数
 * 3、exec.php 定义swoole_exec和swoole_shell_exec函数
 * 4、curl.php 定义了类swoole_http_status_code，里面包含了status code和对应的reason；定义了swoole_curl_handler类等等
 * 5、WaitGroup.php 定义了WaitGroup类，类似于golang的WaitGroup
 * 6、ObjectPool.php 定义了ObjectPool类，即对象池
 * 7、StringObject.php 定义了StringObject类，封装了对字符串常用的一些操作
 * 8、ArrayObject.php 定义了ArrayObject类，封装了对数组常用的一些操作
 * 9、Server.php 定义了一个协程化的Swoole\Coroutine\Server类，实际上是对Swoole\Coroutine\Socket的封装
 * 10、Connection.php 定义了一个Swoole\Coroutine\Server\Connection类
 * 11、functions.php 定义了一些函数
 * 12、alias.php 定义了Swoole\Coroutine\WaitGroup类别名Co\WaitGroup::class以及Swoole\Coroutine\Server::class类别名Co\Server::class
 * 13、alias_ns.php 定义了一些在非根命名空间下的函数，例如Swoole\Coroutine\run()以及Co\run()，实际上是对Scheduler类add和start的封装
 * 
 * 我们会发现，随着Swoole的壮大，可以用已经实现的Swoole功能去实现实现其他的功能，从而封装成一个库，提供给PHP用户空间使用。
 * 而且，这种实现方式对Swoole性能的影响还是比较小的，因为这些库在Swoole启动的时候就已经编译为了对应opcode。
 * 但是个人认为，这种实现方式比较浪费内存。例如一个int的PHP变量，需要消耗16字节，而C定义一个int变量一般只需要4字节，
 * 所以能够用C/C++实现的功能，尽可能的用C/C++实现。目前，Swoole主要是用这种方式实现内置库。
 */
static void php_swoole_load_library()
{
    zend::eval(swoole_library_source_constants, "@swoole-src/library/constants.php");
    zend::eval(swoole_library_source_std_array, "@swoole-src/library/std/array.php");
    zend::eval(swoole_library_source_std_exec, "@swoole-src/library/std/exec.php");
    zend::eval(swoole_library_source_ext_curl, "@swoole-src/library/ext/curl.php");
    zend::eval(swoole_library_source_core_coroutine_wait_group, "@swoole-src/library/core/Coroutine/WaitGroup.php");
    zend::eval(swoole_library_source_core_coroutine_object_pool, "@swoole-src/library/core/Coroutine/ObjectPool.php");
    zend::eval(swoole_library_source_core_string_object, "@swoole-src/library/core/StringObject.php");
    zend::eval(swoole_library_source_core_array_object, "@swoole-src/library/core/ArrayObject.php");
    zend::eval(swoole_library_source_core_coroutine_server, "@swoole-src/library/core/Coroutine/Server.php");
    zend::eval(swoole_library_source_core_coroutine_server_connection, "@swoole-src/library/core/Coroutine/Server/Connection.php");
    zend::eval(swoole_library_source_functions, "@swoole-src/library/functions.php");
    zend::eval(swoole_library_source_alias, "@swoole-src/library/alias.php");
    zend::eval(swoole_library_source_alias_ns, "@swoole-src/library/alias_ns.php");
}

我已经给出了这个函数的注释了。其中zend::eval直接执行PHP代码。通过这种方式，Swoole让curl协程化了。

所以，这就是为什么我们只是查看一个简单脚本，就会打印出众多的opcode。因为在加载Swoole扩展的时候，默认会把swoole-src/library里面的PHP代码编译为opcode。

所以，我们这个时候可以这样来查看我们这个脚本的opcode：

1
2
3
4
5
6
7
8
9
10
11
12
13
~/codeDir/phpCode/test/swoole # phpdbg -np* test.php
function name: (null)
L1-9 {main}() /root/codeDir/phpCode/test/swoole/test.php - 0x7f517c681000 + 3 ops
 L3    #0     NOP                                                                                   
 L8    #1     ECHO                    "main"                                                        
 L9    #2     RETURN<-1>              1                                                             

function name: test
L3-6 test() /root/codeDir/phpCode/test/swoole/test.php - 0x7f517c67e060 + 2 ops
 L5    #0     ECHO                    "test"                                                        
 L6    #1     RETURN<-1>              null                                                          
[Script ended normally]
~/codeDir/phpCode/test/swoole #

多了一个-n参数，禁用默认的php.ini配置。

发表于
字数统计 867 字 | 阅读时长 4 分钟

这篇文章是讲解如何使用Swoole作为动态链接库，引入到我们自己的项目中。

编译Swoole为动态链接库的过程很简单，过程如下。

先下载一份Swoole源码，然后进入Swoole源码的根目录，然后开始进行编译过程。

1
2
3
4
5
6
~/codeDir/cppCode/swoole-src # phpize 
Configuring for:
PHP Api Version:         20180731
Zend Module Api No:      20180731
Zend Extension Api No:   320180731
~/codeDir/cppCode/swoole-src #
1
2
3
4
5
6
7
8
9
10
11
12
13
14
~/codeDir/cppCode/swoole-src # ./configure
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for a sed that does not truncate output... /bin/sed
checking for cc... cc
checking whether the C compiler works... yes
checking for C compiler default output file name... a.out

# 省略其他的输出内容

(cached) (cached) checking how to hardcode library paths into programs... immediate
configure: creating ./config.status
config.status: creating config.h
~/codeDir/cppCode/swoole-src #
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
~/codeDir/cppCode/swoole-src # cmake .
-- The C compiler identification is GNU 8.3.0
-- The CXX compiler identification is GNU 8.3.0
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- The ASM compiler identification is GNU
-- Found assembler: /usr/bin/cc
-- Configuring done
-- Generating done
-- Build files have been written to: /root/codeDir/cppCode/swoole-src
~/codeDir/cppCode/swoole-src #

然后安装Swoole为动态链接库：

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
~/codeDir/cppCode/swoole-src # make install
Scanning dependencies of target shared
[  1%] Building C object CMakeFiles/shared.dir/src/core/array.c.o
[  2%] Building C object CMakeFiles/shared.dir/src/core/base.c.o
[  3%] Building C object CMakeFiles/shared.dir/src/core/channel.c.o

# 省略其他的输出内容

[ 91%] Building CXX object CMakeFiles/shared.dir/src/wrapper/timer.cc.o
[ 92%] Linking CXX shared library lib/libswoole.so
[ 97%] Built target shared
Scanning dependencies of target test_server
[ 98%] Building C object CMakeFiles/test_server.dir/examples/test_server.c.o
[100%] Linking C executable bin/test_server
[100%] Built target test_server
Install the project...
-- Install configuration: "Debug"
Are you run command using root user?
-- Installing: /usr/local/lib/libswoole.so.4.4.1
-- Up-to-date: /usr/local/lib/libswoole.so
-- Up-to-date: /usr/local/include/swoole/array.h
-- Up-to-date: /usr/local/include/swoole/asm_context.h
-- Up-to-date: /usr/local/include/swoole/async.h

# 省略其他的输出内容

-- Up-to-date: /usr/local/include/swoole/wrapper/base.hpp
-- Up-to-date: /usr/local/include/swoole/wrapper/client.hpp
-- Up-to-date: /usr/local/include/swoole/wrapper/server.hpp
-- Up-to-date: /usr/local/include/swoole/swoole_config.h
-- Installing: /usr/local/include/swoole/config.h
~/codeDir/cppCode/swoole-src #

我们发现，我们编译出了一个动态链接库libswoole.so。现在，我们就可以使用Swoole实现的函数了并且里面有许多的数据结构可以被我们使用。

我们来进行测试：

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
#include <swoole/swoole.h>
#include <swoole/hashmap.h>

#include <iostream>

using namespace std;

int main(int argc, char const *argv[])
{
    char *ret;
    swHashMap *hm = swHashMap_new(16, NULL);
    swHashMap_add(hm, (char *) SW_STRL("key1"), (void *)"value1");
    swHashMap_add(hm, (char *) SW_STRL("key2"), (void *)"value2");
    swHashMap_add(hm, (char *) SW_STRL("key3"), (void *)"value3");
    swHashMap_add(hm, (char *) SW_STRL("key4"), (void *)"value4");
    swHashMap_add(hm, (char *) SW_STRL("key5"), (void *)"value5");

    ret = (char *)swHashMap_find(hm, (char *) SW_STRL("key1"));
    cout << ret << endl;

    ret = (char *)swHashMap_find(hm, (char *) SW_STRL("key2"));
    cout << ret << endl;

    ret = (char *)swHashMap_find(hm, (char *) SW_STRL("key3"));
    cout << ret << endl;

    ret = (char *)swHashMap_find(hm, (char *) SW_STRL("key4"));
    cout << ret << endl;

    ret = (char *)swHashMap_find(hm, (char *) SW_STRL("key5"));
    cout << ret << endl;

    swHashMap_update(hm, (char *) SW_STRL("key1"), (void *)"newvalue1");
    ret = (char *)swHashMap_find(hm, (char *) SW_STRL("key1"));
    cout << ret << endl;

    swHashMap_free(hm);
}

编译、执行：

1
2
3
4
5
6
7
8
~/codeDir/cppCode # g++ -D HAVE_CONFIG_H main.cpp -lswoole
~/codeDir/cppCode # ./a.out 
value1
value2
value3
value4
value5
newvalue1

成功。

有了这个基础，我们可以在我们的PHP协程扩展里面使用Swoole的基础数据结构，实现网络模块。

注意，我们这里不可以直接使用Swoole的定时器。因为Swoole的定时器用了全局变量SwooleG，所以我们需要自己去实现定时器。

发表于
字数统计 1k 字 | 阅读时长 5 分钟

前些日子，有人给Swoole提出了一个Issue，内容如下：

1
2
3
4
5
6
number of maximum connection we can use with swoole?

hello
i want to know how many is the maximum connection per second that swoole can support
we want use this framework for real-time game server and it is very important to know max number support connection/second for swoole framework.
thank you

峰哥回复如下：

1
2
3
4
5
6
It depends on the value of your system ulimit -n and your settings. The maximum limit is 1 million.

ulimit -n 100000
$server = new Swoole\Server;

$server->set(["max_connection" => 100000]);

说的是取决于我们设置的ulimit -n的值以及我们给server配置的值。我们来测试一下：

服务器代码：

1
2
3
4
5
6
7
8
9
10
<?php // co_long_tcp_server.php 

$serv = new Swoole\Server("0.0.0.0", 9501);

$serv->on('receive', function (Swoole\Server $serv, $fd, $from_id, $data)
{
    $serv->send($fd, $data . $data);
});

$serv->start();

我们启动服务器：

1
php co_long_tcp_server.php

然后，我们来看看我们的ulimit -n的值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
~/codeDir/phpCode/test/swoole # ulimit -a
-f: file size (blocks)             unlimited
-t: cpu time (seconds)             unlimited
-d: data seg size (kb)             unlimited
-s: stack size (kb)                8192
-c: core file size (blocks)        0
-m: resident set size (kb)         unlimited
-l: locked memory (kb)             82000
-p: processes                      unlimited
-n: file descriptors               1048576
-v: address space (kb)             unlimited
-w: locks                          unlimited
-e: scheduling priority            0
-r: real-time priority             0

我们发现，我们最大可以打开的文件个数是1048576。我们修改这个值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
~/codeDir/phpCode/test/swoole # ulimit -n 100
~/codeDir/phpCode/test/swoole # ulimit -a
-f: file size (blocks)             unlimited
-t: cpu time (seconds)             unlimited
-d: data seg size (kb)             unlimited
-s: stack size (kb)                8192
-c: core file size (blocks)        0
-m: resident set size (kb)         unlimited
-l: locked memory (kb)             82000
-p: processes                      unlimited
-n: file descriptors               100
-v: address space (kb)             unlimited
-w: locks                          unlimited
-e: scheduling priority            0
-r: real-time priority             0
~/codeDir/phpCode/test/swoole #

此时，我们最大可以打开的文件个数是100个。好的，我们来进行测试。我使用我正在贡献的一个压测脚本来进行测试：

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
~/codeDir/cppCode/swoole-src/benchmark # php co_run.php -s tcp://127.0.0.1 -c 100 
============================================================
Swoole Version          4.4.0-alpha
============================================================


Warning: Swoole\Coroutine\Client::connect(): new Socket() failed, Error: No file descriptors available[24] in /root/codeDir/cppCode/swoole-src/benchmark/co_run.php on line 249

Warning: Swoole\Coroutine\Client::connect(): new Socket() failed, Error: No file descriptors available[24] in /root/codeDir/cppCode/swoole-src/benchmark/co_run.php on line 249

Warning: Swoole\Coroutine\Client::connect(): new Socket() failed, Error: No file descriptors available[24] in /root/codeDir/cppCode/swoole-src/benchmark/co_run.php on line 249

Warning: Swoole\Coroutine\Client::connect(): new Socket() failed, Error: No file descriptors available[24] in /root/codeDir/cppCode/swoole-src/benchmark/co_run.php on line 249


Concurrency Level:      100
Time taken for tests:   0.7476 seconds
Complete requests:      10,000
Failed requests:        400
Connect failed:         0
Total send:             9,830,400 bytes
Total reveive:          19,660,800 bytes
Requests per second:    12841.091492777
Connection time:        0.0091 seconds

~/codeDir/cppCode/swoole-src/benchmark #

我们发现，此时报错了，说是没有可用的文件描述符。并且后面跟了一个错误码24，它对应如下含义：

1
Too many open files

为什么我们设置了最多打开100个文件，但是却无法维持100个客户端的连接呢？因为Swoole除了需要打开用于维持连接的套接字以外，还需要打开一些其他的文件，例如epoll fd等等。所以，我们设置ulimit -n为100不代表我们就可以维持100个连接。实际上要比100低。我们再次调低客户端连接的个数：

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
~/codeDir/cppCode/swoole-src/benchmark # php co_run.php -s tcp://127.0.0.1 -c 80 -v
============================================================
Swoole Version          4.4.0-alpha
============================================================

Completed 1000 requests
Completed 2000 requests
Completed 3000 requests
Completed 4000 requests
Completed 5000 requests
Completed 6000 requests
Completed 7000 requests
Completed 8000 requests
Completed 9000 requests
Completed 10000 requests


Concurrency Level:      80
Time taken for tests:   0.451 seconds
Complete requests:      10,000
Failed requests:        0
Connect failed:         0
Total send:             10,240,000 bytes
Total reveive:          20,480,000 bytes
Requests per second:    22172.949002217
Connection time:        0.0071 seconds

~/codeDir/cppCode/swoole-src/benchmark #

我们发现，维持80个连接是可以的。

好的，我们设置回ulimit -n的值之后，修改一下服务器脚本：

1
2
3
4
5
6
7
8
9
10
11
<?php

$serv = new Swoole\Server("0.0.0.0", 9501);
$serv->set(["max_connection" => 100]);

$serv->on('receive', function (Swoole\Server $serv, $fd, $from_id, $data)
{
    $serv->send($fd, $data . $data);
});

$serv->start();

设置最大连接为100。然后进行测试：

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
~/codeDir/cppCode/swoole-src/benchmark # php co_run.php -s tcp://127.0.0.1  -c 100 -v
============================================================
Swoole Version          4.4.0-alpha
============================================================

Completed 1000 requests
Completed 2000 requests
Completed 3000 requests
Completed 4000 requests
Completed 5000 requests
Completed 6000 requests
Completed 7000 requests
Completed 8000 requests
Completed 9000 requests
Completed 10000 requests


Concurrency Level:      100
Time taken for tests:   0.5277 seconds
Complete requests:      10,000
Failed requests:        0
Connect failed:         0
Total send:             10,240,000 bytes
Total reveive:          20,480,000 bytes
Requests per second:    18950.161076369
Connection time:        0.0105 seconds

~/codeDir/cppCode/swoole-src/benchmark #

发现，维持100个连接是没问题的。

发表于
字数统计 1.3k 字 | 阅读时长 6 分钟

最近项目要用Go写。受Laravel的启发，想找一个Go语言的数据库版本迁移工具，然后就找到了一个大家用的比较多的工具：migrate。因为官方文档以及网上资源太少，所以这里写一篇文章记录下。

（安装这个工具的方法省略）

我们创建一个目录migrations，里面存放我们需要迁移的对象。

然后，创建迁移文件：

1
migrate create -ext sql -dir migrations create_users_table

执行这条命令会创建两个文件，分别是：

1
2
~/codeDir/golangCode/echo-demo # ls migrations/
20190617061102_create_users_table.down.sql  20190617061102_create_users_table.up.sql

20190617061102是和时间有关的一个标识，用来区分我们的migration的版本。

这两个文件都是空的，需要我们自己去填充。很明显，这是两个相反的sql操作。

我们在20190617061102_create_users_table.up.sql中写入创建users表的操作：

1
2
3
4
5
6
CREATE TABLE IF NOT EXISTS users(
   id INT,
   name VARCHAR(100) NOT NULL,
   password VARCHAR(40) NOT NULL,
   PRIMARY KEY ( id )
);

对应的我们就需要在20190617061102_create_users_table.down.sql中删除这张表：

1
DROP table IF EXISTS users;

然后，我们在终端执行命令：

1
migrate -verbose -source file://migrations -database postgres://postgres:postgres用户的密码@host.docker.internal:5432/postgres?sslmode=disable up 1

结果如下：

1
2
3
4
5
6
7
~/codeDir/golangCode/echo-demo # migrate -verbose -source file://migrations -database postgres://postgres:postgres用户的密码@host.docker.internal:5432/postgres?sslmode=disable up 1
2019/06/17 06:17:20 Start buffering 20190617061102/u create_users_table
2019/06/17 06:17:20 Read and execute 20190617061102/u create_users_table
2019/06/17 06:17:20 Finished 20190617061102/u create_users_table (read 11.0414ms, ran 12.0132ms)
2019/06/17 06:17:20 Finished after 28.7139ms
2019/06/17 06:17:20 Closing source and database
~/codeDir/golangCode/echo-demo #

此时，我们看看数据库的表：

1
2
3
4
5
6
7
8
9
postgres=# \dt
               List of relations
 Schema |       Name        | Type  |  Owner   
--------+-------------------+-------+----------
 public | schema_migrations | table | postgres
 public | users             | table | postgres
(2 rows)

postgres=#

发现，此时有两张表，分别是schema_migrations以及我们创建的users。其中，schema_migrations里面存放的是当前migration的版本以及状态。

我们来看看：

1
2
3
4
5
6
7
postgres=# select * from schema_migrations;
    version     | dirty 
----------------+-------
 20190617061102 | f
(1 row)

postgres=#

此时，migration的版本是20190617061102，这个就是我们文件的前缀。dirty代表当前版本是干净的还是脏的。f表示干净（即没有出问题）。

然后，我来演示一下migrate失败的操作。

我们再创建一个migration文件：

1
migrate create -ext sql -dir migrations create_emails_table
1
2
3
~/codeDir/golangCode/echo-demo # ls migrations/
20190617061102_create_users_table.down.sql   20190617061102_create_users_table.up.sql     20190617062220_create_emails_table.down.sql  20190617062220_create_emails_table.up.sql
~/codeDir/golangCode/echo-demo #

然后，在up的那个文件里面写下：

1
2
3
4
5
CREATE TABLE IF NOT EXISTS emails(
   id error INT,
   account VARCHAR(100) NOT NULL,
   PRIMARY KEY ( id )
);

（我们在id的那一行故意写错了，加了一个会导致报错的字符串error）

在down的那个文件里面写下：

1
DROP table IF EXISTS emails;

然后，执行迁移操作：

1
2
3
4
5
6
7
8
9
~/codeDir/golangCode/echo-demo # migrate -verbose -source file://migrations -database postgres://postgres:postgres用户的密码@host.docker.internal:5432/postgres?sslmode=disable up 1
2019/06/17 06:24:49 Start buffering 20190617062220/u create_emails_table
2019/06/17 06:24:49 Read and execute 20190617062220/u create_emails_table
2019/06/17 06:24:49 error: migration failed: syntax error at or near "INT" (column 13) in line 2: CREATE TABLE IF NOT EXISTS emails(
   id error INT,
   account VARCHAR(100) NOT NULL,
   PRIMARY KEY ( id )
); (details: pq: syntax error at or near "INT")
~/codeDir/golangCode/echo-demo #

完美报错。

此时，我们把error这个字符串删除：

1
2
3
4
5
CREATE TABLE IF NOT EXISTS emails(
   id INT,
   account VARCHAR(100) NOT NULL,
   PRIMARY KEY ( id )
);

然后再执行迁移操作：

1
2
3
~/codeDir/golangCode/echo-demo # migrate -verbose -source file://migrations -database postgres://postgres:postgres用户的密码@host.docker.internal:5432/postgres?sslmode=disable up 1
2019/06/17 06:26:36 error: Dirty database version 20190617062220. Fix and force version.
~/codeDir/golangCode/echo-demo #

（开始的时候，我是吃惊的，因为我按照Laravel migrate的思路，不应该会报错）

报错提示说database version是脏的。所以，我们看看schema_migrations表的内容：

1
2
3
4
5
6
7
postgres=# select * from schema_migrations;
    version     | dirty 
----------------+-------
 20190617062220 | t
(1 row)

postgres=#

我们发现，尽管migrate up失败了，但是这里还是会up这个version。这是我用不习惯的一个地方。

此时，我们需要按照报错的提示：

1
Fix and force version.

我们已经把error字符串删除了，所以此时我们只需要force version一下：

1
2
3
~/codeDir/golangCode/echo-demo # migrate -verbose -source file://migrations -database postgres://postgres:postgres用户的密码@host.docker.internal:5432/postgres?sslmode=disable force 20190617062220
2019/06/17 06:32:30 Finished after 18.7548ms
2019/06/17 06:32:30 Closing source and database

force后面带上dirty的那个版本。

此时，我们再看看schema_migrations表的内容：

1
2
3
4
5
6
7
postgres=# select * from schema_migrations;
    version     | dirty 
----------------+-------
 20190617062220 | f
(1 row)

postgres=#

dirty已经是f了，代表这是干净的了。

然后，我们再回退到上一个版本：

1
2
3
4
5
6
7
~/codeDir/golangCode/echo-demo # migrate -verbose -source file://migrations -database postgres://postgres:postgres用户的密码@host.docker.internal:5432/postgres?sslmode=disable down 1
2019/06/17 06:34:04 Start buffering 20190617062220/d create_emails_table
2019/06/17 06:34:04 Read and execute 20190617062220/d create_emails_table
2019/06/17 06:34:04 Finished 20190617062220/d create_emails_table (read 13.2303ms, ran 10.691ms)
2019/06/17 06:34:04 Finished after 30.1489ms
2019/06/17 06:34:04 Closing source and database
~/codeDir/golangCode/echo-demo #

回退成功：

1
2
3
4
5
6
7
postgres=# select * from schema_migrations;
    version     | dirty 
----------------+-------
 20190617061102 | f
(1 row)

postgres=#

然后，我们现在可以正常的执行up操作了：

1
2
3
4
5
6
7
~/codeDir/golangCode/echo-demo # migrate -verbose -source file://migrations -database postgres://postgres:postgres用户的密码@host.docker.internal:5432/postgres?sslmode=disable up 1
2019/06/17 06:35:15 Start buffering 20190617062220/u create_emails_table
2019/06/17 06:35:15 Read and execute 20190617062220/u create_emails_table
2019/06/17 06:35:15 Finished 20190617062220/u create_emails_table (read 12.715ms, ran 16.2358ms)
2019/06/17 06:35:15 Finished after 34.5774ms
2019/06/17 06:35:15 Closing source and database
~/codeDir/golangCode/echo-demo #
1
2
3
4
5
6
7
8
9
10
postgres=# \dt
               List of relations
 Schema |       Name        | Type  |  Owner   
--------+-------------------+-------+----------
 public | emails            | table | postgres
 public | schema_migrations | table | postgres
 public | users             | table | postgres
(3 rows)

postgres=#

emails表创建完成。

（感觉还是不如Laravel的migrate好用）