PHP超时处理全面总结(3)

最新推荐文章于 2024-09-24 09:30:08 发布

蝶龙旱魁

最新推荐文章于 2024-09-24 09:30:08 发布

阅读量8k

点赞数 1

分类专栏： php 文章标签： php memcached behavior mysql stream fp

php 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

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

后端&接口访问超时
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('http://example.com/');
        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("example.com", 80, $errno, $errstr, $timeout); 
if ($fp) { 
        fwrite($fp, "GET / HTTP/1.0\r\n"); 
        fwrite($fp, "Host: example.com\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("http://example.com/", 0, $ctx);
?>

fopen 超时：

<?php

$timeout = array(

'http' => array(

'timeout' => 5 //设置一个超时时间，单位为秒

)

);

$ctx = stream_context_create($timeout);

if ($fp = fopen("http://example.com/", "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);

从接口中可以看出在读取数据的时候，是没有超时设置的。