��ҹ·�ˣ�PHP��ʱ����ȫ���ܽ�

ProcessLifeTime һ�����̵���������ڣ�����֮��������kill

MaxProcessCount �������̸���

DefaultMinClassProcessCount ÿ��������������С���̸���

DefaultMaxClassProcessCount ÿ�������������������̸���

IPCConnectTimeout ������Ӧ��ʱʱ��

IPCCommTimeout ������ͨѶ���ʱ�䣬�����Ĵ����п��ܾ�������ֵ���ù�С���ɵ�

MaxRequestsPerProcess ÿ�������������ɴ������������ɺ���ɱ

--------------------------------------------------

# ÿ��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

# ���ͻ��������ij�ʱ���ƣ���λ����, ��Ϊ0��ʾ��������

# ����С��max-read-idleʱ��read-timeout��Ч

server.read-timeout = 0

# дӦ��ҳ�����ͻ��˵ij�ʱ���ƣ���λ���룬��Ϊ0��ʾ��������

# ����С��max-write-idleʱ��write-timeout��Ч

server.write-timeout = 0

# �����Ĵ���ʱ�����ޣ���������mod_proxy_core���Ǿ��Ǻͺ��˵Ľ���ʱ������, ��λ����

server.max-connection-idle = 1200

--------------------------------------------------

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;         #д��ʱ

}

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

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

}

?> 

// 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; 

        } 

} 

$timeout = array(

    'http' => array(

        'timeout' => 5 //����һ����ʱʱ�䣬��λΪ��

    )

);

$ctx = stream_context_create($timeout);

$text = file_get_contents("http://example.com/", 0, $ctx);

?>

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

}

?>

//�Լ�������д��ʱ����

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; 

}

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;

}