老和山下云儿飞

心有多大，这个世界就有多大！

php安装redis extension(转)

liyunfei

php需要装redis的插件才能连redis，把安装方法转一下；

说明：
       操作系统：CentOS

php安装目录：/usr/local/php

php.ini配置文件路径：/usr/local/php/etc/php.ini

Nginx安装目录：/usr/local/nginx

Nginx网站根目录：/usr/local/nginx/html

系统运维  www.osyunwei.com  温馨提醒：qihang01原创内容 版权所有,转载请注明出处及原文链接

1、安装编译工具

yum install wget  make gcc gcc-c++ zlib-devel openssl openssl-devel pcre-devel kernel keyutils  patch perl

2、安装redis

下载：https://github.com/nicolasff/phpredis/archive/2.2.4.tar.gz

上传phpredis-2.2.4.tar.gz到/usr/local/src目录

cd /usr/local/src #进入软件包存放目录

tar zxvf phpredis-2.2.4.tar.gz #解压

cd phpredis-2.2.4 #进入安装目录

/usr/local/php/bin/phpize #用phpize生成configure配置文件

./configure –with-php-config=/usr/local/php/bin/php-config  #配置

make  #编译

make install  #安装

安装完成之后，出现下面的安装路径

/usr/local/php/lib/php/extensions/no-debug-non-zts-20090626/

3、配置php支持

vi /usr/local/php/etc/php.ini  #编辑配置文件，在最后一行添加以下内容

添加

extension=”redis.so”

:wq! #保存退出

4、测试

vi /usr/local/nginx/html/index.php   #编辑

<?php

phpinfo();

?>

:wq! #保存退出

查天气api

liyunfei

原来觉得查天气的api很简单，结果做了一天，发现这个事情没有想象的那么容易，所以写下来：

 

主要有几个事情包括几个坑一起记下来：

1. 通用的服务框架，通用协议访问后端c服务器、redis、mysql，这个没啥好讲的

2. 第一个坑，本来想试试python的服务器，结果共享内存死活搞不来，静态成员变量一到回调函数就失败，搞了1-2个小时没搞定，就放弃了，用c来解决；

3. 第二个坑，发了1天等open.weather.com.cn，结果发现数据根本就不能用

4. 第三个坑，下m.weather.com.cn，发现丢包率太高

5. 决定用这种方案，一周的天气预报每天更新一次，每天凌晨合并数据，用c服务器reload，提供kv服务，前端获取请求后，将地域换成地域id,对实时的直接获取其他网站的json包，然后对数据进行缓存redis(1个小时有效期)，超过一个小时，就再次进行查询操作

6.第四个坑，尼玛，之所以一直访问失败，错误率这么高的最重要原因，是refer没有设置为http://mobile.weather.com.cn/，o(╯□╰)o

7.做的时候，觉得做天气有啥子好做的，一堆的网站做基础数据的，而且数据格式都基本一样的，弱弱的想，我直接套个壳是不是就是最快的做法，

8.今天最后的做法，就是每天8点半，开始从weather.com.cn下数据，然后更新源数据，php直接访问我们的后端服务器，实时天气，实时查询接口，然后缓存redis,每次查询先去看redis有没有数据，

9.给个链接：http://www.zhihu.com/question/20521716

10. 查实时天气的，只有地级市的查询，地级市以下的需要先回溯到地级市，然后再查询；

11.拼音查询会重名，宿州和苏州是一个拼音；

12.strpos 判断是不是一致的，用!==，这样还会判断类型，不然会把0也会算进去

 

流程图

  • 获取ID

–精确匹配（id/拼音/中文名）

–模糊匹配（精确匹配不了的情况，可以通过包含关系进行查询）

  • 获取一周天气预报

–访问后端c服务器，数据每天早上8点开始抓取

  • 获取实时天气预报

–实时抓取数据，抓取后存放在redis一个小时

php框架中使用mcpack进行发包

liyunfei

需要进行一下操作

1. 直接在框架入口module.php设置对应参数,设置配置

public static function test()
{
static $as = null;
if ($as === null) {
$as = new As_Client(Newapi_Conf_Common::$asServer);
}
return $as;
}
Env::set('NewapiAS',NewapiModule::test());

然后增加配置：

public static $asServer = array("host"=>array("121.40.104.68"), "port"=>1527, "timeout"=>0.5);

2. 调用对应的mcpack访问接口
创建头

protected function create_simple_asreq()
{
$as_head = array();
$as_head['id'] = 0x01;
$as_head['provider'] = "request";
$as_head['version'] = 0x100;
$as_req = array(
"head" => $as_head,
"request_body" => array()
);
return $as_req;
}

执行访问：

$as = Env::get('NewapiAS');
$retry = 0;
$times = 2;
$req = $this->create_simple_asreq();
$req['request_body'] = array("type" => 2);
do {
try{
$res = $as->query($req);
break;
}catch (Exception $ex){
if(1+$retry >= $times){
throw new Exception("as back error!");
}
}

}while(++$retry < $times);
var_dump($res);exit(1);

搭建快抓系统的种种问题

liyunfei

搭建python服务器：

1. gethostbyname+gethostname只能获取内网ip，导致服务器一直绑定的是内网ip,所以一直外部访问不了

2. 一直不能import _hashlib，libcryto.so.4和libssl.so.4都版本不对，好不容易从其他机器上拷贝了两个替换

3. python需要安装lxml

4.python的lib需要放到webkit的lib之前，LD_LIBRARY_PATH，不然会有版本的问题

wcsvr:

1. 原来有ec，后面把ec干掉了

2. 需要修改几个配置，一个是switch的配置，指向解析服务器

3. webkit配置，对应的服务器

webkit/squid:

1. webkit一定要线程数是10的倍数，才能启动，尼玛

2. 需要将webkit的lib加到LD_LIBRARY_PATH里面

3.squid一定要放到/home/work/下，源代码找不到，没有办法编译，也是尼玛

4.squid 定义了用户组，需要修改，默认的是nobody

网页：

1.fsockopen要在php.ini里解除屏蔽，然后重启nginx

2.mcpack包，需要下载，放到php对应的目录里

生产者消费者

liyunfei

我这篇不是正统意义的生产者消费者，只是我自己对一般离线任务解决的框架，主要是解决一些非实时的数据需求；

生产者消费者都不是常驻内存，都是每个时间周期来操作，dump可能是一天，其他可能是秒级别：

生产者：

1. dump全库

2. select想要的数据文件，生成pack包

消费者：

按业务流图：

1. merge，合并基准文件、pack包、状态包，生成新的基准文件，执行失败也会有状态包

2. 过滤执行时间超过1天的任务，并杀死相关进程

3. 查看当前启动的执行进程数n

4. 启动10-n个进程，按时间先后或者优先级执行子任务，并更新对应任务状态和启动时间

5.生成新的基准文件，如果没有修改，则不处理；

子任务：

1. 执行任务

2. 执行完毕后增加对应状态的状态包

3. 更新数据库

重新启动：

1.杀死所有子任务

2. 增加状态包为执行失败

启动：

1. 将所有正在执行的任务设置为执行失败，重新进入队列排队

生产者消费者（转）

liyunfei

秒杀多线程第十篇 生产者消费者问题

生产者消费者问题是一个著名的线程同步问题，该问题描述如下：有一个生产者在生产产 品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个具有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓 冲区中，消费者可以从缓冲区中取走产品进行消费，显然生产者和消费者之间必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已 经放入产品的缓冲区中再次投放产品。

这个生产者消费者题目不仅常用于操作系统的课程设计，也常常在程序员和软件设计师考试中出现。并且在计算机考研的专业课考试中也是一个非常热门的问题。因此现在就针对这个问题进行详细深入的解答。

 

首先来简化问题，先假设生产者和消费者都只有一个，且缓冲区也只有一个。这样情况就简便多了。

第一．从缓冲区取出产品和向缓冲区投放产品必须是互斥进行的。可以用关键段和互斥量来完成。

第二．生产者要等待缓冲区为空，这样才可以投放产品，消费者要等待缓冲区不为空，这样才可以取出产品进行消费。并且由于有二个等待过程，所以要用二个事件或信号量来控制。

考虑这二点后，代码很容易写出来。另外为了美观起见，将消费者的输出颜色设置为彩色，有关如何在控制台下设置彩色输出请参阅《VC 控制台颜色设置》。

[cpp] view plaincopy

  1. //1生产者 1消费者 1缓冲区
  2. //使用二个事件，一个表示缓冲区空，一个表示缓冲区满。
  3. //再使用一个关键段来控制缓冲区的访问
  4. #include <stdio.h>
  5. #include <process.h>
  6. #include <windows.h>
  7. //设置控制台输出颜色
  8. BOOL SetConsoleColor(WORD wAttributes)
  9. {
  10.     HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
  11.     if (hConsole == INVALID_HANDLE_VALUE)
  12.         return FALSE;
  13.     return SetConsoleTextAttribute(hConsole, wAttributes);
  14. }
  15. const int END_PRODUCE_NUMBER = 10;   //生产产品个数
  16. int g_Buffer;                        //缓冲区
  17. //事件与关键段
  18. CRITICAL_SECTION g_cs;
  19. HANDLE g_hEventBufferEmpty, g_hEventBufferFull;
  20. //生产者线程函数
  21. unsigned int __stdcall ProducerThreadFun(PVOID pM)
  22. {
  23.     for (int i = 1; i <= END_PRODUCE_NUMBER; i++)
  24.     {
  25.         //等待缓冲区为空
  26.         WaitForSingleObject(g_hEventBufferEmpty, INFINITE);
  28.         //互斥的访问缓冲区
  29.         EnterCriticalSection(&g_cs);
  30.         g_Buffer = i;
  31.         printf(“生产者将数据%d放入缓冲区\n”, i);
  32.         LeaveCriticalSection(&g_cs);
  34.         //通知缓冲区有新数据了
  35.         SetEvent(g_hEventBufferFull);
  36.     }
  37.     return 0;
  38. }
  39. //消费者线程函数
  40. unsigned int __stdcall ConsumerThreadFun(PVOID pM)
  41. {
  42.     volatile bool flag = true;
  43.     while (flag)
  44.     {
  45.         //等待缓冲区中有数据
  46.         WaitForSingleObject(g_hEventBufferFull, INFINITE);
  48.         //互斥的访问缓冲区
  49.         EnterCriticalSection(&g_cs);
  50.         SetConsoleColor(FOREGROUND_GREEN);
  51.         printf(”  消费者从缓冲区中取数据%d\n”, g_Buffer);
  52.         SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  53.         if (g_Buffer == END_PRODUCE_NUMBER)
  54.             flag = false;
  55.         LeaveCriticalSection(&g_cs);
  57.         //通知缓冲区已为空
  58.         SetEvent(g_hEventBufferEmpty);
  60.         Sleep(10); //some other work should to do
  61.     }
  62.     return 0;
  63. }
  64. int main()
  65. {
  66.     printf(”  生产者消费者问题   1生产者 1消费者 1缓冲区\n”);
  67.     printf(” – by MoreWindows( http://blog.csdn.net/MoreWindows ) –\n\n”);
  69.     InitializeCriticalSection(&g_cs);
  70.     //创建二个自动复位事件，一个表示缓冲区是否为空，另一个表示缓冲区是否已经处理
  71.     g_hEventBufferEmpty = CreateEvent(NULL, FALSE, TRUE, NULL);
  72.     g_hEventBufferFull = CreateEvent(NULL, FALSE, FALSE, NULL);
  74.     const int THREADNUM = 2;
  75.     HANDLE hThread[THREADNUM];
  77.     hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);
  78.     hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
  79.     WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);
  80.     CloseHandle(hThread[0]);
  81.     CloseHandle(hThread[1]);
  83.     //销毁事件和关键段
  84.     CloseHandle(g_hEventBufferEmpty);
  85.     CloseHandle(g_hEventBufferFull);
  86.     DeleteCriticalSection(&g_cs);
  87.     return 0;
  88. }

运行结果如下所示：

可以看出生产者与消费者已经是有序的工作了。

 

然后再对这个简单生产者消费者问题加大难度。将消费者改成2个，缓冲池改成拥有4个缓冲区的大缓冲池。

如何来思考了这个问题了？首先根据上面分析的二点，可以知道生产者和消费者由一个变成多个的影响不大，唯一要注意的是缓冲池变大了，回顾一下《秒杀多线程第八篇 经典线程同步 信号量Semaphore》中的信号量，不难得出用二个信号量就可以解决这种缓冲池有多个缓冲区的情况——用一个信号量A来记录为空的缓冲区个数，另一个信号量B记录非空的缓冲区个数，然后生产者等待信号量A，消费者等待信号量B就可以了。因此可以仿照上面的代码来实现复杂生产者消费者问题，示例代码如下：

[cpp] view plaincopy

  1. //1生产者 2消费者 4缓冲区
  2. #include <stdio.h>
  3. #include <process.h>
  4. #include <windows.h>
  5. //设置控制台输出颜色
  6. BOOL SetConsoleColor(WORD wAttributes)
  7. {
  8.     HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
  9.     if (hConsole == INVALID_HANDLE_VALUE)
  10.         return FALSE;
  12.     return SetConsoleTextAttribute(hConsole, wAttributes);
  13. }
  14. const int END_PRODUCE_NUMBER = 8;  //生产产品个数
  15. const int BUFFER_SIZE = 4;          //缓冲区个数
  16. int g_Buffer[BUFFER_SIZE];          //缓冲池
  17. int g_i, g_j;
  18. //信号量与关键段
  19. CRITICAL_SECTION g_cs;
  20. HANDLE g_hSemaphoreBufferEmpty, g_hSemaphoreBufferFull;
  21. //生产者线程函数
  22. unsigned int __stdcall ProducerThreadFun(PVOID pM)
  23. {
  24.     for (int i = 1; i <= END_PRODUCE_NUMBER; i++)
  25.     {
  26.         //等待有空的缓冲区出现
  27.         WaitForSingleObject(g_hSemaphoreBufferEmpty, INFINITE);
  29.         //互斥的访问缓冲区
  30.         EnterCriticalSection(&g_cs);
  31.         g_Buffer[g_i] = i;
  32.         printf(“生产者在缓冲池第%d个缓冲区中投放数据%d\n”, g_i, g_Buffer[g_i]);
  33.         g_i = (g_i + 1) % BUFFER_SIZE;
  34.         LeaveCriticalSection(&g_cs);
  36.         //通知消费者有新数据了
  37.         ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);
  38.     }
  39.     printf(“生产者完成任务，线程结束运行\n”);
  40.     return 0;
  41. }
  42. //消费者线程函数
  43. unsigned int __stdcall ConsumerThreadFun(PVOID pM)
  44. {
  45.     while (true)
  46.     {
  47.         //等待非空的缓冲区出现
  48.         WaitForSingleObject(g_hSemaphoreBufferFull, INFINITE);
  50.         //互斥的访问缓冲区
  51.         EnterCriticalSection(&g_cs);
  52.         SetConsoleColor(FOREGROUND_GREEN);
  53.         printf(”  编号为%d的消费者从缓冲池中第%d个缓冲区取出数据%d\n”, GetCurrentThreadId(), g_j, g_Buffer[g_j]);
  54.         SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  55.         if (g_Buffer[g_j] == END_PRODUCE_NUMBER)//结束标志
  56.         {
  57.             LeaveCriticalSection(&g_cs);
  58.             //通知其它消费者有新数据了(结束标志)
  59.             ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);
  60.             break;
  61.         }
  62.         g_j = (g_j + 1) % BUFFER_SIZE;
  63.         LeaveCriticalSection(&g_cs);
  65.         Sleep(50); //some other work to do
  67.         ReleaseSemaphore(g_hSemaphoreBufferEmpty, 1, NULL);
  68.     }
  69.     SetConsoleColor(FOREGROUND_GREEN);
  70.     printf(”  编号为%d的消费者收到通知，线程结束运行\n”, GetCurrentThreadId());
  71.     SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  72.     return 0;
  73. }
  74. int main()
  75. {
  76.     printf(”  生产者消费者问题   1生产者 2消费者 4缓冲区\n”);
  77.     printf(” – by MoreWindows( http://blog.csdn.net/MoreWindows ) –\n\n”);
  79.     InitializeCriticalSection(&g_cs);
  80.     //初始化信号量,一个记录有产品的缓冲区个数,另一个记录空缓冲区个数.
  81.     g_hSemaphoreBufferEmpty = CreateSemaphore(NULL, 4, 4, NULL);
  82.     g_hSemaphoreBufferFull  = CreateSemaphore(NULL, 0, 4, NULL);
  83.     g_i = 0;
  84.     g_j = 0;
  85.     memset(g_Buffer, 0, sizeof(g_Buffer));
  87.     const int THREADNUM = 3;
  88.     HANDLE hThread[THREADNUM];
  89.     //生产者线程
  90.     hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);
  91.     //消费者线程
  92.     hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
  93.     hThread[2] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
  94.     WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);
  95.     for (int i = 0; i < THREADNUM; i++)
  96.         CloseHandle(hThread[i]);
  98.     //销毁信号量和关键段
  99.     CloseHandle(g_hSemaphoreBufferEmpty);
  100.     CloseHandle(g_hSemaphoreBufferFull);
  101.     DeleteCriticalSection(&g_cs);
  102.     return 0;
  103. }

运行结果如下图所示：

输出结果证明各线程的同步和互斥已经完成了。

 

至此，生产者消费者问题已经圆满的解决了，下面作个总结：

1．首先要考虑生产者与消费者对缓冲区操作时的互斥。

2．不管生产者与消费者有多少个，缓冲池有多少个缓冲区。都只有二个同步过程——分别是生产者要等待有空缓冲区才能投放产品，消费者要等待有非空缓冲区才能去取产品。