转:PHP超时处理全面总结

 
<?xml version="1.0" ?>
<configuration>
//...
  Sets the limit on the number of simultaneous requests that will be served.
  Equivalent to Apache MaxClients directive.
  Equivalent to PHP_FCGI_CHILDREN environment in original php.fcgi
  Used with any pm_style.
  #php-cgi的进程数量
  <value name="max_children">128</value>
 
 
  The timeout (in seconds) for serving a single request after which the worker process will be terminated
  Should be used when ‘max_execution_time‘ ini option does not stop script execution for some reason
  ‘0s‘ means ‘off‘
 #php-fpm 请求执行超时时间，0s为永不超时，否则设置一个 Ns 为超时的秒数
  <value name="request_terminate_timeout">0s</value>
 
  The timeout (in seconds) for serving of single request after which a php backtrace will be dumped to slow.log file
  ‘0s‘ means ‘off‘
  <value name="request_slowlog_timeout">0s</value>
 
</configuration>

$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‘]); 

<?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.";
}
?>

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

 
<?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; 
        } 
} 

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

<?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);
}
?>

 
<?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）
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;
}

 
<?
    $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 
$server = new Server; 
$client = new Client; 
 
for (;;) { 
  foreach ($select->can_read(0) as $socket) { 
 
    if ($socket == $client->socket) { 
      // New Client Socket 
      $select->add(socket_accept($client->socket)); 
    } 
    else { 
      //there‘s something to read on $socket 
    } 
  } 
} 
?> 
 
### 异步多路复用IO & 超时连接处理类 ###
<?php 
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; 
  } 
} 
?>

//信号处理函数
static void connect_alarm(int signo)
{
     debug_printf("SignalHandler");
     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");
            m_connectionStatus = STATUS_CLOSED;
            errno = ETIMEDOUT; //防止三次握手继续进行 
            return ERR_TIMEOUT;
        }
        else {
            debug_printf("Other Err");
            m_connectionStatus = STATUS_CLOSED;
            return ERR_NET_SOCKET;
        }
    }
　　alarm(0);//关闭时钟 
　　signal(SIGALRM, sigfunc); //(如果有)恢复原来的信号处理函数 
　　return; 
}
 
//读取数据的超时设置
同样可以为 recv 设置超时，5秒内收不到任何应答就中断 
signal( ... ); 
alarm(5); 
recv( ... ); 
alarm(0); 
static void sig_alarm(int signo){return;} 

//select 实现毫秒级超时示例：
static void conn_select() {
    // Open TCP Socket
    m_Socket = socket(PF_INET,SOCK_STREAM,0);
    if( m_Socket < 0 )
    {
        m_connectionStatus = STATUS_CLOSED;
        return ERR_NET_SOCKET;
    }
 
    struct sockaddr_in addr;
    inet_aton(m_Host.c_str(), &addr.sin_addr);
    addr.sin_port = htons(m_Port);
    addr.sin_family = PF_INET;
 
    // Set timeout values for socket
    struct timeval timeouts;
    timeouts.tv_sec = SOCKET_TIMEOUT_SEC ;   // const -> 5
    timeouts.tv_usec = SOCKET_TIMEOUT_USEC ; // const -> 0
    uint8_t optlen = sizeof(timeouts);
 
    if( setsockopt( m_Socket, SOL_SOCKET, SO_RCVTIMEO,&timeouts,(socklen_t)optlen) < 0 )
    {
        m_connectionStatus = STATUS_CLOSED;
        return ERR_NET_SOCKET;
    }
 
    // Set the Socket to TCP Nodelay ( Send immediatly after a send / write command )
    int flag_TCP_nodelay = 1;
    if ( (setsockopt( m_Socket, IPPROTO_TCP, TCP_NODELAY,
            (char *)&flag_TCP_nodelay, sizeof(flag_TCP_nodelay))) < 0)
    {
        m_connectionStatus = STATUS_CLOSED;
        return ERR_NET_SOCKET;
    }
    // Save Socket Flags
    int opts_blocking = fcntl(m_Socket, F_GETFL);
    if ( opts_blocking < 0 )
    {
        return ERR_NET_SOCKET;
    }
    //设置为非阻塞模式
    int opts_noblocking = (opts_blocking | O_NONBLOCK);
    // Set Socket to Non-Blocking
    if (fcntl(m_Socket, F_SETFL, opts_noblocking)<0)
    {
        return ERR_NET_SOCKET;
    }
    // Connect
    if ( connect(m_Socket, (struct sockaddr *)&addr, sizeof(addr)) < 0)
    {
        // EINPROGRESS always appears on Non Blocking connect
        if ( errno != EINPROGRESS )
        {
            m_connectionStatus = STATUS_CLOSED;
            return ERR_NET_SOCKET;
        }
        // Create a set of sockets for select
        fd_set socks;
        FD_ZERO(&socks);
        FD_SET(m_Socket,&socks);
        // Wait for connection or timeout
        int fdcnt = select(m_Socket+1,NULL,&socks,NULL,&timeouts);
        if ( fdcnt < 0 )
        {
            return ERR_NET_SOCKET;
        }
        else if ( fdcnt == 0 )
        {
            return ERR_TIMEOUT;
        }
    }
    //Set Socket to Blocking again
    if(fcntl(m_Socket,F_SETFL,opts_blocking)<0)
    {
        return ERR_NET_SOCKET;
    }
 
    m_connectionStatus = STATUS_OPEN;
    return 0;
}