PHP

事务嵌套解决方案

2016年2月29日 chen

mysql官方并不支持事务嵌套，当第二个事务开始时候，会隐式的先调用commit提交之前的事务，而后在开启第二次的事务。

在正常开发中难免会出现失误嵌套的情况。如何解决呢？

laravel/lumen框架使用了mysql的SAVEPOINT方法来解决这一问题。

mysql savepoint

首先来看下mysql原生案例。

# 表结构
+----------+------------------+------+-----+---------+----------------+
| Field    | Type             | Null | Key | Default | Extra          |
+----------+------------------+------+-----+---------+----------------+
| id       | int(10) unsigned | NO   | PRI | NULL    | auto_increment |
| username | varchar(32)      | NO   |     | NULL    |                |
| password | varchar(32)      | NO   |     | NULL    |                |
+----------+------------------+------+-----+---------+----------------+

# 表结构

+----------+------------------+------+-----+---------+----------------+

+----------+------------------+------+-----+---------+----------------+

| id | int(10) unsigned | NO | PRI | NULL | auto_increment |

+----------+------------------+------+-----+---------+----------------+

2次开启事务案例

# 操作
mysql> begin;       # 开启事务
Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('ff', 'ff');
Query OK, 1 row affected (0.00 sec)

mysql> begin;       # 此处mysql会先提交前一个事务，再开启后一个事务。
Query OK, 0 rows affected (0.01 sec)

mysql> insert into user(username, password) values('ee', 'ee');
Query OK, 1 row affected (0.00 sec)

mysql> rollback;    # 事务回滚，把username=ee回滚掉了，而ff已插入数据库。
Query OK, 0 rows affected (0.00 sec)

# 操作

mysql> begin; # 开启事务

Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('ff', 'ff');

Query OK, 1 row affected (0.00 sec)

mysql> begin; # 此处mysql会先提交前一个事务，再开启后一个事务。

Query OK, 0 rows affected (0.01 sec)

mysql> insert into user(username, password) values('ee', 'ee');

Query OK, 1 row affected (0.00 sec)

mysql> rollback; # 事务回滚，把username=ee回滚掉了，而ff已插入数据库。

Query OK, 0 rows affected (0.00 sec)

savepoint 案例

mysql> begin;                   # 开启事务
Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('ff', 'ff');
Query OK, 1 row affected (0.00 sec)

mysql> SAVEPOINT trans_1;       # 创建回滚点trans_1
Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('ee', 'ee');
Query OK, 1 row affected (0.00 sec)

mysql> SAVEPOINT trans_2;       # 创建回滚点trans_2
Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('gg', 'gg');
Query OK, 1 row affected (0.00 sec)

mysql> ROLLBACK TO SAVEPOINT trans_2;   # 回滚到trans_2，将username=gg回滚掉了
Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('hh', 'hh');
Query OK, 1 row affected (0.00 sec)

mysql> commit;                  # 提交数据
Query OK, 0 rows affected (0.00 sec)

mysql> begin; # 开启事务

Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('ff', 'ff');

Query OK, 1 row affected (0.00 sec)

mysql> SAVEPOINT trans_1; # 创建回滚点trans_1

Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('ee', 'ee');

Query OK, 1 row affected (0.00 sec)

mysql> SAVEPOINT trans_2; # 创建回滚点trans_2

Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('gg', 'gg');

Query OK, 1 row affected (0.00 sec)

mysql> ROLLBACK TO SAVEPOINT trans_2; # 回滚到trans_2，将username=gg回滚掉了

Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('hh', 'hh');

Query OK, 1 row affected (0.00 sec)

mysql> commit; # 提交数据

Query OK, 0 rows affected (0.00 sec)

上面例子中username=gg被回滚掉了，最终数据库中插入了username=ee,ff,hh。如果最后commit换成rollback所有数据将全部回滚。

laravel/lumen 实现

    /**
     * Start a new database transaction.
     *
     * @return void
     */
    public function beginTransaction()
    {
        ++$this->transactions;

        if ($this->transactions == 1) {
            $this->getPdo()->beginTransaction();
        } elseif ($this->transactions > 1 && $this->queryGrammar->supportsSavepoints()) {
            $this->getPdo()->exec(
                $this->queryGrammar->compileSavepoint('trans'.$this->transactions)
            );
        }

        $this->fireConnectionEvent('beganTransaction');
    }

/**

* Start a new database transaction.

* @return void

public function beginTransaction()

{

++$this->transactions;

if ($this->transactions == 1) {

$this->getPdo()->beginTransaction();

} elseif ($this->transactions > 1 && $this->queryGrammar->supportsSavepoints()) {

$this->getPdo()->exec(

$this->queryGrammar->compileSavepoint('trans'.$this->transactions)

);

}

$this->fireConnectionEvent('beganTransaction');

}

开启事务时检测当前transactions等级，如果等于1开启事务，如果大于1则创建相应level的savepoint。

    /**
     * Commit the active database transaction.
     *
     * @return void
     */
    public function commit()
    {
        if ($this->transactions == 1) {
            $this->getPdo()->commit();
        }

        --$this->transactions;

        $this->fireConnectionEvent('committed');
    }

/**

* Commit the active database transaction.

* @return void

public function commit()

{

if ($this->transactions == 1) {

$this->getPdo()->commit();

}

--$this->transactions;

$this->fireConnectionEvent('committed');

}

commit操作时候，检测当前transactions等级，如果不等于1跳过操作，并且transactions等级减1。如果等于1，事务提交。

    /**
     * Rollback the active database transaction.
     *
     * @return void
     */
    public function rollBack()
    {
        if ($this->transactions == 1) {
            $this->getPdo()->rollBack();
        } elseif ($this->transactions > 1 && $this->queryGrammar->supportsSavepoints()) {
            $this->getPdo()->exec(
                $this->queryGrammar->compileSavepointRollBack('trans'.$this->transactions)
            );
        }

        $this->transactions = max(0, $this->transactions - 1);

        $this->fireConnectionEvent('rollingBack');
    }

/**

* Rollback the active database transaction.

* @return void

public function rollBack()

{

if ($this->transactions == 1) {

$this->getPdo()->rollBack();

} elseif ($this->transactions > 1 && $this->queryGrammar->supportsSavepoints()) {

$this->getPdo()->exec(

$this->queryGrammar->compileSavepointRollBack('trans'.$this->transactions)

);

}

$this->transactions = max(0, $this->transactions - 1);

$this->fireConnectionEvent('rollingBack');

}

而rollback操作，检测当前transactions等级，如果不等于1回滚到相应等级的savepoint，等于1这全部回滚。

PHP

Functional Programming

2016年2月20日 chen

函数式编程是什么
函数式编程的特点
函数式编程的意义
函数式编程的几个技术

一、函数式编程是什么？

函数式编程就是编写纯函数，尽可能移除隐含的输入与输出，这样我们的代码就是仅描述输入与输出之间关系的代码。

1、纯函数

Q: 什么是纯函数？
A: 该函数所有的输入都是显示的（无隐含输入），同样它的所有输出都是显示输出。

让我们来看2个例子：

# 示例1
# 设定参数int类型和返回值类型为php7特性
function square(int $x) : int {
    return $x * $x;
}

# 示例1

# 设定参数int类型和返回值类型为php7特性

function square(int $x) : int {

return $x * $x;

}

# 示例2
function processNext() {
    $message = Queue::pop();

    if ($message != null) {
        process($message);
    }
}

# 示例2

function processNext() {

$message = Queue::pop();

if ($message != null) {

process($message);

}

示例1我们可以清晰的知道输入的是一个int类型，输出的也是一个int类型。对于这种我们称之为纯函数。
而示例2这个函数既没有输入也没有输出，然而很明显它依赖着什么，并且很显然也在做着什么。但是我们不知道。对于这种我们称之为不纯函数。

为什么我们要写纯函数呢？因为不纯函数有很多副作用。详情可参考：
【译】什么是函数式编程？

二、函数式编程的特点

1、函数是”第一等公民”

所谓”第一等公民”（first class），指的是函数与其他数据类型一样，处于平等地位，可以赋值给其他变量，也可以作为参数，传入另一个函数，或者作为别的函数的返回值。

举例来说，下面代码中的$print变量就是一个函数，可以作为另一个函数的参数。

$print = function($i) {
    print_r($i);
};

$arr = [1,2,3];

array_map($print, $arr);
// 123

$print = function($i) {

print_r($i);

};

$arr = [1,2,3];

array_map($print, $arr);

// 123

2、没有”副作用”

所谓”副作用”（side effect），指的是函数内部与外部互动（最典型的情况，就是修改全局变量的值），产生运算以外的其他结果。
函数式编程强调没有”副作用”，意味着函数要保持独立，所有功能就是返回一个新的值，没有其他行为，尤其是不得修改外部变量的值。

3、不修改状态

上一点已经提到，函数式编程只是返回新的值，不修改系统变量。因此，不修改变量，也是它的一个重要特点。
在其他类型的语言中，变量往往用来保存”状态”（state）。不修改变量，意味着状态不能保存在变量中。函数式编程使用参数保存状态，最好的例子就是递归。下面的代码是一个将字符串逆序排列的函数，它演示了不同的参数如何决定了运算所处的”状态”。

4、引用透明

引用透明（Referential transparency），指的是函数的运行不依赖于外部变量或”状态”，只依赖于输入的参数，任何时候只要参数相同，引用函数所得到的返回值总是相同的。
有了前面的第三点和第四点，这点是很显然的。其他类型的语言，函数的返回值往往与系统状态有关，不同的状态之下，返回值是不一样的。这就叫”引用不透明”，很不利于观察和理解程序的行为。

三、函数式编程的意义

简单的说函数式编程有什么好处，我们为什么要去掌握它。

1、代码简洁，开发快速

函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。

2、接近自然语言，易于理解

函数式编程的自由度很高，可以写出很接近自然语言的代码。
用户函数式语言表达(1 + 2) * 3 - 4：

　　subtract(multiply(add(1,2), 3), 4);

1 2	subtract(multiply(add(1,2), 3), 4);

对它进行变形，不难得到另一种写法：

　　$obj -> add(1,2) -> multiply(3) -> subtract(4);

1 2	$obj -> add(1,2) -> multiply(3) -> subtract(4);

3、更方便的代码管理

函数式编程不依赖、也不会改变外界的状态，只要给定输入参数，返回的结果必定相同。因此，每一个函数都可以被看做独立单元，很有利于进行单元测试（unit testing）和除错（debugging），以及模块化组合。

4、易于”并发编程”

函数式编程不需要考虑”死锁”（deadlock），因为它不修改变量，所以根本不存在”锁”线程的问题。不必担心一个线程的数据，被另一个线程修改，所以可以很放心地把工作分摊到多个线程，部署”并发编程”（concurrency）。

四、函数式编程的几个技术

1、 map、 reduce & filte

函数式编程中，我们不应该用循环迭代的方式，我们应该用更为高级的方法。

# 循环
$len = function($str) {
    return strlen($str);
};
$strings = [
    'hello', 'world', 'functional'
];

$lens = array_map($len, $strings);

print_r($lens);
/*
Array
(
    [0] => 5
    [1] => 5
    [2] => 10
)
*/

# 循环

$len = function($str) {

return strlen($str);

};

$strings = [

'hello', 'world', 'functional'

];

$lens = array_map($len, $strings);

print_r($lens);

Array

(

[0] => 5

[1] => 5

[2] => 10

)

这样的代码很易读，因为，这样的代码是在描述要干什么，而不是怎么干。

# 过滤
$filter = function($int) {
    return($int & 1);
};

$nums = [1,2,3,4,5,6,7,8,9];

$odd = array_filter($nums, $filter);

print_r($odd);
/*
Array
(
    [0] => 1
    [2] => 3
    [4] => 5
    [6] => 7
    [8] => 9
)
*/

# 过滤

$filter = function($int) {

return($int & 1);

};

$nums = [1,2,3,4,5,6,7,8,9];

$odd = array_filter($nums, $filter);

print_r($odd);

Array

(

[0] => 1

[2] => 3

[4] => 5

[6] => 7

[8] => 9

)

$reduceToTable = function($html, $p) {
   $html .= "<TR><TD><a href=\"$p.html\">$p</a></td></tr>\n";
   return $html;
};

$list = ["page1", "page2", "page3"];

$table = array_reduce($list, $reduceToTable);
echo "<table>\n".$table . "</table>\n";

/*
<table>
<TR><TD><a href="page1.html">page1</a></td></tr>
<TR><TD><a href="page2.html">page2</a></td></tr>
<TR><TD><a href="page3.html">page3</a></td></tr>
</table>
*/

$reduceToTable = function($html, $p) {

$html .= "<TR><TD><a href=\"$p.html\">$p</a></td></tr>\n";

return $html;

};

$list = ["page1", "page2", "page3"];

$table = array_reduce($list, $reduceToTable);

echo "<table>\n".$table . "</table>\n";

<table>

</table>

2、 pipeline

详情参考我的另外一篇博客：pipeline

3、 recursing 递归

递归最大的好处就简化代码，他可以把一个复杂的问题用很简单的代码描述出来。注意：递归的精髓是描述问题，而这正是函数式编程的精髓。

通常递归的效率低下，内存占用量比较大，这是它长期不能在业界推广的主要原因。

所以这里推荐使用尾递归。

递归和尾递归有何区别？

以斐波那契数列为例：

/**
 * 递归
 */
function f1($a) {
    if ($a <= 1) {
        return 1 ;
    }
    else {
        return f1($a - 1) + f1($a - 2);
    }
}

/**
 * 尾递归
 */
function f2($a, $b, $n) {
    if ($n == 0) {
        return $a;
    } else {
        return f2($b, $a + $b, $n - 1);
    }
}

/**

* 递归

function f1($a) {

if ($a <= 1) {

return 1 ;

}

else {

return f1($a - 1) + f1($a - 2);

}

/**

* 尾递归

function f2($a, $b, $n) {

if ($n == 0) {

return $a;

} else {

return f2($b, $a + $b, $n - 1);

}

初看一下没有看出什么太大区别。但是执行效率却是天差地别。

递归函数在return的时候进行了计算f1($a - 1) + f1($a - 2)。这个时候计算机底层就会创建stack累积而后计算

f1(4);
return f1(3) + f1(2);
return f1(2) + f1(1) + f1(2);
return f1(1) + f1(0) + f1(1) + f1(2);
return 1 + 1 + 1 + f1(2);
return 1 + 1 + 1 + f1(1) + f1(0);
return 1 + 1 + 1 + 1 + 1;
5;

f1(4);

return f1(3) + f1(2);

return f1(2) + f1(1) + f1(2);

return f1(1) + f1(0) + f1(1) + f1(2);

return 1 + 1 + 1 + f1(2);

return 1 + 1 + 1 + f1(1) + f1(0);

return 1 + 1 + 1 + 1 + 1;

这个曲线就代表内存占用大小的峰值，从左到右，达到顶峰，再从右到左收缩。

而尾递归不会如此耗内存。

f2(1, 1, 4);
return f2(1, 2, 3);
return f2(2, 3, 2);
return f2(3, 5, 1);
return f2(5, 8, 0);
return $a;
5;

f2(1, 1, 4);

return f2(1, 2, 3);

return f2(2, 3, 2);

return f2(3, 5, 1);

return f2(5, 8, 0);

return $a;

他的内存比较平稳。

下面是一个f1和f2以及循环测试，展示他们各自的使用时间，可以看出他们之间的巨大差别。

            时间  
f1(33)      3.05s
f2(33)      0.00015s
for(33)     0.00011s

时间

f1(33) 3.05s

f2(33) 0.00015s

for(33) 0.00011s

4、 currying 柯里化

写一个数组连接成字符串的函数

$concatArray = function($arr) {
    return array_reduce($arr, function($result, $input) {
        return $result . $input;
    });
};
echo $concatArray([1,2,3]), "\n"; // 123

$concatArray = function($arr) {

return array_reduce($arr, function($result, $input) {

return $result . $input;

});

};

echo $concatArray([1,2,3]), "\n"; // 123

现在我要其中所有数字加1, 然后在连接

$concatArray = function($arr, $plus) {
    $arr = array_map(function($i) use($plus) {
        return $i + $plus;
    }, $arr);
    return array_reduce($arr, function($result, $input) {
        return $result . $input;
    });
};

echo $concatArray([1,2,3], 1), "\n"; // 234

$concatArray = function($arr, $plus) {

$arr = array_map(function($i) use($plus) {

return $i + $plus;

}, $arr);

return array_reduce($arr, function($result, $input) {

return $result . $input;

});

};

echo $concatArray([1,2,3], 1), "\n"; // 234

然后结果所有数字乘以2, 再进行连接

$concatArray = function($arr, $plus, $multiple) {
    $arr = array_map(function($i) use ($plus) {
        return $i + $plus;
    }, $arr);
    $arr = array_map(function($i) use ($multiple) {
        return $i * $multiple;
    }, $arr);
    return array_reduce($arr, function($result, $input) {
        return $result . $input;
    });
};

echo $concatArray([1,2,3], 1, 2), "\n"; // 468

$concatArray = function($arr, $plus, $multiple) {

$arr = array_map(function($i) use ($plus) {

return $i + $plus;

}, $arr);

$arr = array_map(function($i) use ($multiple) {

return $i * $multiple;

}, $arr);

return array_reduce($arr, function($result, $input) {

return $result . $input;

});

};

echo $concatArray([1,2,3], 1, 2), "\n"; // 468

是不是觉得很烦了？
如果需要再添加一个功能，是不是又要添加一个参数了？
是不是违背了函数式编程简洁、接近人类语言的好处了？

这个使用就需要用到柯里化了。

什么是柯里化?

柯里化是这样的一个转换过程，把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，如果其他的参数是必要的，返回接受余下的参数且返回结果的新函数。

$concatArray = function($arr, $funcs) {
    $arr = array_reduce($funcs, function($result, $input) {
        return array_map($input, $result);
    }, $arr);
    return array_reduce($arr, function($result, $input) {
        return $result . $input;
    });
};

$plus = function($num) {
    return function($a) use ($num) {
        return $a + $num;
    };
};

$multiple = function($num) {
    return function($a) use ($num) {
        return $a * $num;
    };
}; 

$arr = [1,2,3];

echo $concatArray($arr, [$plus(1), $multiple(2)]), "\n";

$concatArray = function($arr, $funcs) {

$arr = array_reduce($funcs, function($result, $input) {

return array_map($input, $result);

}, $arr);

return array_reduce($arr, function($result, $input) {

return $result . $input;

});

};

$plus = function($num) {

return function($a) use ($num) {

return $a + $num;

};

$multiple = function($num) {

return function($a) use ($num) {

return $a * $num;

};

$arr = [1,2,3];

echo $concatArray($arr, [$plus(1), $multiple(2)]), "\n";

这里有人就会说了，柯里化不是到最后变换成接受一个单一参数的函数吗？这里为什么还有2个参数？

其实如果将其转换为没想对象的来看他就是接收了一个参数：

$arrayObject -> concatArray([$plus(1), $multiple(2)]);

1 2	$arrayObject -> concatArray([$plus(1), $multiple(2)]);

当然还有其他非柯里化方式可以来实现简化如下：

$concatArray = function($arr) {
    return array_reduce($arr, function($result, $input) {
        return $result . $input;
    });
};

$plus = function($arr, $num) {
    return array_map(function($i) use($num) {
        return $i + $num;
    }, $arr);
};

$multiple = function($arr, $num) {
    return array_map(function($i) use($num) {
        return $i * $num;
    }, $arr);
}; 

$arr = [1,2,3];
echo $concatArray($multiple($plus($arr, 1), 2)), "\n"; // 468

$concatArray = function($arr) {

return array_reduce($arr, function($result, $input) {

return $result . $input;

});

};

$plus = function($arr, $num) {

return array_map(function($i) use($num) {

return $i + $num;

}, $arr);

};

$multiple = function($arr, $num) {

return array_map(function($i) use($num) {

return $i * $num;

}, $arr);

};

$arr = [1,2,3];

echo $concatArray($multiple($plus($arr, 1), 2)), "\n"; // 468

5、 higher order function 高阶函数

所谓高阶函数就是函数当参数，把传入的函数做一个封装，然后返回这个封装函数。现象上就是函数传进传出，就像面向对象对象满天飞一样。

6、 lazy evaluation 惰性求值

柯里化中我们的案例就又到了惰性求值。

7、 determinism 确定性

确定性就是只要输入参数一致，输出结果就是一致的。就像数学那样 f(x) = y ，这个函数无论在什么场景下，都会得到同样的结果。

参考以及转载自：
【译】什么是函数式编程？
阮一峰：函数式编程初探
 左耳朵耗子：函数式编程
 为什么要柯里化

PHP

swoole入门 —— C/S架构

2016年2月14日 chen

一、什么是swoole

官方定义：特别霸气。
Swoole：重新定义PHP

官方介绍：

PHP语言的异步、并行、高性能网络通信框架，使用纯C语言编写，提供了PHP语言的异步多线程服务器，异步TCP/UDP网络客户端，异步MySQL，数据库连接池，AsyncTask，消息队列，毫秒定时器，异步文件读写，异步DNS查询。

它让PHP能够做出了WEB以外的更多事。

二、安装

swoole是一个php扩展。安装方式与其他扩展一样。

也可以用pecl进行安装：

pecl install swoole

1 2	pecl install swoole

三、Client-Server 架构

3.1、同步模型

同步模型类似nginx+php-fpm组合。

编写服务端代码：
主要作用：常驻运行服务，接收信息，然后添加上Swoole: 进行返回。

# server.php 
$serv = new swoole_server("127.0.0.1", 9501);
$serv->set(array(
    'worker_num' => 8,   //工作进程数量
    'daemonize' => true, //是否作为守护进程
));
$serv->on('connect', function ($serv, $fd){
    echo "Client:Connect.\n";
});
$serv->on('receive', function ($serv, $fd, $from_id, $data) {
    $serv->send($fd, 'Swoole: '.$data);
    $serv->close($fd);
});
$serv->on('close', function ($serv, $fd) {
    echo "Client: Close.\n";
});
$serv->start();

# server.php

$serv = new swoole_server("127.0.0.1", 9501);

$serv->set(array(

'worker_num' => 8, //工作进程数量

'daemonize' => true, //是否作为守护进程

));

$serv->on('connect', function ($serv, $fd){

echo "Client:Connect.\n";

});

$serv->on('receive', function ($serv, $fd, $from_id, $data) {

$serv->send($fd, 'Swoole: '.$data);

$serv->close($fd);

});

$serv->on('close', function ($serv, $fd) {

echo "Client: Close.\n";

});

$serv->start();

然后运行它，因为我们启用了'daemonize' => true选项，所以他将会变成一个守护进程。

php server.php

1 2	php server.php

再编写一个同步客户端：

# sync_client.php
$client = new swoole_client(SWOOLE_SOCK_TCP);
//设置事件回调函数
$client->on("connect", function($cli) {});
$client->on("receive", function($cli, $data){});
$client->on("error", function($cli){});
$client->on("close", function($cli){});
//发起网络连接
$client->connect('127.0.0.1', 9501, 0.5);

$client->send('hello world!!!');
echo $client->recv();

# sync_client.php

$client = new swoole_client(SWOOLE_SOCK_TCP);

//设置事件回调函数

$client->on("connect", function($cli) {});

$client->on("receive", function($cli, $data){});

$client->on("error", function($cli){});

$client->on("close", function($cli){});

//发起网络连接

$client->connect('127.0.0.1', 9501, 0.5);

$client->send('hello world!!!');

echo $client->recv();

运行客户端：
发送hello world!!!信息，并且接收到了Swoole: hello world!!!返回信息。

php sync_client.php 
// Swoole: hello world!!!

php sync_client.php

// Swoole: hello world!!!

3.2、异步模型

服务端不去动它。

编写异步客户端：

# async_client.php
$client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);
//设置事件回调函数
$client->on("connect", function($cli) {
    $cli->send("hello world");
});
$client->on("receive", function($cli, $data){
    echo "Received: ".$data."\n";
});
$client->on("error", function($cli){});
$client->on("close", function($cli){});
//发起网络连接
$client->connect('127.0.0.1', 9501, 0.5);

# async_client.php

$client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);

//设置事件回调函数

$client->on("connect", function($cli) {

$cli->send("hello world");

});

$client->on("receive", function($cli, $data){

echo "Received: ".$data."\n";

});

$client->on("error", function($cli){});

$client->on("close", function($cli){});

//发起网络连接

$client->connect('127.0.0.1', 9501, 0.5);

与同步相比写法上主要区别是：

1、创建swoole_client对象时，需要指明SWOOLE_SOCK_ASYNC异步。
2、异步操作，connect连接时，并不会立即连接上。所以需要将发送和接收请求写在回掉函数内。

运行客户端：

php async_client.php 
// Received: Swoole: hello world

php async_client.php

// Received: Swoole: hello world

3.3、将同步异步化

swoole的另外一个特性Eventloop。可以将各种fd添加到swoole的事件循环中，将同步的IO异步化。

另外结合promise和fifo，进行数据传输。可以达到同时请求N个数据源，同时获取数据的作用。

# sync_to_async_client.php
require_once "vendor/autoload.php";


class SyncClient 
{
    protected $deferred;

    protected $client;

    protected $data = [];

    public function __construct() {
        $this -> deferred = new React\Promise\Deferred();
        $this -> client = new swoole_client(SWOOLE_SOCK_TCP);
        $this -> client ->on("connect", function($cli) {});
        $this -> client ->on("receive", function($cli, $data){});
        $this -> client ->on("error", function($cli){});
        $this -> client ->on("close", function($cli){});
        $this -> client -> connect('127.0.0.1', 9501, 5);
    }

    public function setTask($data) {
        $this -> data = $data;
        return $this -> deferred -> promise();
    }

    public function todo() {
        $data = is_array($this -> data) ? json_encode($this -> data) : $this -> data;
        $this -> data = [];
        $this -> client -> send($data);
        $deferred = $this -> deferred;
        $client = $this -> client;
        swoole_event_add($this->client->sock, function($fp) use($client, $deferred){
            $str = $client -> recv();
            swoole_event_del($fp);
            $deferred -> resolve($str);
        });
    }
}

function task($i, $fifo) {
    $syncClient = new SyncClient();
    $promise = $syncClient -> setTask([
        'func' => 'Module.Class.Method',
        'params' => [
            'hello' => 'world',
            'i' => $i,
        ]
    ]);

    $promise -> then(function($data) use($fifo) {
        $fifo -> write($data);
    });

    return $syncClient -> todo();
}

$protocol = new Pangou\Fifo\Protocol\LengthProtocol();
$write = new Pangou\Fifo\Fifo($protocol, '/tmp/serv.fifo', '0666', false);
$read = new Pangou\Fifo\Fifo($protocol, '/tmp/serv.fifo', '0666', true);

for ($i = 0; $i < 20; $i++) {
    task($i, $write);
}

swoole_event_wait();

$data = [];

for ($i = 0; $i < 20; $i++) {
    $data[] = $read -> read();
}

print_r($data);
/*
Array
(
    [0] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":0}}
    [1] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":1}}
    [2] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":2}}
    [3] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":3}}
    [4] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":4}}
    [5] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":5}}
    [6] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":6}}
    [7] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":7}}
    [8] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":8}}
    [9] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":9}}
    [10] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":10}}
    [11] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":11}}
    [12] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":12}}
    [13] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":13}}
    [14] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":14}}
    [15] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":15}}
    [16] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":16}}
    [17] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":17}}
    [18] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":18}}
    [19] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":19}}
)
*/

100

101

# sync_to_async_client.php

require_once "vendor/autoload.php";

class SyncClient

{

protected $deferred;

protected $client;

protected $data = [];

public function __construct() {

$this -> deferred = new React\Promise\Deferred();

$this -> client = new swoole_client(SWOOLE_SOCK_TCP);

$this -> client ->on("connect", function($cli) {});

$this -> client ->on("receive", function($cli, $data){});

$this -> client ->on("error", function($cli){});

$this -> client ->on("close", function($cli){});

$this -> client -> connect('127.0.0.1', 9501, 5);

}

public function setTask($data) {

$this -> data = $data;

return $this -> deferred -> promise();

}

public function todo() {

$data = is_array($this -> data) ? json_encode($this -> data) : $this -> data;

$this -> data = [];

$this -> client -> send($data);

$deferred = $this -> deferred;

$client = $this -> client;

swoole_event_add($this->client->sock, function($fp) use($client, $deferred){

$str = $client -> recv();

swoole_event_del($fp);

$deferred -> resolve($str);

});

}

function task($i, $fifo) {

$syncClient = new SyncClient();

$promise = $syncClient -> setTask([

'func' => 'Module.Class.Method',

'params' => [

'hello' => 'world',

'i' => $i,

]

]);

$promise -> then(function($data) use($fifo) {

$fifo -> write($data);

});

return $syncClient -> todo();

}

$protocol = new Pangou\Fifo\Protocol\LengthProtocol();

$write = new Pangou\Fifo\Fifo($protocol, '/tmp/serv.fifo', '0666', false);

$read = new Pangou\Fifo\Fifo($protocol, '/tmp/serv.fifo', '0666', true);

for ($i = 0; $i < 20; $i++) {

task($i, $write);

}

swoole_event_wait();

$data = [];

for ($i = 0; $i < 20; $i++) {

$data[] = $read -> read();

}

print_r($data);

Array

(

[0] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":0}}

[1] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":1}}

[2] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":2}}

[3] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":3}}

[4] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":4}}

[5] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":5}}

[6] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":6}}

[7] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":7}}

[8] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":8}}

[9] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":9}}

[10] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":10}}

[11] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":11}}

[12] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":12}}

[13] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":13}}

[14] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":14}}

[15] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":15}}

[16] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":16}}

[17] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":17}}

[18] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":18}}

[19] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":19}}

)

3.4、将异步同步化

与同步异步化相同，因为本身是异步IO，省略了将同步IO异步话的操作。

# async_to_sync_client.php

require_once "vendor/autoload.php";

class AsyncClient
{
    protected $deferred;

    protected $client;

    public function __construct() {
        $this -> deferred = new React\Promise\Deferred();
        $this -> client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);
    }

    public function setTask($data) {
        $this -> client ->on("connect", function($cli) use($data) {
            $data = is_array($data) ? json_encode($data) : $data;
            $cli->send($data);
        });
        $deferred = $this -> deferred;
        $this -> client ->on("receive", function($cli, $data) use($deferred){
            $deferred -> resolve($data);
        });
        $this -> client ->on("error", function($cli){});
        $this -> client ->on("close", function($cli){});
        return $this -> deferred -> promise();
    }

    public function todo() {
        $this -> client -> connect('127.0.0.1', 9501, 5);
    }

}


function task($i, $fifo) {
    $client = new AsyncClient();
    $promise = $client -> setTask([
        'func' => 'Module.Class.Method',
        'params' => [
            'hello' => 'world',
            'i' => $i,
        ]
    ]);

    $promise -> then(function($data) use($fifo) {
        $fifo -> write($data);
    });

    return $client -> todo();
}

$protocol = new Pangou\Fifo\Protocol\LengthProtocol();
$write = new Pangou\Fifo\Fifo($protocol, '/tmp/serv.fifo', '0666', false);
$read = new Pangou\Fifo\Fifo($protocol, '/tmp/serv.fifo', '0666', true);

for ($i = 0; $i < 20; $i++) {
    task($i, $write);
}

swoole_event_wait();

$data = [];

for ($i = 0; $i < 20; $i++) {
    $data[] = $read -> read();
}

print_r($data);
/*
Array
(
    [0] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":0}}
    [1] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":1}}
    [2] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":2}}
    [3] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":3}}
    [4] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":4}}
    [5] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":5}}
    [6] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":6}}
    [7] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":7}}
    [8] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":8}}
    [9] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":9}}
    [10] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":10}}
    [11] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":11}}
    [12] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":12}}
    [13] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":13}}
    [14] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":14}}
    [15] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":15}}
    [16] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":16}}
    [17] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":17}}
    [18] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":18}}
    [19] => Swoole: {"func":"Module.Class.Method","params":{"hello":"world","i":19}}
)
*/

# async_to_sync_client.php

require_once "vendor/autoload.php";

class AsyncClient

{

protected $deferred;

protected $client;

public function __construct() {

$this -> deferred = new React\Promise\Deferred();

$this -> client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);

}

public function setTask($data) {

$this -> client ->on("connect", function($cli) use($data) {

$data = is_array($data) ? json_encode($data) : $data;

$cli->send($data);

});

$deferred = $this -> deferred;

$this -> client ->on("receive", function($cli, $data) use($deferred){

$deferred -> resolve($data);

});

$this -> client ->on("error", function($cli){});

$this -> client ->on("close", function($cli){});

return $this -> deferred -> promise();

}

public function todo() {

$this -> client -> connect('127.0.0.1', 9501, 5);

}

function task($i, $fifo) {

$client = new AsyncClient();

$promise = $client -> setTask([

'func' => 'Module.Class.Method',

'params' => [

'hello' => 'world',

'i' => $i,

]

]);

$promise -> then(function($data) use($fifo) {

$fifo -> write($data);

});

return $client -> todo();