关于phpcurlsocket的信息

发布时间：2023-01-08

本文目录一览：

  1. 几种常见的PHP超时处理方法
  2. php的curl socket soap 这几个扩展有什么作用和区别?
  3. 如何查看php进程请求的socket详情
  4. php的curl和socket的区别

几种常见的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

配置：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

配置：

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 的超时设置倒是非常清晰容易理解，上面超时针对不同工作模式，但是因为超时带来的问题是非常多的。 延伸阅读：

PHP本身超时处理

PHP-FPM

配置：

<?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' in 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.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中被加入。从PHP5.2.3起可使用。)
  • CURLOPT_CONNECTTIMEOUT 在发起连接前等待的时间，如果设置为0，则无限等待。
  • CURLOPT_CONNECTTIMEOUT_MS 尝试连接等待的时间，以毫秒为单位。如果设置为0，则无限等待。在cURL 7.16.2中被加入。从PHP5.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); // 超时毫秒，cURL7.16.2中被加入。从PHP5.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();
}
// 执行查询sleep1秒不超时
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";
}
// 执行查询sleep9秒会超时
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(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占用会较高）

<?php
$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编程的知识去理解）

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

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的curl socket soap 这几个扩展有什么作用和区别?

  • curl 一般是为了提交页面的，如GET、POST、上传、下载等功能。
  • socket 也有上面那些功能，一般很少用，可以做socket应用，如聊天室，可以做网络应用。PHP socket这个功能不强。
  • soap 做webservice，这种协议很多语言都支持，跨平台性非常强，非常好用。一般接口用它比较多。
  • 另外接口还有很多种如REST、XML-RPC等等。

如何查看php进程请求的socket详情

PHP使用socket发送HTTP请求的方法，具体如下：

socket方式：

$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
// socket_set_option($socket, SOL_SOCKET, SO_SNDTIMEO, array("sec" => 20, "usec" => 0));
socket_connect($socket, '', 80);
// 里面的换行代表 \r\n 注意拷贝的代码后面可能有空格
$http = <<<eof
GET / HTTP/1.0
Accept: */*
User-Agent: Lowell-Agent
Host: 
Connection: Close
eof;
socket_write($socket, $http, strlen($http));
while ($str = socket_read($socket, 1024)) {
    echo $str;
}
socket_close($socket);

fsockopen方式：

$fp = fsockopen("", 80, $errno, $errstr, 30);
if (!$fp) {
    echo "$errstr ($errno)<br />\n";
} else {
    $out = "GET / HTTP/1.1\r\n";
    $out .= "Host: \r\n";
    $out .= "Connection: Close\r\n\r\n";
    fwrite($fp, $http);
    while (!feof($fp)) {
        echo fgets($fp, 128);
    }
    fclose($fp);
}

原始socket方式：

$fp = stream_socket_client("tcp://", $errno, $errstr, 30);
if (!$fp) {
    echo "$errstr ($errno)<br />\n";
} else {
    $http = <<<eof
GET / HTTP/1.0
Accept: */*
User-Agent: Lowell-Agent
Host: 
Connection: Close
eof;
    fwrite($fp, $http);
    while (!feof($fp)) {
        echo fgets($fp, 1024);
    }
    fclose($fp);
}

stream 方式（GET）：

$http = <<<eof
Host: 
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:27.0) Gecko/20100101 Firefox/27.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3
Cookie: BAIDUID=79D98B1AD8436C57B967E111E484F1CD:FG=1; BDUSS=lF-UFFOanFPVG92NmF4U3NiTEoxOFh4YVBCTnZaMUtoTUNhZmxrWThwN25IaUJVQVFBQUFBJCQAAAAAAAAAAAEAAADzo1gKc2lxaW5pYW8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOeR-FPnkfhTU; BAIDUPSID=79D98B1AD8436C57B967E111E484F1CD; BD_UPN=13314352; BD_HOME=1; H_PS_PSSID=10047_1435_10874_10212_10501_10496_10753_10796_10219_10355_10666_10597_10095_10658_10442_10700_10460_10360_10618; sug=3; sugstore=0; ORIGIN=2; bdime=0
Connection: keep-alive
Cache-Control: max-age=0
eof;
$hdrs = array(
    'http' => array(
        'header' => $http,
        'timeout' => 1, // 超时 秒
        'method' => 'GET', // 默认方式
        'protocol_version' => '1.1', // 默认为 1.0
    ),
);
// 参数格式参考 方式的格式可以参考； = stream_context_create($hdrs);
echo file_get_contents('', false, $context);

stream 方式（POST）：

$postdata = http_build_query(array('act' => 'save', 'id' => 387171));
$http = <<<eof
Host: 
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:27.0) Gecko/20100101 Firefox/27.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Cookie: BAIDUID=79D98B1AD8436C57B967E111E484F1CD:FG=1; BDUSS=lF-UFFOanFPVG92NmF4U3NiTEoxOFh4YVBCTnZaMUtoTUNhZmxrWThwN25IaUJVQVFBQUFBJCQAAAAAAAAAAAEAAADzo1gKc2lxaW5pYW8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOeR-FPnkfhTU; BAIDUPSID=79D98B1AD8436C57B967E111E484F1CD; BD_UPN=13314352; BD_HOME=1; H_PS_PSSID=10047_1435_10874_10212_10501_10496_10753_10796_10219_10355_10666_10597_10095_10658_10442_10700_10460_10360_10618; sug=3; sugstore=0; ORIGIN=2; bdime=0
Connection: keep-alive
Cache-Control: max-age=0
eof;
// 注意post方式需要增加Content-Type
$hdrs = array(
    'http' => array(
        'header' => $http,
        'timeout' => 1, // 超时 秒
        'method' => 'POST',
        'content' => $postdata,
        'protocol_version' => '1.1', // 默认为 1.0
    ),
);
// 参数格式参考 方式的格式可以参考； = stream_context_create($hdrs);
echo file_get_contents('', false, $context);

php的curl和socket的区别

socket是一种数据结构，他可以用来在服务器和客户端进行对话。而curl是利用url语法规定来传输文件和数据的规定，支持很多协议，例如FTP、HTTP、TELNET等。 要是还有什么不懂的地方建议去后盾网看看，那里教学视频非常多，师资力量大，希望可以帮助到你。 望采纳，谢谢。

推荐文章