包含phppost请求超时的词条

发布时间：2023-01-08

本文目录一览：

  1. 几种常见的PHP超时处理方法
  2. PHP提交表单超时的问题
  3. 如何用php向服务器发送post请求
  4. PHP。POST请求的问题

几种常见的PHP超时处理方法

【Web服务器超时处理】

Apache

一般在性能很高的情况下，缺省所有超时配置都是30秒，但是在上传文件，或者网络速度很慢的情况下，那么可能触发超时操作。 目前 Apache FastCGI PHP-FPM 模式下有三个超时设置： FastCGI 超时设置： 修改的 FastCGI 连接配置，类似如下：

IfModule mod_fastcgi.c
FastCgiExternalServer /home/forum/apache/apache_php/cgi-bin/php-cgi -socket /home/forum/php5/etc/php-fpm.sock
ScriptAlias /fcgi-bin/ "/home/forum/apache/apache_php/cgi-bin/"
AddHandler php-fastcgi .php
Action php-fastcgi /fcgi-bin/php-cgi
AddType application/x-
/IfModule

缺省配置是30s，如果需要定制自己的配置，需要修改配置，比如修改为100秒：(修改后重启 Apache)：

IfModule mod_fastcgi.c
FastCgiExternalServer /home/forum/apache/apache_php/cgi-bin/php-cgi -socket /home/forum/php5/etc/php-fpm.sock -idle-timeout 100
ScriptAlias /fcgi-bin/ "/home/forum/apache/apache_php/cgi-bin/"
AddHandler php-fastcgi .php
Action php-fastcgi /fcgi-bin/php-cgi
AddType application/x-
/IfModule

如果超时会返回500错误，断开跟后端 PHP 服务的连接，同时记录一条 Apache 错误日志：

[Thu Jan 27 18:30:15 2011][error][client 10.81.41.110] FastCGI: comm with server "/home/forum/apache/apache_php/cgi-bin/php-cgi" aborted: idle timeout (30 sec)

[Thu Jan 27 18:30:15 2011][error][client 10.81.41.110] FastCGI: incomplete headers (0 bytes) received from server "/home/forum/apache/apache_php/cgi-bin/php-cgi"

其他 FastCGI 配置参数说明：

IdleTimeout 发呆时限
ProcessLifeTime 一个进程的最长生命周期，过期之后无条件 kill
MaxProcessCount 最大进程个数
DefaultMinClassProcessCount 每个程序启动的最小进程个数
DefaultMaxClassProcessCount 每个程序启动的最大进程个数
IPCConnectTimeout 程序响应超时时间
IPCCommTimeout 与程序通讯的最长时间，上面的错误有可能就是这个值设置过小造成的
MaxRequestsPerProcess 每个进程最多完成处理个数，达成后自杀

Lighttpd

配置：lig Lighttpd 配置中，关于超时的参数有如下几个（篇幅考虑，只写读超时，写超时参数同理）： 主要涉及选项：

server.max-keep-alive-idle=5
server.max-read-idle=60
server.read-timeout=0
server.max-connection-idle=360

# 每次 keep-alive 的最大请求数, 默认值是 16
server.max-keep-alive-requests=100
# keep-alive 的最长等待时间, 单位是秒，默认值是 5
server.max-keep-alive-idle=1200
# lighttpd 的 work 子进程数，默认值是 0，单进程运行
server.max-worker=2
# 限制用户在发送请求的过程中，最大的中间停顿时间(单位是秒)，
# 如果用户在发送请求的过程中(没发完请求)，中间停顿的时间太长，lighttpd 会主动断开连接
# 默认值是 60(秒)
server.max-read-idle=1200
# 限制用户在接收应答的过程中，最大的中间停顿时间(单位是秒)，
# 如果用户在接收应答的过程中(没接完)，中间停顿的时间太长，lighttpd 会主动断开连接
# 默认值是 360(秒)
server.max-write-idle=12000
# 读客户端请求的超时限制，单位是秒, 配为 0 表示不作限制
# 设置小于 max-read-idle 时，read-timeout 生效
server.read-timeout=0
# 写应答页面给客户端的超时限制，单位是秒，配为 0 表示不作限制
# 设置小于 max-write-idle 时，write-timeout 生效
server.write-timeout=0
# 请求的处理时间上限，如果用了 mod_proxy_core，那就是和后端的交互时间限制, 单位是秒
server.max-connection-idle=1200

说明： 对于一个 keep-alive 连接上的连续请求，发送第一个请求内容的最大间隔由参数 max-read-idle 决定，从第二个请求起，发送请求内容的最大间隔由参数 max-keep-alive-idle 决定。请求间的间隔超时也由 max-keep-alive-idle 决定。发送请求内容的总时间超时由参数 read-timeout 决定。Lighttpd 与后端交互数据的超时由 max-connection-idle 决定。 延伸阅读：

Nginx

配置：nf

http {
    # Fastcgi:(针对后端的 fastcgi 生效, fastcgi 不属于 proxy 模式)
    fastcgi_connect_timeout 5; # 连接超时
    fastcgi_send_timeout 10;   # 写超时
    fastcgi_read_timeout 10;   # 读取超时
    # Proxy:(针对 proxy/upstreams 的生效)
    proxy_connect_timeout 15s; # 连接超时
    proxy_read_timeout 24s;    # 读超时
    proxy_send_timeout 10s;    # 写超时
}

说明： Nginx 的超时设置倒是非常清晰容易理解，上面超时带来的问题是非常多的。 延伸阅读： ml ml ml 【PHP本身超时处理】

PHP-fpm

配置：nf

<?xml version="1.0" ?>
<configuration>
    <!-- 设置同时处理请求的最大数量 -->
    <value name="max_children">128</value>
    <!-- 设置单个请求的最大执行时间，超时后进程将被终止 -->
    <value name="request_terminate_timeout">0s</value>
    <!-- 设置单个请求执行时间，超过后将记录慢日志 -->
    <value name="request_slowlog_timeout">0s</value>
</configuration>

说明： 在 php.ini 中，有一个参数 max_execution_time 可以设置 PHP 脚本的最大执行时间，但是，在 php-cgi (php-fpm) 中，该参数不会起效。真正能够控制 PHP 脚本最大执行时间的是：

<value name="request_terminate_timeout">0s</value>

就是说如果是使用 mod_php5.so 的模式运行 max_execution_time 是会生效的，但是如果是 php-fpm 模式中运行时不生效的。 延伸阅读：

PHP

配置：php.ini 选项：

max_execution_time=30

或者在代码里设置：

ini_set("max_execution_time", 30);
set_time_limit(30);

说明： 对当前会话生效，比如设置 0 一直不超时，但是如果 php 的 safe_mode 打开了，这些设置都会不生效。 效果一样，但是具体内容需要参考 php-fpm 部分内容，如果 php-fpm 中设置了 request_terminate_timeout 的话，那么 max_execution_time 就不生效。

后端接口访问超时

HTTP访问

一般我们访问 HTTP 方式很多，主要是：curl, socket, file_get_contents() 等方法。 如果碰到对方服务器一直没有响应的时候，我们就悲剧了，很容易把整个服务器搞死，所以在访问 HTTP 的时候也需要考虑超时的问题。

CURL 访问 HTTP

CURL 是我们常用的一种比较靠谱的访问 HTTP 协议接口的 lib 库，性能高，还有一些并发支持的功能等。 CURL: curl_setopt($ch, opt) 可以设置一些超时的设置，主要包括：

  • CURLOPT_TIMEOUT 设置 cURL 允许执行的最长秒数。
  • CURLOPT_TIMEOUT_MS 设置 cURL 允许执行的最长毫秒数。(在 cURL 7.16.2 中被加入。从 PHP 5.2.3 起可使用。)
  • CURLOPT_CONNECTTIMEOUT 在发起连接前等待的时间，如果设置为 0，则无限等待。
  • CURLOPT_CONNECTTIMEOUT_MS 尝试连接等待的时间，以毫秒为单位。如果设置为 0，则无限等待。在 cURL 7.16.2 中被加入。从 PHP 5.2.3 开始可用。
  • CURLOPT_DNS_CACHE_TIMEOUT 设置在内存中保存 DNS 信息的时间，默认为 120 秒。 curl 普通秒级超时：
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_TIMEOUT, 60); // 只需要设置一个秒的数量就可以
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_USERAGENT, $defined_vars['HTTP_USER_AGENT']);

curl 普通秒级超时使用：

curl_setopt($ch, CURLOPT_TIMEOUT, 60);

curl 如果需要进行毫秒超时，需要增加：

curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);

或者是：

curl_setopt($ch, CURLOPT_NOSIGNAL, true); 是可以支持毫秒级别超时设置的

curl 一个毫秒级超时的例子：

<?php
if (!isset($_GET['foo'])) {
    // Client
    $ch = curl_init('');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_NOSIGNAL, 1); // 注意，毫秒超时一定要设置这个
    curl_setopt($ch, CURLOPT_TIMEOUT_MS, 200); // 超时毫秒，cURL 7.16.2 中被加入。从 PHP 5.2.3 起可使用
    $data = curl_exec($ch);
    $curl_errno = curl_errno($ch);
    $curl_error = curl_error($ch);
    curl_close($ch);
    if ($curl_errno > 0) {
        echo "cURL Error ($curl_errno): $curl_error\n";
    } else {
        echo "Data received: $data\n";
    }
} else {
    // Server
    sleep(10);
    echo "Done.";
}
?>

其他一些技巧：

  1. 按照经验总结是：cURL 版本 >= libcurl/7.21.0 版本，毫秒级超时是一定生效的，切记。
  2. curl_multi 的毫秒级超时也有问题。单次访问是支持 ms 级超时的，curl_multi 并行调多个会不准

流处理方式访问 HTTP

除了 curl，我们还经常自己使用 fsockopen、或者是 file 操作函数来进行 HTTP 协议的处理，所以，我们对这块的超时处理也是必须的。 一般连接超时可以直接设置，但是流读取超时需要单独处理。 自己写代码处理:

$tmCurrent = gettimeofday();
$intUSGone = ($tmCurrent['sec'] - $tmStart['sec']) * 1000000
    + ($tmCurrent['usec'] - $tmStart['usec']);
if ($intUSGone > $this->_intReadTimeoutUS) {
    return false;
}

或者使用内置流处理函数 stream_set_timeout() 和 stream_get_meta_data() 处理：

<?php
// Timeout in seconds
$timeout = 5;
$fp = fsockopen("", 80, $errno, $errstr, $timeout);
if ($fp) {
    fwrite($fp, "GET / HTTP/1.0\r\n");
    fwrite($fp, "Host: \r\n");
    fwrite($fp, "Connection: Close\r\n\r\n");
    stream_set_blocking($fp, true); // 重要，设置为非阻塞模式
    stream_set_timeout($fp, $timeout); // 设置超时
    $info = stream_get_meta_data($fp);
    while ((!feof($fp)) && (!$info['timed_out'])) {
        $data .= fgets($fp, 4096);
        $info = stream_get_meta_data($fp);
        ob_flush;
        flush();
    }
    if ($info['timed_out']) {
        echo "Connection Timed Out!";
    } else {
        echo $data;
    }
}
?>

file_get_contents 超时：

<?php
$timeout = array(
    'http' => array(
        'timeout' => 5 // 设置一个超时时间，单位为秒
    )
);
$ctx = stream_context_create($timeout);
$text = file_get_contents("", 0, $ctx);
?>

fopen 超时：

<?php
$timeout = array(
    'http' => array(
        'timeout' => 5 // 设置一个超时时间，单位为秒
    )
);
$ctx = stream_context_create($timeout);
if ($fp = fopen("", "r", false, $ctx)) {
    while ($c = fread($fp, 8192)) {
        echo $c;
    }
    fclose($fp);
}
?>

MySQL

php 中的 mysql 客户端都没有设置超时的选项，mysqli 和 mysql 都没有，但是 libmysql 是提供超时选项的，只是我们在 php 中隐藏了而已。 那么如何在 PHP 中使用这个操作捏，就需要我们自己定义一些 MySQL 操作常量，主要涉及的常量有：

MYSQL_OPT_READ_TIMEOUT = 11;
MYSQL_OPT_WRITE_TIMEOUT = 12;

这两个，定义以后，可以使用 options 设置相应的值。 不过有个注意点，mysql 内部实现：

  1. 超时设置单位为秒，最少配置 1 秒
  2. 但 mysql 底层的 read 会重试两次，所以实际会是 3 秒 重试两次 + 自身一次 = 3 倍超时时间，那么就是说最少超时时间是 3 秒，不会低于这个值，对于大部分应用来说可以接受，但是对于小部分应用需要优化。 查看一个设置访问 mysql 超时的 php 实例：
<?php
// 自己定义读写超时常量
if (!defined('MYSQL_OPT_READ_TIMEOUT')) {
    define('MYSQL_OPT_READ_TIMEOUT', 11);
}
if (!defined('MYSQL_OPT_WRITE_TIMEOUT')) {
    define('MYSQL_OPT_WRITE_TIMEOUT', 12);
}
// 设置超时
$mysqli = mysqli_init();
$mysqli->options(MYSQL_OPT_READ_TIMEOUT, 3);
$mysqli->options(MYSQL_OPT_WRITE_TIMEOUT, 1);
// 连接数据库
$mysqli->real_connect("localhost", "root", "root", "test");
if (mysqli_connect_errno()) {
    printf("Connect failed: %s/n", mysqli_connect_error());
    exit();
}
// 执行查询 sleep 1 秒不超时
printf("Host information: %s/n", $mysqli->host_info);
if (!($res = $mysqli->query('select sleep(1)'))) {
    echo "query1 error: " . $mysqli->error . "/n";
} else {
    echo "Query1: query success/n";
}
// 执行查询 sleep 9 秒会超时
if (!($res = $mysqli->query('select sleep(9)'))) {
    echo "query2 error: " . $mysqli->error . "/n";
} else {
    echo "Query2: query success/n";
}
$mysqli->close();
echo "close mysql connection/n";
?>

延伸阅读：

Memcached

PHP扩展

php_memcache 客户端： 连接超时：bool Memcache::connect(string $host [, int $port [, int $timeout]]) 在 get 和 set 的时候，都没有明确的超时设置参数。 libmemcached 客户端：在 php 接口没有明显的超时参数。 说明：所以说，在 PHP 中访问 Memcached 是存在很多问题的，需要自己 hack 部分操作，或者是参考网上补丁。

C/C++访问 Memcached

客户端：libmemcached 客户端 说明：memcache 超时配置可以配置小点，比如 5，10 个毫秒已经够用了，超过这个时间还不如从数据库查询。 下面是一个连接和读取 set 数据的超时的 C++ 示例：

// 创建连接超时（连接到 Memcached）
memcached_st* MemCacheProxy::_create_handle() {
    memcached_st* mmc = NULL;
    memcached_return_t prc;
    if (_mpool != NULL) { // get from pool
        mmc = memcached_pool_pop(_mpool, false, prc);
        if (mmc == NULL) {
            __LOG_WARNING__("MemCacheProxy", "get handle from pool error [%d]", (int) prc);
        }
        return mmc;
    }
    memcached_st* handle = memcached_create(NULL);
    if (handle == NULL) {
        __LOG_WARNING__("MemCacheProxy", "create_handle error");
        return NULL;
    }
    // 设置连接/读取超时
    memcached_behavior_set(handle, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_DEFAULT);
    memcached_behavior_set(handle, MEMCACHED_BEHAVIOR_NO_BLOCK, _noblock); // 参数 MEMCACHED_BEHAVIOR_NO_BLOCK 为 1 使超时配置生效，不设置超时会不生效，关键时候会悲剧的，容易引起雪崩
    memcached_behavior_set(handle, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, _connect_timeout); // 连接超时
    memcached_behavior_set(handle, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, _read_timeout); // 读超时
    memcached_behavior_set(handle, MEMCACHED_BEHAVIOR_SND_TIMEOUT, _send_timeout); // 写超时
    memcached_behavior_set(handle, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, _poll_timeout);
    // 设置一致 hash
    // memcached_behavior_set_distribution(handle, MEMCACHED_DISTRIBUTION_CONSISTENT);
    memcached_behavior_set(handle, MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT);
    memcached_return rc;
    for (uint i = 0; i < _server_count; i++) {
        rc = memcached_server_add(handle, _ips[i], _ports[i]);
        if (MEMCACHED_SUCCESS != rc) {
            __LOG_WARNING__("MemCacheProxy", "add server [%s:%d] failed.", _ips[i], _ports[i]);
        }
    }
    _mpool = memcached_pool_create(handle, _min_connect, _max_connect);
    if (_mpool == NULL) {
        __LOG_WARNING__("MemCacheProxy", "create_pool error");
        return NULL;
    }
    mmc = memcached_pool_pop(_mpool, false, prc);
    if (mmc == NULL) {
        __LOG_WARNING__("MyMemCacheProxy", "get handle from pool error [%d]", (int) prc);
    }
    // __LOG_DEBUG__("MemCacheProxy", "get handle [%p]", handle);
    return mmc;
}
// 设置一个 key 超时（set 一个数据到 memcached）
bool MemCacheProxy::_add(memcached_st* handle, unsigned int* key, const char* value, int len, unsigned int timeout) {
    memcached_return rc;
    char tmp[1024];
    snprintf(tmp, sizeof(tmp), "%u#%u", key[0], key[1]);
    // 有个 timeout 值
    rc = memcached_set(handle, tmp, strlen(tmp), (char*) value, len, timeout, 0);
    if (MEMCACHED_SUCCESS != rc) {
        return false;
    }
    return true;
}
// Memcache 读取数据超时 (没有设置)
libmemcahed 源码中接口定义：
LIBMEMCACHED_API char* memcached_get(memcached_st* ptr, const char* key, size_t key_length, size_t* value_length, uint32_t* flags, memcached_return_t* error);
LIBMEMCACHED_API memcached_return_t memcached_mget(memcached_st* ptr, const char* const* keys, const size_t* key_length, size_t number_of_keys);
从接口中可以看出在读取数据的时候，是没有超时设置的。

延伸阅读：

如何实现超时

程序中需要有超时这种功能，比如你单独访问一个后端 Socket 模块，Socket 模块不属于我们上面描述的任何一种的时候，它的协议也是私有的，那么这个时候可能需要自己去实现一些超时处理策略，这个时候就需要一些处理代码了。

PHP中超时实现

初级：最简单的超时实现（秒级超时）

思路很简单：链接一个后端，然后设置为非阻塞模式，如果没有连接上就一直循环，判断当前时间和超时时间之间的差异。 php socket 中实现原始的超时：(每次循环都当前时间去减，性能会很差，cpu 占用会较高)

$host = "127.0.0.1";
$port = "80";
$timeout = 15; // timeout in seconds
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP) or die("Unable to create socket\n");
socket_set_nonblock($socket) or die("Unable to set nonblock on socket\n");
$time = time();
// 循环的时候每次都减去相应值
while (!@socket_connect($socket, $host, $port)) // 如果没有连接上就一直死循环
{
    $err = socket_last_error($socket);
    if ($err == 115 || $err == 114) {
        if ((time() - $time) >= $timeout) // 每次都需要去判断一下是否超时了
        {
            socket_close($socket);
            die("Connection timed out.\n");
        }
        sleep(1);
        continue;
    }
    die(socket_strerror($err) . "\n");
}
socket_set_block($this->socket) or die("Unable to set block on socket\n");

升级：使用 PHP 自带异步 IO 去实现（毫秒级超时）

说明： 异步 IO：异步 IO 的概念和同步 IO 相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者。异步 IO 将比特分成小组进行传送，小组可以是 8 位的 1 个字符或更长。发送方可以在任何时刻发送这些比特组，而接收方从不知道它们会在什么时候到达。 多路复用：复用模型是对多个 IO 操作进行检测，返回可操作集合，这样就可以对其进行操作了。这样就避免了阻塞 IO 不能随时处理各个 IO 和非阻塞占用系统资源的确定。 使用 socket_select() 实现超时

socket_select(..., floor($timeout), ceil($timeout * 1000000));

select 的特点：能够设置到微秒级别的超时！ 使用 socket_select() 的超时代码（需要了解一些异步 IO 编程的知识去理解）

class select {
    var $sockets;
    function select($sockets) {
        $this->sockets = array();
        foreach ($sockets as $socket) {
            $this->add($socket);
        }
    }
    function add($add_socket) {
        array_push($this->sockets, $add_socket);
    }
    function remove($remove_socket) {
        $sockets = array();
        foreach ($this->sockets as $socket) {
            if ($remove_socket != $socket)
                $sockets[] = $socket;
        }
        $this->sockets = $sockets;
    }
    function can_read($timeout) {
        $read = $this->sockets;
        socket_select($read, $write = NULL, $except = NULL, $timeout);
        return $read;
    }
    function can_write($timeout) {
        $write = $this->sockets;
        socket_select($read = NULL, $write, $except = NULL, $timeout);
        return $write;
    }
}

C/C++中超时实现

一般在 Linux C/C++ 中，可以使用：alarm() 设置定时器的方式实现秒级超时，或者：select()、poll()、epoll() 之类的异步复用 IO 实现毫秒级超时。也可以使用二次封装的异步 io 库（libevent, libev）也能实现。

使用 alarm 中用信号实现超时（秒级超时）

说明：Linux 内核 connect 超时通常为 75 秒，我们可以设置更小的时间如 10 秒来提前从 connect 中返回。这里用使用信号处理机制，调用 alarm，超时后产生 SIGALRM 信号（也可使用 select 实现） 用 alarm 秒级实现 connect 设置超时代码示例：

// 信号处理函数
static void connect_alarm(int signo) {
    debug_printf("Signal Handler");
    return;
}
// alarm 超时连接实现
static void conn_alarm() {
    Sigfunc* sigfunc; // 现有信号处理函数
    sigfunc = signal(SIGALRM, connect_alarm); // 建立信号处理函数 connect_alarm, (如果有) 保存现有的信号处理函数
    int timeout = 5;
    // 设置闹钟
    if (alarm(timeout) != 0) {
        // ... 闹钟已经设置处理
    }
    // 进行连接操作
    if (connect(m_Socket, (struct sockaddr*) addr, sizeof(addr)) < 0) {
        if (errno == EINTR) { // 如果错误号设置为 EINTR，说明超时中断了
            debug_printf("Timeout");
        }
    }
}

PHP提交表单超时的问题

出现这种情况是由于您的网站超过了 IIS 限制造成的 由于 2003 的操作系统在提示 IIS 过多时并非像 2000 系统提示“链接人数过多”，而是提示 "Service Unavailable"，出现这种情况是由于网站超过了系统资源限制造成的，主要是程序占用资源太多。 比如同样是 100 人在线的论坛，雷傲论坛所占的资源就是 PW 论坛所占资源的 10 倍以上；另外，一些死循环程序，或者不优化的程序都会占用太多的系统资源，而系统资源明显是有限的。不过 WINDOWS 2003 的操作系统，各网站之间是以独立进程运行的，不会相互影响。 如果一个网站的程序占资源太多或者发生太多的错误，系统日志就会提示：“应用程序池 'xxx' 被自动禁用，原因是为此应用程序池提供服务的进程中出现一系列错误，或者提示：应用程序池 'xxx' 超过了其作业限制设置。这时，访问这个网站就会提示：Service Unavailable。一般系统会在 30 秒左右恢复正常，多刷新几次就能正常访问了。 另外，如果你的网站当前访问人数过多，超过了系统的 IIS 连接数限制，也会出现 Service Unavailable 的提示 (win2k 主机下出现连接过多就会提示：连接过多，请稍后再试；而 win2003 的主机刚直接提示：Service Unavailable）

如何用 php 向服务器发送 post 请求

用 PHP 向服务器发送 HTTP 的 POST 请求，代码如下：

<?php
/**
 * 发送 post 请求
 * @param string $url 请求地址
 * @param array $post_data post 键值对数据
 * @return string
 */
function send_post($url, $post_data) {
    $postdata = http_build_query($post_data);
    $options = array(
        'http' => array(
            'method' => 'POST',
            'header' => 'Content-type: application/x-www-form-urlencoded',
            'content' => $postdata,
            'timeout' => 15 * 60 // 超时时间（单位: s）
        )
    );
    $context = stream_context_create($options);
    $result = file_get_contents($url, false, $context);
    return $result;
}

使用的时候直接调用上面定义的 send_post 方法：

$post_data = array(
    'username' => 'username',
    'password' => 'password'
);
send_post('网址', $post_data);

PHP。POST 请求的问题

最简单的话就是使用 session 保存，其次可以把数据存储在数据库里，或者文件里，然后在 register.php 里查询。 原生 session 使用方法

session_start();
// 赋值
$_SESSION["Session名称"] = 变量或字符串信息;
// 使用
$_SESSION["Session名称"];
推荐文章