YS的笔记 - 用户贡献 [zh-cn]

首页

2023-06-15T06:00:14Z

Yaosong：/* 菜单 */

==菜单==

*[[PHP]]
*[[Python]]
*[[Rabbitmq]]
*[[钉钉]]
*[[Nginx]]
*[[Linux]]
*[[windows]]
*[[Laravel]]
*[[微信X5调试]]
*[[vim]]
*[[办事]]
*[[nas]]
*[[Golang]]

==工具==

*[http://rufus.ie/ u盘引导盘制作工具]
*[https://github.com/Genymobile/scrcpy 手机投屏工具]

<seo titlemode="append" keywords="php python linux 微信" description="开发技术笔记"></seo>

Nginx

2023-06-15T05:59:25Z

Yaosong：创建页面，内容为“==location的优先级== 在Nginx中，location的优先级顺序如下： *精确匹配（=） *前缀字符串匹配（^~） *正则表达式匹配（~和~*） *…”

==location的优先级==

在Nginx中，location的优先级顺序如下：

*精确匹配（=）
*前缀字符串匹配（^~）
*正则表达式匹配（~和~*）
*前缀字符串匹配

首先，Nginx会检查精确匹配的location。如果找到精确匹配，则搜索终止。如果没有找到精确匹配，则Nginx会检查前缀字符串匹配的location。在这些location中，选择并记住最长匹配前缀的location。如果最长匹配前缀位置具有“^〜”修饰符，则不检查正则表达式。

然后，按照它们在配置文件中出现的顺序检查正则表达式。正则表达式的搜索在第一个匹配处终止，并使用相应的配置。如果没有找到与正则表达式匹配，则使用先前记住的前缀位置的配置。

首页

2023-01-13T09:45:34Z

Yaosong：/* 菜单 */

==菜单==

*[[PHP]]
*[[Python]]
*[[Rabbitmq]]
*[[钉钉]]
*[[Linux]]
*[[windows]]
*[[Laravel]]
*[[微信X5调试]]
*[[vim]]
*[[办事]]
*[[nas]]
*[[Golang]]

==工具==

*[http://rufus.ie/ u盘引导盘制作工具]
*[https://github.com/Genymobile/scrcpy 手机投屏工具]

<seo titlemode="append" keywords="php python linux 微信" description="开发技术笔记"></seo>

Golang

2023-01-13T09:40:20Z

Yaosong：

性能分析工具pprof
<code>pprofFile, pprofErr := os.Create("cpu.pprof")</code>
<code>if pprofErr != nil {</code>
<code>log.Fatal(pprofErr)</code>
<code>}</code>
<code>pprof.StartCPUProfile(pprofFile)</code>
<code>defer pprof.StopCPUProfile()</code>

<code>go tool pprof -http=":8000" ./cpu.pprof</code>

打印编译器转义分析决策

<code>go build -gcflags=-m demo.go</code>

Golang

2023-01-13T09:31:09Z

Yaosong：

<blockquote></blockquote>
<code>pprofFile, pprofErr := os.Create("cpu.pprof")</code>
<code>if pprofErr != nil {</code>
<code>log.Fatal(pprofErr)</code>
<code>}</code>
<code>pprof.StartCPUProfile(pprofFile)</code>
<code>defer pprof.StopCPUProfile()</code>

<code>go tool pprof -http=":8000" ./cpu.pprof</code>

<code>go build -gcflags=-m demo.go</code>

Golang

2023-01-13T09:30:15Z

Yaosong：创建页面，内容为“<br /><blockquote></blockquote> <code>pprofFile, pprofErr := os.Create("cpu.pprof")</code> <code>if pprofErr != nil {</code> <code>log.Fatal(pprofErr)</code>…”

<br /><blockquote></blockquote>
<code>pprofFile, pprofErr := os.Create("cpu.pprof")</code>

<code>if pprofErr != nil {</code>

<code>log.Fatal(pprofErr)</code>

<code>}</code>

<code>pprof.StartCPUProfile(pprofFile)</code>

<code>defer pprof.StopCPUProfile()</code>

<code>go tool pprof -http=":8000" ./cpu.pprof</code>

<code>go build -gcflags=-m demo.go</code>

办事

2020-01-08T09:22:32Z

Yaosong：

[http://ggfw.rsj.sh.gov.cn/ 上海市人力资源和社会保障局公共服务平台]

[https://gaj.sh.gov.cn/wa/login.jsp 上海互联网安全综合服务网]

== 网站维护 ==
[https://gaj.sh.gov.cn/wa/ 上海公安备案]

首页

2020-01-08T09:19:10Z

Yaosong：

== 菜单 ==
* [[PHP]]
* [[Python]]
* [[Rabbitmq]]
* [[钉钉]]
* [[Linux]]
* [[windows]]
* [[Laravel]]
* [[微信X5调试]]
* [[vim]]
* [[办事]]
* [[nas]]

== 工具 ==
* [http://rufus.ie/ u盘引导盘制作工具]
* [https://github.com/Genymobile/scrcpy 手机投屏工具]

<seo titlemode ="append" keywords="php python linux 微信" description ="开发技术笔记"></seo>

办事

2020-01-04T08:16:46Z

Yaosong：

[http://ggfw.rsj.sh.gov.cn/ 上海市人力资源和社会保障局公共服务平台]

[https://gaj.sh.gov.cn/wa/login.jsp 上海互联网安全综合服务网]

路由器

2019-12-28T06:11:10Z

Yaosong：创建页面，内容为“小米路由器ss 小米路由器ssh权限安装misstar工具箱 https://bbs.misstar.com/?thread-6.htm 用不了问题修复 https://bbs.misstar.com/?thread-191…”

小米路由器ss

小米路由器ssh权限

安装misstar工具箱
https://bbs.misstar.com/?thread-6.htm

用不了问题修复
https://bbs.misstar.com/?thread-191.htm

首页

2019-12-25T15:06:25Z

Yaosong：

== 菜单 ==
* [[PHP]]
* [[Python]]
* [[Rabbitmq]]
* [[钉钉]]
* [[Linux]]
* [[windows]]
* [[Laravel]]
* [[微信X5调试]]
* [[vim]]
* [[办事]]
* [[nas]]

== 工具 ==
* [http://rufus.ie/ u盘引导盘制作工具]
* [https://github.com/Genymobile/scrcpy 手机投屏工具]

<seo title ="首页" titlemode ="append" keywords="php python linux 微信" description ="开发技术笔记"></seo>

Nas

2019-12-10T14:44:54Z

Yaosong：

记录下qnap ts453bmini的装机流程。

* 公网访问
* 使用自己的域名做ddns

# 购买
## 京东买的ts453bmini
## 东芝TR200 480G ssd。机器不带硬盘，买了个ssd放第一个盘位，打算放常用数据，后面再加机械硬盘。
# 插上电之后，扫码打开网页，按提示一步一步操作就可以了。
# 安装完成后，在同一个路由器下访问机器的ip，就可以访问了。
## 这里遇到一个问题，区域设置成中国，应用商店打不开，然后改成全球就可以了。
# 外网访问
## 装完之后局域网可以访问了，但是想在不在家的时候访问qnap，就得搞定外网访问了。可以通过设置dmz主机搞定。
## 我是上海电信的宽带，光猫是悦me网关（F450G），机器上有管理员账号(useradmin)密码可以登录网关，但是里面没有dmz的设置选项。然后这里需要找到电信客服报修，跟负责维修的师傅说明情况，师傅会把超级管理员密码发给你，然后就可以用超级管理员账号(用户名:telecomadmin)登录了。应用-》高级NAT设置-》DMZ设置。[[文件:F450Gdmz设置.png|600px]]
## 这里有一个坑，设置完之后通过公网ip访问一直没反应，最后突然发现用手机4G网络访问却是正常访问的。不知道是个什么原理，但是原因确实是在自己的网络下访问自己的公网ip请求是到不了自己的网络上的。。。
## 然后是端口，电信应该是拦截了80和443端口的，所以必需改成其他的端口号才能访问。在qts（qnap的操作系统）系统的控制台-》常规设置-》系统管理-》系统端口里改成自己想要的端口，我是改成5000。
## 所有操作完之后，外网应该就可以访问了，不在家也能操作自己的nas了~
# 家里的ip可能经常会变，然后可以在qts系统的控制台-》myQNAPcloud云服务-》My DDNS 里面，开启ddns服务
# 如果嫌他的域名不要记的话，可以自己注册一个域名，然后qts系统的控制台-》网络与虚拟交换机 -》 DDNS 里面，新增一个自己的DDNS，动态解析域名到家里的ip~
## 我用的是阿里云注册的域名
## 因为我有一台云服务器，所以采用的是nas-》我的服务器-》修改阿里云域名解析的方式。其实可以直接在nas上写个脚本调用阿里云的域名解析接口修改。
## pip install aliyun-python-sdk-alidns
## python脚本dns.py:
<nowiki>
#!/usr/bin/env python
#coding=utf-8

from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.acs_exception.exceptions import ClientException
from aliyunsdkcore.acs_exception.exceptions import ServerException
from aliyunsdkalidns.request.v20150109.DescribeDomainRecordsRequest import DescribeDomainRecordsRequest
from aliyunsdkalidns.request.v20150109.UpdateDomainRecordRequest import UpdateDomainRecordRequest
import json;
import sys

client = AcsClient('阿里云accessId', '阿里云secret', 'cn-hangzhou')

if len(sys.argv) != 2:
print('参数错误')
exit()

def setVal(recordId, rr, strType, ip):
request = UpdateDomainRecordRequest()
request.set_accept_format('json')

request.set_RecordId(recordId)
request.set_RR(rr)
request.set_Type(strType)
request.set_Value(ip)

response = client.do_action_with_exception(request)
# python2: print(response)
print(str(response, encoding='utf-8'))

ip = sys.argv[1]

request = DescribeDomainRecordsRequest()
request.set_accept_format('json')

request.set_DomainName("yaosong.live")

response = client.do_action_with_exception(request)
# python2: print(response)
# print(str(response, encoding='utf-8'))
lists = json.loads(str(response, encoding='utf-8'))
for i in lists['DomainRecords']['Record']:
if i['DomainName'] == 'yaosong.live' and i['RR'] == 'nas' and i['Value'] != ip:
setVal(i['RecordId'], i['RR'], i['Type'], ip)
# setVal(i[''])
break;

</nowiki>
## 执行：python3 dns.py IP地址
## 脚本测试没有问题之后，部署一个http服务，能够接收nas发出的ddns请求，我的是<code>https://xxx.yaosong.live/nasdns?hostname=%HOST%&username=%USER%&password=%PASS%&IP=%IP%</code>，服务里面执行python脚本就可以了。
## 我的域名是nas.yaosong.live，然后我就可以通过http://nas.yaosong.live:5000访问我的nas了~

最后，在局域网内就不要访问公网ip或者域名了，访问内网ip吧...

Nas

2019-12-10T14:43:22Z

Yaosong：

记录下qnap ts453bmini的装机流程。

# 购买
## 京东买的ts453bmini
## 东芝TR200 480G ssd。机器不带硬盘，买了个ssd放第一个盘位，打算放常用数据，后面再加机械硬盘。
# 插上电之后，扫码打开网页，按提示一步一步操作就可以了。
# 安装完成后，在同一个路由器下访问机器的ip，就可以访问了。
## 这里遇到一个问题，区域设置成中国，应用商店打不开，然后改成全球就可以了。
# 外网访问
## 装完之后局域网可以访问了，但是想在不在家的时候访问qnap，就得搞定外网访问了。可以通过设置dmz主机搞定。
## 我是上海电信的宽带，光猫是悦me网关（F450G），机器上有管理员账号(useradmin)密码可以登录网关，但是里面没有dmz的设置选项。然后这里需要找到电信客服报修，跟负责维修的师傅说明情况，师傅会把超级管理员密码发给你，然后就可以用超级管理员账号(用户名:telecomadmin)登录了。应用-》高级NAT设置-》DMZ设置。[[文件:F450Gdmz设置.png|600px]]
## 这里有一个坑，设置完之后通过公网ip访问一直没反应，最后突然发现用手机4G网络访问却是正常访问的。不知道是个什么原理，但是原因确实是在自己的网络下访问自己的公网ip请求是到不了自己的网络上的。。。
## 然后是端口，电信应该是拦截了80和443端口的，所以必需改成其他的端口号才能访问。在qts（qnap的操作系统）系统的控制台-》常规设置-》系统管理-》系统端口里改成自己想要的端口，我是改成5000。
## 所有操作完之后，外网应该就可以访问了，不在家也能操作自己的nas了~
# 家里的ip可能经常会变，然后可以在qts系统的控制台-》myQNAPcloud云服务-》My DDNS 里面，开启ddns服务
# 如果嫌他的域名不要记的话，可以自己注册一个域名，然后qts系统的控制台-》网络与虚拟交换机 -》 DDNS 里面，新增一个自己的DDNS，动态解析域名到家里的ip~
## 我用的是阿里云注册的域名
## 因为我有一台云服务器，所以采用的是nas-》我的服务器-》修改阿里云域名解析的方式。其实可以直接在nas上写个脚本调用阿里云的域名解析接口修改。
## pip install aliyun-python-sdk-alidns
## python脚本dns.py:
<nowiki>
#!/usr/bin/env python
#coding=utf-8

from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.acs_exception.exceptions import ClientException
from aliyunsdkcore.acs_exception.exceptions import ServerException
from aliyunsdkalidns.request.v20150109.DescribeDomainRecordsRequest import DescribeDomainRecordsRequest
from aliyunsdkalidns.request.v20150109.UpdateDomainRecordRequest import UpdateDomainRecordRequest
import json;
import sys

client = AcsClient('阿里云accessId', '阿里云secret', 'cn-hangzhou')

if len(sys.argv) != 2:
print('参数错误')
exit()

def setVal(recordId, rr, strType, ip):
request = UpdateDomainRecordRequest()
request.set_accept_format('json')

request.set_RecordId(recordId)
request.set_RR(rr)
request.set_Type(strType)
request.set_Value(ip)

response = client.do_action_with_exception(request)
# python2: print(response)
print(str(response, encoding='utf-8'))

ip = sys.argv[1]

request = DescribeDomainRecordsRequest()
request.set_accept_format('json')

request.set_DomainName("yaosong.live")

response = client.do_action_with_exception(request)
# python2: print(response)
# print(str(response, encoding='utf-8'))
lists = json.loads(str(response, encoding='utf-8'))
for i in lists['DomainRecords']['Record']:
if i['DomainName'] == 'yaosong.live' and i['RR'] == 'nas' and i['Value'] != ip:
setVal(i['RecordId'], i['RR'], i['Type'], ip)
# setVal(i[''])
break;

</nowiki>
## 执行：python3 dns.py IP地址
## 脚本测试没有问题之后，部署一个http服务，能够接收nas发出的ddns请求，我的是<code>https://xxx.yaosong.live/nasdns?hostname=%HOST%&username=%USER%&password=%PASS%&IP=%IP%</code>，服务里面执行python脚本就可以了。
## 我的域名是nas.yaosong.live，然后我就可以通过http://nas.yaosong.live:5000访问我的nas了~

最后，在局域网内就不要访问公网ip或者域名了，访问内网ip吧...

Nas

2019-12-10T14:38:28Z

Yaosong：创建页面，内容为“记录下qnap ts453bmini的装机流程。 # 购买 ## 京东买的ts453bmini ## 东芝TR200 480G ssd。机器不带硬盘，买了个ssd放第一个盘位，打算…”

文件:F450Gdmz设置.png

2019-12-10T14:05:31Z

Yaosong：

首页

2019-12-10T13:31:02Z

Yaosong：/* 菜单 */

== 菜单 ==
* [[PHP]]
* [[Python]]
* [[Rabbitmq]]
* [[钉钉]]
* [[Linux]]
* [[windows]]
* [[Laravel]]
* [[微信X5调试]]
* [[vim]]
* [[办事]]
* [[nas]]

== 工具 ==
* [http://rufus.ie/ u盘引导盘制作工具]

<seo title ="首页" titlemode ="append" keywords="php python linux 微信" description ="开发技术笔记"></seo>

算法

2019-11-28T09:37:27Z

Yaosong：创建页面，内容为“== 常用限流算法设计 == * 计数器法 * 漏桶算法 * 令牌桶算法”

== 常用限流算法设计 ==
* 计数器法
* 漏桶算法
* 令牌桶算法

Windows

2019-11-27T07:57:06Z

Yaosong：/* PHP-FastCGI on Windows */

== 查看80端口占用的程序 ==
# <code>netstat -aon|findstr "80"</code>
# 拿到上一步返回的pid，<code>tasklist|findstr {PID}</code>

== 切换hosts工具 ==
* SwitchHosts! 切换hosts

== PHP-FastCGI on Windows ==
在windows环境下使用RunHiddenConsole运行php-cgi。
[https://www.nginx.com/resources/wiki/start/topics/examples/phpfastcgionwindows/]

# 安装nginx windows版本[https://windows.php.net/]
# 安装php windows版本[https://windows.php.net/] [https://windows.php.net/downloads/releases/]
# 安装RunHiddenConsole[https://redmine.lighttpd.net/attachments/download/660/RunHiddenConsole.zip]

start-php-fcgi.bat
<nowiki>
@ECHO OFF
ECHO Starting PHP FastCGI...
taskkill /F /IM php-cgi.exe
RunHiddenConsole.exe php-cgi.exe -b 127.0.0.1:9000 -c d:\dev\php-5.6.9\php.ini
RunHiddenConsole.exe php-cgi.exe -b 127.0.0.1:9001 -c d:\dev\php-5.6.9\php.ini
RunHiddenConsole.exe php-cgi.exe -b 127.0.0.1:9002 -c d:\dev\php-5.6.9\php.ini
RunHiddenConsole.exe php-cgi.exe -b 127.0.0.1:9003 -c d:\dev\php-5.6.9\php.ini
</nowiki>

start-nginx.bat
<nowiki>
:: 关闭回显，即执行本脚本时不显示执行路径和命令，直接显示结果
@echo off
rem @author luwuer

color f8
set NGINX_DIR=D:\dev\nginx\

cd %NGINX_DIR%
:INFO
echo.
echo --------------------- 进程列表 ---------------------
tasklist|findstr /i "nginx.exe"
if errorlevel 1 echo nginx未启动
echo --------------------- 进程列表 ---------------------

echo.
echo. 1. 启动Nginx
echo. 2. 关闭Nginx
echo. 3. 重启Nginx
echo. 4. 退出
echo.
echo 请输入功能序号：
set /p id=
if "%id%"=="1" goto START
if "%id%"=="2" goto STOP
if "%id%"=="3" goto RESTART
if "%id%"=="4" exit
pause

:START
if exist "%NGINX_DIR%nginx.exe" (
cd /d %NGINX_DIR%
start "" nginx.exe
echo 启动成功
) else (
echo "%NGINX_DIR%nginx.exe不存在"
)
goto INFO

:STOP
taskkill /F /IM nginx.exe > nul
echo 已关闭所有nginx进程
goto INFO

:RESTART
taskkill /F /IM nginx.exe > nul
if exist "%NGINX_DIR%nginx.exe" (
cd /d %NGINX_DIR%
start "" nginx.exe
) else (
echo "%NGINX_DIR%nginx.exe不存在"
)
echo 已重启
goto INFO

goto :eof
</nowiki>

办事

2019-11-18T10:15:19Z

Yaosong：创建页面，内容为“ [http://ggfw.rsj.sh.gov.cn/ 上海市人力资源和社会保障局公共服务平台]”

[http://ggfw.rsj.sh.gov.cn/ 上海市人力资源和社会保障局公共服务平台]

首页

2019-11-18T10:14:32Z

Yaosong：

== 菜单 ==
* [[PHP]]
* [[Python]]
* [[Rabbitmq]]
* [[钉钉]]
* [[Linux]]
* [[windows]]
* [[Laravel]]
* [[微信X5调试]]
* [[vim]]
* [[办事]]

== 工具 ==
* [http://rufus.ie/ u盘引导盘制作工具]

<seo title ="首页" titlemode ="append" keywords="php python linux 微信" description ="开发技术笔记"></seo>

Windows

2019-11-18T10:04:50Z

Yaosong：/* 查看80端口占用的程序 */

== 查看80端口占用的程序 ==
# <code>netstat -aon|findstr "80"</code>
# 拿到上一步返回的pid，<code>tasklist|findstr {PID}</code>

Windows

2019-11-18T10:04:38Z

Yaosong：

== 查看80端口占用的程序 ==
# netstat -aon|findstr "80"
# 拿到上一步返回的pid，<code>tasklist|findstr {PID}</code>

Windows

2019-11-18T10:03:54Z

Yaosong：创建页面，内容为“== 查看80端口占用的程序 == # netstat -aon|findstr "80" # 拿到上一步返回的pid，tasklist|findstr {{PID}}”

== 查看80端口占用的程序 ==
# netstat -aon|findstr "80"
# 拿到上一步返回的pid，tasklist|findstr {{PID}}

首页

2019-11-18T10:01:50Z

Yaosong：/* 菜单 */

== 菜单 ==
* [[PHP]]
* [[Python]]
* [[Rabbitmq]]
* [[钉钉]]
* [[Linux]]
* [[windows]]
* [[Laravel]]
* [[微信X5调试]]
* [[vim]]

== 工具 ==
* [http://rufus.ie/ u盘引导盘制作工具]

<seo title ="首页" titlemode ="append" keywords="php python linux 微信" description ="开发技术笔记"></seo>

Linux

2019-11-18T09:58:59Z

Yaosong：

== 工具 ==

* [[https://stedolan.github.io/jq/ jq]] 一个轻量级且灵活的命令行JSON处理器

* [[https://geoff.greer.fm/ag/ ag]] The Silver Searcher代码搜索工具
* [[https://github.com/yaosonglive/vim .vimrc]] vim制表符换成控制配置

== Nginx ==
* [[Nginx灰度]] cookie实现灰度
* 常见错误
** 413 Request Entity Too Large
**: <code>client_max_body_size 8m;</code>

== 图片压缩 ==
使用imagemagick进行图片压缩
首先安装apt install imagemagick

下面是demo，把再当前路径下的public目录中的图片进行压缩:
<nowiki>
import os

arr = [
'/upload/images/c0d0d881b2d742165999d91ec6380de2.jpg',
'/upload/images/4e16982954bcbe89667ec70f67c02f20.jpg',
]

for i in arr:
try:
# print i
kb = os.path.getsize('./public%s' % i)
newNames = os.path.splitext(i)
strname = '%s_s%s' % newNames
if kb/1024 > 1:
shell = "convert -sample 30%%x30%% ./public%s ./public%s" % (i, strname)
os.system(shell)
# print "update themes set preview='%s' where preview='%s';" % (strname, i)
except Exception,e :
print e
pass

</nowiki>
-resize 是缩小，-sample 是压缩

== 其他 ==
* [[公钥]]

* 终端不能输入中文
*# 先<code>locale -a</code>查看，是否有<code>zh_CN.utf8</code>
*# 如果没有,安装：
*#: centos: yum install glibc-common
*#: ubuntu: apt-get -y install language-pack-zh-hans
*# 重新进入终端，检查环境变量, 如果还是不行，修改环境变量:
*#* LANG=zh_CN.UTF-8
*#* LC_ALL=LC_ALL=zh_CN.UTF-8

== 端口检测 ==
* telnet
:在telnet连接成功后，使用<code>Control +]</code>然后使用<code>Control + D</code>退出它。
:列出所有TCP连接套接字
<nowiki>
telnet localhost 80</nowiki>

* lsof
:监听ipv4进程
<nowiki>
sudo lsof -n -i4TCP:5672 | grep LISTEN</nowiki>
:IPv6的程序：
<nowiki>
sudo lsof -n -i6TCP:5672 | grep LISTEN</nowiki>

* ss
:使用ss显示使用IPv4及其操作系统进程的侦听TCP套接字：
<nowiki>
sudo ss --tcp -f inet --listening --numeric --processes</nowiki>
:同样，对于使用IPv6的TCP套接字：
<nowiki>
sudo ss --tcp -f inet6 --listening --numeric --processes</nowiki>

* netstat
<nowiki>
sudo netstat --all --numeric --tcp --programs</nowiki>

== nginx fpm connect() to unix:xxx failed. http 502 ==
https://forum.nginx.org/read.php?11,215606,215606#msg-215606

1）调高nginx和php-fpm中的backlog

2）增加sock文件和php-fpm实例数

pm

pm.max_children

listen.backlog = 4096

* nginx

<nowiki>
server {
listen 80 backlog=1024;
... ...
}
</nowiki>

开多个fpm

== 终端中文输入 ==
* ubuntu
locale-gen zh_CN.UTF-8

dpkg-reconfigure locales

== ubuntu 阿里云源 ==
ubuntu 18.04 (bionic) 配置 opsx 安装源
https://opsx.alibaba.com/guide?lang=zh-CN&document=69a2341e-801e-11e8-8b5a-00163e04cdbb

常见问题

2019-10-28T05:24:10Z

Yaosong：/* fpm */

== cookie 和 session 的区别 ==
* 作用范围不同，Cookie 保存在客户端（浏览器），Session 保存在服务器端。
* 存取方式的不同，Cookie 只能保存 ASCII，Session 可以存任意数据类型，一般情况下我们可以在 Session 中保持一些常用变量信息，比如说 UserId 等。
* 有效期不同，Cookie 可设置为长时间保持，比如我们经常使用的默认登录功能，Session 一般失效时间较短，客户端关闭或者 Session 超时都会失效。
* 隐私策略不同，Cookie 存储在客户端，比较容易遭到不法获取，早期有人将用户的登录名和密码存储在 Cookie 中导致信息被窃取；Session 存储在服务端，安全性相对 Cookie 要好一些。
* 存储大小不同，单个 Cookie 保存的数据不能超过 4K，Session 可存储数据远高于 Cookie。

分布式session

ip_hash
Session 复制
缓存中间件

== post 和 get 的区别 ==
https://www.w3school.com.cn/tags/html_ref_httpmethods.asp

GET 用于获取信息，是无副作用的，是幂等的，且可缓存
POST 用于修改服务器上的数据，有副作用，非幂等，不可缓存
* 安全？post请求不会保留在浏览器历史记录中

{|class="wikitable"
!colspan="2"|GET
|POST
|-
|后退按钮/刷新
| 无害
|数据会被重新提交（浏览器应该告知用户数据会被重新提交）。
|-
|书签
|可收藏为书签
|不可收藏为书签
|-
|缓存
|能被缓存
|不能缓存
|-
|编码类型
| application/x-www-form-urlencoded
|application/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。
|-
|历史
|参数保留在浏览器历史中。
|参数不会保存在浏览器历史中。
|-
|对数据长度的限制
|是的。当发送数据时，GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。
|无限制。
|-
|对数据类型的限制
|只允许 ASCII 字符。
|没有限制。也允许二进制数据。
|-
|安全性
|与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。
在发送密码或其他敏感信息时绝不要使用 GET ！
|POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
|-
|可见性
|数据在 URL 中对所有人都是可见的。
|数据不会显示在 URL 中。
|}

== 转发和重定向的区别 ==
转发

1. 是服务器内部的重定向，服务器直接访问目标地址的 url网址，把里面的东西读取出来，但是客户端并不知道，因此用forward的话，客户端浏览器的网址是不会发生变化的。

2. 关于request: 由于在整个定向的过程中用的是同一个request，因此forward会将request的信息带到被重定向的地址中。

重定向

1.是客户端的重定向，是完全的跳转。即服务器返回的一个url给客户端浏览器，然后客户端浏览器会重新发送一次请求，到新的url里面，因此浏览器中显示的url网址会发生变化。

2.因为这种方式比forward多了一次网络请求，因此效率会低于forward。

== 堆栈区别 ==
== 并发和并行的区别 ==
行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

== 索引 ==
=== 不走索引 ===
=== 行级锁和表级锁 ===

行级锁定的优点：

· 当在许多线程中访问不同的行时只存在少量锁定冲突。

· 回滚时只有少量的更改。

· 可以长时间锁定单一的行。

行级锁定的缺点：

· 比页级或表级锁定占用更多的内存。

· 当在表的大部分中使用时，比页级或表级锁定速度慢，因为你必须获取更多的锁。

· 如果你在大部分数据上经常进行GROUP BY操作或者必须经常扫描整个表，比其它锁定明显慢很多。

· 用高级别锁定，通过支持不同的类型锁定，你也可以很容易地调节应用程序，因为其锁成本小于行级锁定。

== 存储引擎 ==
* InnoDB
== 数据库，事务，隔离级别，存储引擎 ==
* 数据库，三大范式
== redis，有什么优势 -memcache对比 ==
数据存储位置
* redis：内存、磁盘(数据持久化)
* memcache: 内存

存储数据的类型（都是键值对的形式）值的类型：
* redis：list、set、hash、string、zset等
* memcache：string

== http\https ==
* 默认端口不同80：443
* https需要颁发证书
* HTTPS协议的安全性更高
* https缺点
** 速度慢
** 服务器成本

== 数据库的存储引擎应用场景，索引结构 ==

MyISAM表使用B型树索引。读取场景下性能好，表锁，不能事务

InnoDB是为处理巨大数据量时的最大性能设计。B树。由于是行锁，写入、更新速度可能会快。

MEMORY表被存储在内存中，且默认使用哈希索引

为什么索引结构默认使用B-Tree，而不是hash，二叉树，红黑树？
* hash：虽然可以快速定位，但是没有顺序，IO复杂度高。
* 二叉树：树的高度不均匀，不能自平衡，查找效率跟数据有关（树的高度），并且IO代价高。
* 红黑树：树的高度随着数据量增加而增加，IO代价高。

为什么建议使用自增长主键作为索引。

结合B+Tree的特点，自增主键是连续的，在插入过程中尽量减少页分裂，即使要进行页分裂，也只会分裂很少一部分。并且能减少数据的移动，每次插入都是插入到最后。总之就是减少分裂和移动的频率。

== 大数据量的优化 ==
* 分区、分表、分库

== 设计一个权限系统 ==
== 算法题 ==
== 红黑树 ==
== 多线程，sleep，wait，yield ==
== restful ==
== 设计模式，单例模式，适配器模式 ==
== 操作系统，死锁 ==
== 快排时间复杂度 ==
== nginx可承受的压力 ==
== 项目 ==
* 项目难点
* 架构优化
* 难点
* 主要业务
== 服务调用超时可能由什么造成 ==

* 网络问题，是否繁忙？
* cpu、内存排查，cpu消耗高，处理不过来
* 服务端有没有收到请求，看请求响应时间
* 客服端网络、cpu等有问题

== 进程间的通信方式 ==
== fpm ==
* 进程管理方式pm，静态、动态。
* 合适的超时时间request_terminate_timeout、max_execution_time
* 看服务器性能，设置进程数量max_children
* fpm进程处理最大请求数max_requests

== nginx ==

* worker_processes 8; #nginx进程数，建议按照cpu数目来指定，一般为它的倍数,平时设置为2倍。

* 静态资源缓存

* nginx打开文件的最大个数

* buffer：如果buffer太小，Nginx会不停的写一些临时文件，这样会导致磁盘不停的去读写

== php array 结构 ==

hashtable+映射表的方式

hash=>映射表=>bucket

映射表与bucket长度相同

hash冲突的情况：链地址法。next设置为相同hash的索引，然后在映射表里的值替换成当前元素在bucket中的位置。

== 处理负载，高并发？==

# HTML静态化
效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。
# 图片服务器分离
把图片单独存储，尽量减少图片等大流量的开销，可以放在一些相关的平台上，如七牛等
# 数据库集群和库表散列及缓存
数据库的并发连接为100，一台数据库远远不够，可以从读写分离、主从复制，数据库集群方面来着手。另外尽量减少数据库的访问，可以使用缓存数据库如memcache、redis。
# 镜像：
尽量减少下载，可以把不同的请求分发到多个镜像端。
# 负载均衡：
Apache的最大并发连接为1500，只能增加服务器，可以从硬件上着手，如F5服务器。当然硬件的成本比较高，我们往往从软件方面着手。

== Laravel请求生命周期 ==

#、Laravel 采用了单一入口模式，应用的所有请求入口都是 public/index.php 文件。
#、注册类文件自动加载器 : Laravel通过 composer 进行依赖管理，无需开发者手动导入各种类文件，而由自动加载器自行导入。
#、创建服务容器：从 bootstrap/app.php 文件中取得 Laravel 应用实例 $app (服务容器)。
#、创建 HTTP / Console 内核：传入的请求会被发送给 HTTP 内核或者 console 内核进行处理
#、载入服务提供者至容器：在内核引导启动的过程中最重要的动作之一就是载入服务提供者到你的应用，服务提供者负责引导启动框架的全部各种组件，例如数据库、队列、验证器以及路由组件。
#、分发请求：一旦应用完成引导和所有服务提供者都注册完成，Request 将会移交给路由进行分发。路由将分发请求给一个路由或控制器，同时运行路由指定的中间件

https://blog.csdn.net/wuhuagu_wuhuaguo/article/details/80637277

== php生命周期 ==
# 模块初始化阶段 --- php_module_startup()
这个阶段主要进行php框架、zend引擎的初始化操作。这个阶段一般是在SAPI启动时执行一次，对于FPM而言，就是在fpm的master进行启动时执行的。php加载每个扩展的代码并调用其模块初始化例程（MINIT），进行一些模块所需变量的申请,内存分配等。
# 请求初始化阶段 --- php_request_startup()
当一个页面请求发生时，在请求处理前都会经历的一个阶段。对于fpm而言，是在worker进程accept一个请求并读取、解析完请求数据后的一个阶段。在这个阶段内，SAPI层将控制权交给PHP层，PHP初始化本次请求执行脚本所需的环境变量。
# 执行脚本阶段 --- php_execute_script()
php代码解析执行的过程。Zend引擎接管控制权，将php脚本代码编译成opcodes并顺次执行
# 请求关闭阶段 --- php_request_shutdown()
请求处理完后就进入了结束阶段，PHP就会启动清理程序。这个阶段，将flush输出内容、发送http响应内容等，然后它会按顺序调用各个模块的RSHUTDOWN方法。 RSHUTDOWN用以清除程序运行时产生的符号表，也就是对每个变量调用unset函数。
# 模块关闭阶段 --- php_module_shutdown()
该阶段在SAPI关闭时执行，与模块初始化阶段对应，这个阶段主要是进行资源的清理、php各模块的关闭操作，同时，将回调各扩展的module shutdown钩子函数。这是发生在所有请求都已经结束之后，例如关闭fpm的操作。（这个是对于CGI和CLI等SAPI，没有“下一个请求”，所以SAPI立刻开始关闭。）

== 504问题排查 ==
Nginx 504 Gateway Time-out的含义是所请求的网关没有请求到，简单来说就是没有请求到可以执行的PHP-CGI

* 问题排查：nginx错误日志，fpm日志，应用日志。
** nginx作为调用方交由php处理的任务长时间没有返回、php作为服务提供者，严重耗时，长时间延迟。
** php-fpm模式下,php处理耗时比较长任务时，会发生堵塞。
* 解决
** 修改配置，最大内存，执行时间。。。
** 如果是数据库耗时，优化数据库结构，比如加索引
** 如果是程序耗时，可以采用异步的方法，

== laravel orm加全局条件? ==

# 实现Illuminate\Database\Eloquent\ScopeInterface接口，apply方法
# 重写boot方法， static::addGlobalScope(new ScopeName);

== laravel 事件 ==
# 创建事件、监听器
# EventServiceProvider中注册
# event函数调用

常见问题

2019-10-28T05:06:05Z

Yaosong：

== cookie 和 session 的区别 ==
* 作用范围不同，Cookie 保存在客户端（浏览器），Session 保存在服务器端。
* 存取方式的不同，Cookie 只能保存 ASCII，Session 可以存任意数据类型，一般情况下我们可以在 Session 中保持一些常用变量信息，比如说 UserId 等。
* 有效期不同，Cookie 可设置为长时间保持，比如我们经常使用的默认登录功能，Session 一般失效时间较短，客户端关闭或者 Session 超时都会失效。
* 隐私策略不同，Cookie 存储在客户端，比较容易遭到不法获取，早期有人将用户的登录名和密码存储在 Cookie 中导致信息被窃取；Session 存储在服务端，安全性相对 Cookie 要好一些。
* 存储大小不同，单个 Cookie 保存的数据不能超过 4K，Session 可存储数据远高于 Cookie。

分布式session

ip_hash
Session 复制
缓存中间件

== post 和 get 的区别 ==
https://www.w3school.com.cn/tags/html_ref_httpmethods.asp

GET 用于获取信息，是无副作用的，是幂等的，且可缓存
POST 用于修改服务器上的数据，有副作用，非幂等，不可缓存
* 安全？post请求不会保留在浏览器历史记录中

{|class="wikitable"
!colspan="2"|GET
|POST
|-
|后退按钮/刷新
| 无害
|数据会被重新提交（浏览器应该告知用户数据会被重新提交）。
|-
|书签
|可收藏为书签
|不可收藏为书签
|-
|缓存
|能被缓存
|不能缓存
|-
|编码类型
| application/x-www-form-urlencoded
|application/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。
|-
|历史
|参数保留在浏览器历史中。
|参数不会保存在浏览器历史中。
|-
|对数据长度的限制
|是的。当发送数据时，GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。
|无限制。
|-
|对数据类型的限制
|只允许 ASCII 字符。
|没有限制。也允许二进制数据。
|-
|安全性
|与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。
在发送密码或其他敏感信息时绝不要使用 GET ！
|POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
|-
|可见性
|数据在 URL 中对所有人都是可见的。
|数据不会显示在 URL 中。
|}

== 转发和重定向的区别 ==
转发

1. 是服务器内部的重定向，服务器直接访问目标地址的 url网址，把里面的东西读取出来，但是客户端并不知道，因此用forward的话，客户端浏览器的网址是不会发生变化的。

2. 关于request: 由于在整个定向的过程中用的是同一个request，因此forward会将request的信息带到被重定向的地址中。

重定向

1.是客户端的重定向，是完全的跳转。即服务器返回的一个url给客户端浏览器，然后客户端浏览器会重新发送一次请求，到新的url里面，因此浏览器中显示的url网址会发生变化。

2.因为这种方式比forward多了一次网络请求，因此效率会低于forward。

== 堆栈区别 ==
== 并发和并行的区别 ==
行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

== 索引 ==
=== 不走索引 ===
=== 行级锁和表级锁 ===

行级锁定的优点：

· 当在许多线程中访问不同的行时只存在少量锁定冲突。

· 回滚时只有少量的更改。

· 可以长时间锁定单一的行。

行级锁定的缺点：

· 比页级或表级锁定占用更多的内存。

· 当在表的大部分中使用时，比页级或表级锁定速度慢，因为你必须获取更多的锁。

· 如果你在大部分数据上经常进行GROUP BY操作或者必须经常扫描整个表，比其它锁定明显慢很多。

· 用高级别锁定，通过支持不同的类型锁定，你也可以很容易地调节应用程序，因为其锁成本小于行级锁定。

== 存储引擎 ==
* InnoDB
== 数据库，事务，隔离级别，存储引擎 ==
* 数据库，三大范式
== redis，有什么优势 -memcache对比 ==
数据存储位置
* redis：内存、磁盘(数据持久化)
* memcache: 内存

存储数据的类型（都是键值对的形式）值的类型：
* redis：list、set、hash、string、zset等
* memcache：string

== http\https ==
* 默认端口不同80：443
* https需要颁发证书
* HTTPS协议的安全性更高
* https缺点
** 速度慢
** 服务器成本

== 数据库的存储引擎应用场景，索引结构 ==

MyISAM表使用B型树索引。读取场景下性能好，表锁，不能事务

InnoDB是为处理巨大数据量时的最大性能设计。B树。由于是行锁，写入、更新速度可能会快。

MEMORY表被存储在内存中，且默认使用哈希索引

为什么索引结构默认使用B-Tree，而不是hash，二叉树，红黑树？
* hash：虽然可以快速定位，但是没有顺序，IO复杂度高。
* 二叉树：树的高度不均匀，不能自平衡，查找效率跟数据有关（树的高度），并且IO代价高。
* 红黑树：树的高度随着数据量增加而增加，IO代价高。

为什么建议使用自增长主键作为索引。

结合B+Tree的特点，自增主键是连续的，在插入过程中尽量减少页分裂，即使要进行页分裂，也只会分裂很少一部分。并且能减少数据的移动，每次插入都是插入到最后。总之就是减少分裂和移动的频率。

== 大数据量的优化 ==
* 分区、分表、分库

== 设计一个权限系统 ==
== 算法题 ==
== 红黑树 ==
== 多线程，sleep，wait，yield ==
== restful ==
== 设计模式，单例模式，适配器模式 ==
== 操作系统，死锁 ==
== 快排时间复杂度 ==
== nginx可承受的压力 ==
== 项目 ==
* 项目难点
* 架构优化
* 难点
* 主要业务
== 服务调用超时可能由什么造成 ==

* 网络问题，是否繁忙？
* cpu、内存排查，cpu消耗高，处理不过来
* 服务端有没有收到请求，看请求响应时间
* 客服端网络、cpu等有问题

== 进程间的通信方式 ==
== fpm ==
* 合适的超时时间request_terminate_timeout、max_execution_time
* 看服务器性能，设置进程数量max_children
* fpm进程处理最大请求数max_requests

== nginx ==

* worker_processes 8; #nginx进程数，建议按照cpu数目来指定，一般为它的倍数,平时设置为2倍。

* 静态资源缓存

* nginx打开文件的最大个数

* buffer：如果buffer太小，Nginx会不停的写一些临时文件，这样会导致磁盘不停的去读写

== php array 结构 ==

hashtable+映射表的方式

hash=>映射表=>bucket

映射表与bucket长度相同

hash冲突的情况：链地址法。next设置为相同hash的索引，然后在映射表里的值替换成当前元素在bucket中的位置。

== 处理负载，高并发？==

# HTML静态化
效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。
# 图片服务器分离
把图片单独存储，尽量减少图片等大流量的开销，可以放在一些相关的平台上，如七牛等
# 数据库集群和库表散列及缓存
数据库的并发连接为100，一台数据库远远不够，可以从读写分离、主从复制，数据库集群方面来着手。另外尽量减少数据库的访问，可以使用缓存数据库如memcache、redis。
# 镜像：
尽量减少下载，可以把不同的请求分发到多个镜像端。
# 负载均衡：
Apache的最大并发连接为1500，只能增加服务器，可以从硬件上着手，如F5服务器。当然硬件的成本比较高，我们往往从软件方面着手。

== Laravel请求生命周期 ==

#、Laravel 采用了单一入口模式，应用的所有请求入口都是 public/index.php 文件。
#、注册类文件自动加载器 : Laravel通过 composer 进行依赖管理，无需开发者手动导入各种类文件，而由自动加载器自行导入。
#、创建服务容器：从 bootstrap/app.php 文件中取得 Laravel 应用实例 $app (服务容器)。
#、创建 HTTP / Console 内核：传入的请求会被发送给 HTTP 内核或者 console 内核进行处理
#、载入服务提供者至容器：在内核引导启动的过程中最重要的动作之一就是载入服务提供者到你的应用，服务提供者负责引导启动框架的全部各种组件，例如数据库、队列、验证器以及路由组件。
#、分发请求：一旦应用完成引导和所有服务提供者都注册完成，Request 将会移交给路由进行分发。路由将分发请求给一个路由或控制器，同时运行路由指定的中间件

https://blog.csdn.net/wuhuagu_wuhuaguo/article/details/80637277

== php生命周期 ==
# 模块初始化阶段 --- php_module_startup()
这个阶段主要进行php框架、zend引擎的初始化操作。这个阶段一般是在SAPI启动时执行一次，对于FPM而言，就是在fpm的master进行启动时执行的。php加载每个扩展的代码并调用其模块初始化例程（MINIT），进行一些模块所需变量的申请,内存分配等。
# 请求初始化阶段 --- php_request_startup()
当一个页面请求发生时，在请求处理前都会经历的一个阶段。对于fpm而言，是在worker进程accept一个请求并读取、解析完请求数据后的一个阶段。在这个阶段内，SAPI层将控制权交给PHP层，PHP初始化本次请求执行脚本所需的环境变量。
# 执行脚本阶段 --- php_execute_script()
php代码解析执行的过程。Zend引擎接管控制权，将php脚本代码编译成opcodes并顺次执行
# 请求关闭阶段 --- php_request_shutdown()
请求处理完后就进入了结束阶段，PHP就会启动清理程序。这个阶段，将flush输出内容、发送http响应内容等，然后它会按顺序调用各个模块的RSHUTDOWN方法。 RSHUTDOWN用以清除程序运行时产生的符号表，也就是对每个变量调用unset函数。
# 模块关闭阶段 --- php_module_shutdown()
该阶段在SAPI关闭时执行，与模块初始化阶段对应，这个阶段主要是进行资源的清理、php各模块的关闭操作，同时，将回调各扩展的module shutdown钩子函数。这是发生在所有请求都已经结束之后，例如关闭fpm的操作。（这个是对于CGI和CLI等SAPI，没有“下一个请求”，所以SAPI立刻开始关闭。）

== 504问题排查 ==
Nginx 504 Gateway Time-out的含义是所请求的网关没有请求到，简单来说就是没有请求到可以执行的PHP-CGI

* 问题排查：nginx错误日志，fpm日志，应用日志。
** nginx作为调用方交由php处理的任务长时间没有返回、php作为服务提供者，严重耗时，长时间延迟。
** php-fpm模式下,php处理耗时比较长任务时，会发生堵塞。
* 解决
** 修改配置，最大内存，执行时间。。。
** 如果是数据库耗时，优化数据库结构，比如加索引
** 如果是程序耗时，可以采用异步的方法，

== laravel orm加全局条件? ==

# 实现Illuminate\Database\Eloquent\ScopeInterface接口，apply方法
# 重写boot方法， static::addGlobalScope(new ScopeName);

== laravel 事件 ==
# 创建事件、监听器
# EventServiceProvider中注册
# event函数调用

常见问题

2019-10-28T03:58:21Z

Yaosong：/* 504问题排查 */

== cookie 和 session 的区别 ==
* 作用范围不同，Cookie 保存在客户端（浏览器），Session 保存在服务器端。
* 存取方式的不同，Cookie 只能保存 ASCII，Session 可以存任意数据类型，一般情况下我们可以在 Session 中保持一些常用变量信息，比如说 UserId 等。
* 有效期不同，Cookie 可设置为长时间保持，比如我们经常使用的默认登录功能，Session 一般失效时间较短，客户端关闭或者 Session 超时都会失效。
* 隐私策略不同，Cookie 存储在客户端，比较容易遭到不法获取，早期有人将用户的登录名和密码存储在 Cookie 中导致信息被窃取；Session 存储在服务端，安全性相对 Cookie 要好一些。
* 存储大小不同，单个 Cookie 保存的数据不能超过 4K，Session 可存储数据远高于 Cookie。

分布式session

ip_hash
Session 复制
缓存中间件

== post 和 get 的区别 ==
https://www.w3school.com.cn/tags/html_ref_httpmethods.asp

GET 用于获取信息，是无副作用的，是幂等的，且可缓存
POST 用于修改服务器上的数据，有副作用，非幂等，不可缓存
* 安全？post请求不会保留在浏览器历史记录中

{|class="wikitable"
!colspan="2"|GET
|POST
|-
|后退按钮/刷新
| 无害
|数据会被重新提交（浏览器应该告知用户数据会被重新提交）。
|-
|书签
|可收藏为书签
|不可收藏为书签
|-
|缓存
|能被缓存
|不能缓存
|-
|编码类型
| application/x-www-form-urlencoded
|application/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。
|-
|历史
|参数保留在浏览器历史中。
|参数不会保存在浏览器历史中。
|-
|对数据长度的限制
|是的。当发送数据时，GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。
|无限制。
|-
|对数据类型的限制
|只允许 ASCII 字符。
|没有限制。也允许二进制数据。
|-
|安全性
|与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。
在发送密码或其他敏感信息时绝不要使用 GET ！
|POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
|-
|可见性
|数据在 URL 中对所有人都是可见的。
|数据不会显示在 URL 中。
|}

== 转发和重定向的区别 ==
转发

1. 是服务器内部的重定向，服务器直接访问目标地址的 url网址，把里面的东西读取出来，但是客户端并不知道，因此用forward的话，客户端浏览器的网址是不会发生变化的。

2. 关于request: 由于在整个定向的过程中用的是同一个request，因此forward会将request的信息带到被重定向的地址中。

重定向

1.是客户端的重定向，是完全的跳转。即服务器返回的一个url给客户端浏览器，然后客户端浏览器会重新发送一次请求，到新的url里面，因此浏览器中显示的url网址会发生变化。

2.因为这种方式比forward多了一次网络请求，因此效率会低于forward。

== 堆栈区别 ==
== 并发和并行的区别 ==
行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

== 索引 ==
=== 不走索引 ===
=== 行级锁和表级锁 ===

行级锁定的优点：

· 当在许多线程中访问不同的行时只存在少量锁定冲突。

· 回滚时只有少量的更改。

· 可以长时间锁定单一的行。

行级锁定的缺点：

· 比页级或表级锁定占用更多的内存。

· 当在表的大部分中使用时，比页级或表级锁定速度慢，因为你必须获取更多的锁。

· 如果你在大部分数据上经常进行GROUP BY操作或者必须经常扫描整个表，比其它锁定明显慢很多。

· 用高级别锁定，通过支持不同的类型锁定，你也可以很容易地调节应用程序，因为其锁成本小于行级锁定。

== 存储引擎 ==
* InnoDB
== 数据库，事务，隔离级别，存储引擎 ==
* 数据库，三大范式
== redis，有什么优势 -memcache对比 ==
数据存储位置
* redis：内存、磁盘(数据持久化)
* memcache: 内存

存储数据的类型（都是键值对的形式）值的类型：
* redis：list、set、hash、string、zset等
* memcache：string

== http\https ==
* 默认端口不同80：443
* https需要颁发证书
* HTTPS协议的安全性更高
* https缺点
** 速度慢
** 服务器成本

== 数据库的存储引擎应用场景，索引结构 ==

MyISAM表使用B型树索引。读取场景下性能好，表锁，不能事务

InnoDB是为处理巨大数据量时的最大性能设计。B树。由于是行锁，写入、更新速度可能会快。

MEMORY表被存储在内存中，且默认使用哈希索引

为什么索引结构默认使用B-Tree，而不是hash，二叉树，红黑树？
* hash：虽然可以快速定位，但是没有顺序，IO复杂度高。
* 二叉树：树的高度不均匀，不能自平衡，查找效率跟数据有关（树的高度），并且IO代价高。
* 红黑树：树的高度随着数据量增加而增加，IO代价高。

为什么建议使用自增长主键作为索引。

结合B+Tree的特点，自增主键是连续的，在插入过程中尽量减少页分裂，即使要进行页分裂，也只会分裂很少一部分。并且能减少数据的移动，每次插入都是插入到最后。总之就是减少分裂和移动的频率。

== 大数据量的优化 ==
* 分区、分表、分库

== 设计一个权限系统 ==
== 算法题 ==
== 红黑树 ==
== 多线程，sleep，wait，yield ==
== restful ==
== 设计模式，单例模式，适配器模式 ==
== 操作系统，死锁 ==
== 快排时间复杂度 ==
== nginx可承受的压力 ==
== 项目 ==
* 项目难点
* 架构优化
* 难点
* 主要业务
== 服务调用超时可能由什么造成 ==

* 网络问题，是否繁忙？
* cpu、内存排查，cpu消耗高，处理不过来
* 服务端有没有收到请求，看请求响应时间
* 客服端网络、cpu等有问题

== 进程间的通信方式 ==
== fpm ==
* 合适的超时时间request_terminate_timeout、max_execution_time
* 看服务器性能，设置进程数量max_children
* fpm进程处理最大请求数max_requests

== nginx ==

* worker_processes 8; #nginx进程数，建议按照cpu数目来指定，一般为它的倍数,平时设置为2倍。

* 静态资源缓存

* nginx打开文件的最大个数

* buffer：如果buffer太小，Nginx会不停的写一些临时文件，这样会导致磁盘不停的去读写

== php array 结构 ==

hashtable+映射表的方式

hash=>映射表=>bucket

映射表与bucket长度相同

hash冲突的情况：链地址法。next设置为相同hash的索引，然后在映射表里的值替换成当前元素在bucket中的位置。

== 处理负载，高并发？==

# HTML静态化
效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。
# 图片服务器分离
把图片单独存储，尽量减少图片等大流量的开销，可以放在一些相关的平台上，如七牛等
# 数据库集群和库表散列及缓存
数据库的并发连接为100，一台数据库远远不够，可以从读写分离、主从复制，数据库集群方面来着手。另外尽量减少数据库的访问，可以使用缓存数据库如memcache、redis。
# 镜像：
尽量减少下载，可以把不同的请求分发到多个镜像端。
# 负载均衡：
Apache的最大并发连接为1500，只能增加服务器，可以从硬件上着手，如F5服务器。当然硬件的成本比较高，我们往往从软件方面着手。

== Laravel请求生命周期 ==

#、Laravel 采用了单一入口模式，应用的所有请求入口都是 public/index.php 文件。
#、注册类文件自动加载器 : Laravel通过 composer 进行依赖管理，无需开发者手动导入各种类文件，而由自动加载器自行导入。
#、创建服务容器：从 bootstrap/app.php 文件中取得 Laravel 应用实例 $app (服务容器)。
#、创建 HTTP / Console 内核：传入的请求会被发送给 HTTP 内核或者 console 内核进行处理
#、载入服务提供者至容器：在内核引导启动的过程中最重要的动作之一就是载入服务提供者到你的应用，服务提供者负责引导启动框架的全部各种组件，例如数据库、队列、验证器以及路由组件。
#、分发请求：一旦应用完成引导和所有服务提供者都注册完成，Request 将会移交给路由进行分发。路由将分发请求给一个路由或控制器，同时运行路由指定的中间件

https://blog.csdn.net/wuhuagu_wuhuaguo/article/details/80637277

== php生命周期 ==
# 模块初始化阶段 --- php_module_startup()
这个阶段主要进行php框架、zend引擎的初始化操作。这个阶段一般是在SAPI启动时执行一次，对于FPM而言，就是在fpm的master进行启动时执行的。php加载每个扩展的代码并调用其模块初始化例程（MINIT），进行一些模块所需变量的申请,内存分配等。
# 请求初始化阶段 --- php_request_startup()
当一个页面请求发生时，在请求处理前都会经历的一个阶段。对于fpm而言，是在worker进程accept一个请求并读取、解析完请求数据后的一个阶段。在这个阶段内，SAPI层将控制权交给PHP层，PHP初始化本次请求执行脚本所需的环境变量。
# 执行脚本阶段 --- php_execute_script()
php代码解析执行的过程。Zend引擎接管控制权，将php脚本代码编译成opcodes并顺次执行
# 请求关闭阶段 --- php_request_shutdown()
请求处理完后就进入了结束阶段，PHP就会启动清理程序。这个阶段，将flush输出内容、发送http响应内容等，然后它会按顺序调用各个模块的RSHUTDOWN方法。 RSHUTDOWN用以清除程序运行时产生的符号表，也就是对每个变量调用unset函数。
# 模块关闭阶段 --- php_module_shutdown()
该阶段在SAPI关闭时执行，与模块初始化阶段对应，这个阶段主要是进行资源的清理、php各模块的关闭操作，同时，将回调各扩展的module shutdown钩子函数。这是发生在所有请求都已经结束之后，例如关闭fpm的操作。（这个是对于CGI和CLI等SAPI，没有“下一个请求”，所以SAPI立刻开始关闭。）

== 504问题排查 ==
Nginx 504 Gateway Time-out的含义是所请求的网关没有请求到，简单来说就是没有请求到可以执行的PHP-CGI

* 问题排查：nginx错误日志，fpm日志，应用日志。
** nginx作为调用方交由php处理的任务长时间没有返回、php作为服务提供者，严重耗时，长时间延迟。
** php-fpm模式下,php处理耗时比较长任务时，会发生堵塞。
* 解决
** 修改配置，最大内存，执行时间。。。
** 如果是数据库耗时，优化数据库结构，比如加索引
** 如果是程序耗时，可以采用异步的方法，

== laravel orm加全局条件? ==
todo

常见问题

2019-10-28T03:55:24Z

Yaosong：/* 504问题排查 */

== cookie 和 session 的区别 ==
* 作用范围不同，Cookie 保存在客户端（浏览器），Session 保存在服务器端。
* 存取方式的不同，Cookie 只能保存 ASCII，Session 可以存任意数据类型，一般情况下我们可以在 Session 中保持一些常用变量信息，比如说 UserId 等。
* 有效期不同，Cookie 可设置为长时间保持，比如我们经常使用的默认登录功能，Session 一般失效时间较短，客户端关闭或者 Session 超时都会失效。
* 隐私策略不同，Cookie 存储在客户端，比较容易遭到不法获取，早期有人将用户的登录名和密码存储在 Cookie 中导致信息被窃取；Session 存储在服务端，安全性相对 Cookie 要好一些。
* 存储大小不同，单个 Cookie 保存的数据不能超过 4K，Session 可存储数据远高于 Cookie。

分布式session

ip_hash
Session 复制
缓存中间件

== post 和 get 的区别 ==
https://www.w3school.com.cn/tags/html_ref_httpmethods.asp

GET 用于获取信息，是无副作用的，是幂等的，且可缓存
POST 用于修改服务器上的数据，有副作用，非幂等，不可缓存
* 安全？post请求不会保留在浏览器历史记录中

{|class="wikitable"
!colspan="2"|GET
|POST
|-
|后退按钮/刷新
| 无害
|数据会被重新提交（浏览器应该告知用户数据会被重新提交）。
|-
|书签
|可收藏为书签
|不可收藏为书签
|-
|缓存
|能被缓存
|不能缓存
|-
|编码类型
| application/x-www-form-urlencoded
|application/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。
|-
|历史
|参数保留在浏览器历史中。
|参数不会保存在浏览器历史中。
|-
|对数据长度的限制
|是的。当发送数据时，GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。
|无限制。
|-
|对数据类型的限制
|只允许 ASCII 字符。
|没有限制。也允许二进制数据。
|-
|安全性
|与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。
在发送密码或其他敏感信息时绝不要使用 GET ！
|POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
|-
|可见性
|数据在 URL 中对所有人都是可见的。
|数据不会显示在 URL 中。
|}

== 转发和重定向的区别 ==
转发

1. 是服务器内部的重定向，服务器直接访问目标地址的 url网址，把里面的东西读取出来，但是客户端并不知道，因此用forward的话，客户端浏览器的网址是不会发生变化的。

2. 关于request: 由于在整个定向的过程中用的是同一个request，因此forward会将request的信息带到被重定向的地址中。

重定向

1.是客户端的重定向，是完全的跳转。即服务器返回的一个url给客户端浏览器，然后客户端浏览器会重新发送一次请求，到新的url里面，因此浏览器中显示的url网址会发生变化。

2.因为这种方式比forward多了一次网络请求，因此效率会低于forward。

== 堆栈区别 ==
== 并发和并行的区别 ==
行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

== 索引 ==
=== 不走索引 ===
=== 行级锁和表级锁 ===

行级锁定的优点：

· 当在许多线程中访问不同的行时只存在少量锁定冲突。

· 回滚时只有少量的更改。

· 可以长时间锁定单一的行。

行级锁定的缺点：

· 比页级或表级锁定占用更多的内存。

· 当在表的大部分中使用时，比页级或表级锁定速度慢，因为你必须获取更多的锁。

· 如果你在大部分数据上经常进行GROUP BY操作或者必须经常扫描整个表，比其它锁定明显慢很多。

· 用高级别锁定，通过支持不同的类型锁定，你也可以很容易地调节应用程序，因为其锁成本小于行级锁定。

== 存储引擎 ==
* InnoDB
== 数据库，事务，隔离级别，存储引擎 ==
* 数据库，三大范式
== redis，有什么优势 -memcache对比 ==
数据存储位置
* redis：内存、磁盘(数据持久化)
* memcache: 内存

存储数据的类型（都是键值对的形式）值的类型：
* redis：list、set、hash、string、zset等
* memcache：string

== http\https ==
* 默认端口不同80：443
* https需要颁发证书
* HTTPS协议的安全性更高
* https缺点
** 速度慢
** 服务器成本

== 数据库的存储引擎应用场景，索引结构 ==

MyISAM表使用B型树索引。读取场景下性能好，表锁，不能事务

InnoDB是为处理巨大数据量时的最大性能设计。B树。由于是行锁，写入、更新速度可能会快。

MEMORY表被存储在内存中，且默认使用哈希索引

为什么索引结构默认使用B-Tree，而不是hash，二叉树，红黑树？
* hash：虽然可以快速定位，但是没有顺序，IO复杂度高。
* 二叉树：树的高度不均匀，不能自平衡，查找效率跟数据有关（树的高度），并且IO代价高。
* 红黑树：树的高度随着数据量增加而增加，IO代价高。

为什么建议使用自增长主键作为索引。

结合B+Tree的特点，自增主键是连续的，在插入过程中尽量减少页分裂，即使要进行页分裂，也只会分裂很少一部分。并且能减少数据的移动，每次插入都是插入到最后。总之就是减少分裂和移动的频率。

== 大数据量的优化 ==
* 分区、分表、分库

== 设计一个权限系统 ==
== 算法题 ==
== 红黑树 ==
== 多线程，sleep，wait，yield ==
== restful ==
== 设计模式，单例模式，适配器模式 ==
== 操作系统，死锁 ==
== 快排时间复杂度 ==
== nginx可承受的压力 ==
== 项目 ==
* 项目难点
* 架构优化
* 难点
* 主要业务
== 服务调用超时可能由什么造成 ==

* 网络问题，是否繁忙？
* cpu、内存排查，cpu消耗高，处理不过来
* 服务端有没有收到请求，看请求响应时间
* 客服端网络、cpu等有问题

== 进程间的通信方式 ==
== fpm ==
* 合适的超时时间request_terminate_timeout、max_execution_time
* 看服务器性能，设置进程数量max_children
* fpm进程处理最大请求数max_requests

== nginx ==

* worker_processes 8; #nginx进程数，建议按照cpu数目来指定，一般为它的倍数,平时设置为2倍。

* 静态资源缓存

* nginx打开文件的最大个数

* buffer：如果buffer太小，Nginx会不停的写一些临时文件，这样会导致磁盘不停的去读写

== php array 结构 ==

hashtable+映射表的方式

hash=>映射表=>bucket

映射表与bucket长度相同

hash冲突的情况：链地址法。next设置为相同hash的索引，然后在映射表里的值替换成当前元素在bucket中的位置。

== 处理负载，高并发？==

# HTML静态化
效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。
# 图片服务器分离
把图片单独存储，尽量减少图片等大流量的开销，可以放在一些相关的平台上，如七牛等
# 数据库集群和库表散列及缓存
数据库的并发连接为100，一台数据库远远不够，可以从读写分离、主从复制，数据库集群方面来着手。另外尽量减少数据库的访问，可以使用缓存数据库如memcache、redis。
# 镜像：
尽量减少下载，可以把不同的请求分发到多个镜像端。
# 负载均衡：
Apache的最大并发连接为1500，只能增加服务器，可以从硬件上着手，如F5服务器。当然硬件的成本比较高，我们往往从软件方面着手。

== Laravel请求生命周期 ==

#、Laravel 采用了单一入口模式，应用的所有请求入口都是 public/index.php 文件。
#、注册类文件自动加载器 : Laravel通过 composer 进行依赖管理，无需开发者手动导入各种类文件，而由自动加载器自行导入。
#、创建服务容器：从 bootstrap/app.php 文件中取得 Laravel 应用实例 $app (服务容器)。
#、创建 HTTP / Console 内核：传入的请求会被发送给 HTTP 内核或者 console 内核进行处理
#、载入服务提供者至容器：在内核引导启动的过程中最重要的动作之一就是载入服务提供者到你的应用，服务提供者负责引导启动框架的全部各种组件，例如数据库、队列、验证器以及路由组件。
#、分发请求：一旦应用完成引导和所有服务提供者都注册完成，Request 将会移交给路由进行分发。路由将分发请求给一个路由或控制器，同时运行路由指定的中间件

https://blog.csdn.net/wuhuagu_wuhuaguo/article/details/80637277

== php生命周期 ==
# 模块初始化阶段 --- php_module_startup()
这个阶段主要进行php框架、zend引擎的初始化操作。这个阶段一般是在SAPI启动时执行一次，对于FPM而言，就是在fpm的master进行启动时执行的。php加载每个扩展的代码并调用其模块初始化例程（MINIT），进行一些模块所需变量的申请,内存分配等。
# 请求初始化阶段 --- php_request_startup()
当一个页面请求发生时，在请求处理前都会经历的一个阶段。对于fpm而言，是在worker进程accept一个请求并读取、解析完请求数据后的一个阶段。在这个阶段内，SAPI层将控制权交给PHP层，PHP初始化本次请求执行脚本所需的环境变量。
# 执行脚本阶段 --- php_execute_script()
php代码解析执行的过程。Zend引擎接管控制权，将php脚本代码编译成opcodes并顺次执行
# 请求关闭阶段 --- php_request_shutdown()
请求处理完后就进入了结束阶段，PHP就会启动清理程序。这个阶段，将flush输出内容、发送http响应内容等，然后它会按顺序调用各个模块的RSHUTDOWN方法。 RSHUTDOWN用以清除程序运行时产生的符号表，也就是对每个变量调用unset函数。
# 模块关闭阶段 --- php_module_shutdown()
该阶段在SAPI关闭时执行，与模块初始化阶段对应，这个阶段主要是进行资源的清理、php各模块的关闭操作，同时，将回调各扩展的module shutdown钩子函数。这是发生在所有请求都已经结束之后，例如关闭fpm的操作。（这个是对于CGI和CLI等SAPI，没有“下一个请求”，所以SAPI立刻开始关闭。）

== 504问题排查 ==
Nginx 504 Gateway Time-out的含义是所请求的网关没有请求到，简单来说就是没有请求到可以执行的PHP-CGI

* 问题排查：nginx错误日志，fpm日志，应用日志。
** nginx作为调用方交由php处理的任务长时间没有返回、php作为服务提供者，严重耗时，长时间延迟。
** php-fpm模式下,php处理耗时比较长任务时，会发生堵塞。
* 解决
** 修改配置，最大内存，执行时间。。。
** 如果是数据库耗时，优化数据库结构，比如加索引
** 如果是程序耗时，可以采用异步的方法，

常见问题

2019-10-28T03:53:01Z

Yaosong：/* php生命周期 */

== cookie 和 session 的区别 ==
* 作用范围不同，Cookie 保存在客户端（浏览器），Session 保存在服务器端。
* 存取方式的不同，Cookie 只能保存 ASCII，Session 可以存任意数据类型，一般情况下我们可以在 Session 中保持一些常用变量信息，比如说 UserId 等。
* 有效期不同，Cookie 可设置为长时间保持，比如我们经常使用的默认登录功能，Session 一般失效时间较短，客户端关闭或者 Session 超时都会失效。
* 隐私策略不同，Cookie 存储在客户端，比较容易遭到不法获取，早期有人将用户的登录名和密码存储在 Cookie 中导致信息被窃取；Session 存储在服务端，安全性相对 Cookie 要好一些。
* 存储大小不同，单个 Cookie 保存的数据不能超过 4K，Session 可存储数据远高于 Cookie。

分布式session

ip_hash
Session 复制
缓存中间件

== post 和 get 的区别 ==
https://www.w3school.com.cn/tags/html_ref_httpmethods.asp

GET 用于获取信息，是无副作用的，是幂等的，且可缓存
POST 用于修改服务器上的数据，有副作用，非幂等，不可缓存
* 安全？post请求不会保留在浏览器历史记录中

{|class="wikitable"
!colspan="2"|GET
|POST
|-
|后退按钮/刷新
| 无害
|数据会被重新提交（浏览器应该告知用户数据会被重新提交）。
|-
|书签
|可收藏为书签
|不可收藏为书签
|-
|缓存
|能被缓存
|不能缓存
|-
|编码类型
| application/x-www-form-urlencoded
|application/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。
|-
|历史
|参数保留在浏览器历史中。
|参数不会保存在浏览器历史中。
|-
|对数据长度的限制
|是的。当发送数据时，GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。
|无限制。
|-
|对数据类型的限制
|只允许 ASCII 字符。
|没有限制。也允许二进制数据。
|-
|安全性
|与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。
在发送密码或其他敏感信息时绝不要使用 GET ！
|POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
|-
|可见性
|数据在 URL 中对所有人都是可见的。
|数据不会显示在 URL 中。
|}

== 转发和重定向的区别 ==
转发

1. 是服务器内部的重定向，服务器直接访问目标地址的 url网址，把里面的东西读取出来，但是客户端并不知道，因此用forward的话，客户端浏览器的网址是不会发生变化的。

2. 关于request: 由于在整个定向的过程中用的是同一个request，因此forward会将request的信息带到被重定向的地址中。

重定向

1.是客户端的重定向，是完全的跳转。即服务器返回的一个url给客户端浏览器，然后客户端浏览器会重新发送一次请求，到新的url里面，因此浏览器中显示的url网址会发生变化。

2.因为这种方式比forward多了一次网络请求，因此效率会低于forward。

== 堆栈区别 ==
== 并发和并行的区别 ==
行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

== 索引 ==
=== 不走索引 ===
=== 行级锁和表级锁 ===

行级锁定的优点：

· 当在许多线程中访问不同的行时只存在少量锁定冲突。

· 回滚时只有少量的更改。

· 可以长时间锁定单一的行。

行级锁定的缺点：

· 比页级或表级锁定占用更多的内存。

· 当在表的大部分中使用时，比页级或表级锁定速度慢，因为你必须获取更多的锁。

· 如果你在大部分数据上经常进行GROUP BY操作或者必须经常扫描整个表，比其它锁定明显慢很多。

· 用高级别锁定，通过支持不同的类型锁定，你也可以很容易地调节应用程序，因为其锁成本小于行级锁定。

== 存储引擎 ==
* InnoDB
== 数据库，事务，隔离级别，存储引擎 ==
* 数据库，三大范式
== redis，有什么优势 -memcache对比 ==
数据存储位置
* redis：内存、磁盘(数据持久化)
* memcache: 内存

存储数据的类型（都是键值对的形式）值的类型：
* redis：list、set、hash、string、zset等
* memcache：string

== http\https ==
* 默认端口不同80：443
* https需要颁发证书
* HTTPS协议的安全性更高
* https缺点
** 速度慢
** 服务器成本

== 数据库的存储引擎应用场景，索引结构 ==

MyISAM表使用B型树索引。读取场景下性能好，表锁，不能事务

InnoDB是为处理巨大数据量时的最大性能设计。B树。由于是行锁，写入、更新速度可能会快。

MEMORY表被存储在内存中，且默认使用哈希索引

为什么索引结构默认使用B-Tree，而不是hash，二叉树，红黑树？
* hash：虽然可以快速定位，但是没有顺序，IO复杂度高。
* 二叉树：树的高度不均匀，不能自平衡，查找效率跟数据有关（树的高度），并且IO代价高。
* 红黑树：树的高度随着数据量增加而增加，IO代价高。

为什么建议使用自增长主键作为索引。

结合B+Tree的特点，自增主键是连续的，在插入过程中尽量减少页分裂，即使要进行页分裂，也只会分裂很少一部分。并且能减少数据的移动，每次插入都是插入到最后。总之就是减少分裂和移动的频率。

== 大数据量的优化 ==
* 分区、分表、分库

== 设计一个权限系统 ==
== 算法题 ==
== 红黑树 ==
== 多线程，sleep，wait，yield ==
== restful ==
== 设计模式，单例模式，适配器模式 ==
== 操作系统，死锁 ==
== 快排时间复杂度 ==
== nginx可承受的压力 ==
== 项目 ==
* 项目难点
* 架构优化
* 难点
* 主要业务
== 服务调用超时可能由什么造成 ==

* 网络问题，是否繁忙？
* cpu、内存排查，cpu消耗高，处理不过来
* 服务端有没有收到请求，看请求响应时间
* 客服端网络、cpu等有问题

== 进程间的通信方式 ==
== fpm ==
* 合适的超时时间request_terminate_timeout、max_execution_time
* 看服务器性能，设置进程数量max_children
* fpm进程处理最大请求数max_requests

== nginx ==

* worker_processes 8; #nginx进程数，建议按照cpu数目来指定，一般为它的倍数,平时设置为2倍。

* 静态资源缓存

* nginx打开文件的最大个数

* buffer：如果buffer太小，Nginx会不停的写一些临时文件，这样会导致磁盘不停的去读写

== php array 结构 ==

hashtable+映射表的方式

hash=>映射表=>bucket

映射表与bucket长度相同

hash冲突的情况：链地址法。next设置为相同hash的索引，然后在映射表里的值替换成当前元素在bucket中的位置。

== 处理负载，高并发？==

# HTML静态化
效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。
# 图片服务器分离
把图片单独存储，尽量减少图片等大流量的开销，可以放在一些相关的平台上，如七牛等
# 数据库集群和库表散列及缓存
数据库的并发连接为100，一台数据库远远不够，可以从读写分离、主从复制，数据库集群方面来着手。另外尽量减少数据库的访问，可以使用缓存数据库如memcache、redis。
# 镜像：
尽量减少下载，可以把不同的请求分发到多个镜像端。
# 负载均衡：
Apache的最大并发连接为1500，只能增加服务器，可以从硬件上着手，如F5服务器。当然硬件的成本比较高，我们往往从软件方面着手。

== Laravel请求生命周期 ==

#、Laravel 采用了单一入口模式，应用的所有请求入口都是 public/index.php 文件。
#、注册类文件自动加载器 : Laravel通过 composer 进行依赖管理，无需开发者手动导入各种类文件，而由自动加载器自行导入。
#、创建服务容器：从 bootstrap/app.php 文件中取得 Laravel 应用实例 $app (服务容器)。
#、创建 HTTP / Console 内核：传入的请求会被发送给 HTTP 内核或者 console 内核进行处理
#、载入服务提供者至容器：在内核引导启动的过程中最重要的动作之一就是载入服务提供者到你的应用，服务提供者负责引导启动框架的全部各种组件，例如数据库、队列、验证器以及路由组件。
#、分发请求：一旦应用完成引导和所有服务提供者都注册完成，Request 将会移交给路由进行分发。路由将分发请求给一个路由或控制器，同时运行路由指定的中间件

https://blog.csdn.net/wuhuagu_wuhuaguo/article/details/80637277

== php生命周期 ==
# 模块初始化阶段 --- php_module_startup()
这个阶段主要进行php框架、zend引擎的初始化操作。这个阶段一般是在SAPI启动时执行一次，对于FPM而言，就是在fpm的master进行启动时执行的。php加载每个扩展的代码并调用其模块初始化例程（MINIT），进行一些模块所需变量的申请,内存分配等。
# 请求初始化阶段 --- php_request_startup()
当一个页面请求发生时，在请求处理前都会经历的一个阶段。对于fpm而言，是在worker进程accept一个请求并读取、解析完请求数据后的一个阶段。在这个阶段内，SAPI层将控制权交给PHP层，PHP初始化本次请求执行脚本所需的环境变量。
# 执行脚本阶段 --- php_execute_script()
php代码解析执行的过程。Zend引擎接管控制权，将php脚本代码编译成opcodes并顺次执行
# 请求关闭阶段 --- php_request_shutdown()
请求处理完后就进入了结束阶段，PHP就会启动清理程序。这个阶段，将flush输出内容、发送http响应内容等，然后它会按顺序调用各个模块的RSHUTDOWN方法。 RSHUTDOWN用以清除程序运行时产生的符号表，也就是对每个变量调用unset函数。
# 模块关闭阶段 --- php_module_shutdown()
该阶段在SAPI关闭时执行，与模块初始化阶段对应，这个阶段主要是进行资源的清理、php各模块的关闭操作，同时，将回调各扩展的module shutdown钩子函数。这是发生在所有请求都已经结束之后，例如关闭fpm的操作。（这个是对于CGI和CLI等SAPI，没有“下一个请求”，所以SAPI立刻开始关闭。）

== 504问题排查 ==
Nginx 504 Gateway Time-out的含义是所请求的网关没有请求到，简单来说就是没有请求到可以执行的PHP-CGI

常见问题

2019-10-22T07:12:44Z

Yaosong：/* Laravel请求生命周期 */

== cookie 和 session 的区别 ==
* 作用范围不同，Cookie 保存在客户端（浏览器），Session 保存在服务器端。
* 存取方式的不同，Cookie 只能保存 ASCII，Session 可以存任意数据类型，一般情况下我们可以在 Session 中保持一些常用变量信息，比如说 UserId 等。
* 有效期不同，Cookie 可设置为长时间保持，比如我们经常使用的默认登录功能，Session 一般失效时间较短，客户端关闭或者 Session 超时都会失效。
* 隐私策略不同，Cookie 存储在客户端，比较容易遭到不法获取，早期有人将用户的登录名和密码存储在 Cookie 中导致信息被窃取；Session 存储在服务端，安全性相对 Cookie 要好一些。
* 存储大小不同，单个 Cookie 保存的数据不能超过 4K，Session 可存储数据远高于 Cookie。

分布式session

ip_hash
Session 复制
缓存中间件

== post 和 get 的区别 ==
https://www.w3school.com.cn/tags/html_ref_httpmethods.asp

GET 用于获取信息，是无副作用的，是幂等的，且可缓存
POST 用于修改服务器上的数据，有副作用，非幂等，不可缓存
* 安全？post请求不会保留在浏览器历史记录中

{|class="wikitable"
!colspan="2"|GET
|POST
|-
|后退按钮/刷新
| 无害
|数据会被重新提交（浏览器应该告知用户数据会被重新提交）。
|-
|书签
|可收藏为书签
|不可收藏为书签
|-
|缓存
|能被缓存
|不能缓存
|-
|编码类型
| application/x-www-form-urlencoded
|application/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。
|-
|历史
|参数保留在浏览器历史中。
|参数不会保存在浏览器历史中。
|-
|对数据长度的限制
|是的。当发送数据时，GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。
|无限制。
|-
|对数据类型的限制
|只允许 ASCII 字符。
|没有限制。也允许二进制数据。
|-
|安全性
|与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。
在发送密码或其他敏感信息时绝不要使用 GET ！
|POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
|-
|可见性
|数据在 URL 中对所有人都是可见的。
|数据不会显示在 URL 中。
|}

== 转发和重定向的区别 ==
转发

1. 是服务器内部的重定向，服务器直接访问目标地址的 url网址，把里面的东西读取出来，但是客户端并不知道，因此用forward的话，客户端浏览器的网址是不会发生变化的。

2. 关于request: 由于在整个定向的过程中用的是同一个request，因此forward会将request的信息带到被重定向的地址中。

重定向

1.是客户端的重定向，是完全的跳转。即服务器返回的一个url给客户端浏览器，然后客户端浏览器会重新发送一次请求，到新的url里面，因此浏览器中显示的url网址会发生变化。

2.因为这种方式比forward多了一次网络请求，因此效率会低于forward。

== 堆栈区别 ==
== 并发和并行的区别 ==
行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

== 索引 ==
=== 不走索引 ===
=== 行级锁和表级锁 ===

行级锁定的优点：

· 当在许多线程中访问不同的行时只存在少量锁定冲突。

· 回滚时只有少量的更改。

· 可以长时间锁定单一的行。

行级锁定的缺点：

· 比页级或表级锁定占用更多的内存。

· 当在表的大部分中使用时，比页级或表级锁定速度慢，因为你必须获取更多的锁。

· 如果你在大部分数据上经常进行GROUP BY操作或者必须经常扫描整个表，比其它锁定明显慢很多。

· 用高级别锁定，通过支持不同的类型锁定，你也可以很容易地调节应用程序，因为其锁成本小于行级锁定。

== 存储引擎 ==
* InnoDB
== 数据库，事务，隔离级别，存储引擎 ==
* 数据库，三大范式
== redis，有什么优势 -memcache对比 ==
数据存储位置
* redis：内存、磁盘(数据持久化)
* memcache: 内存

存储数据的类型（都是键值对的形式）值的类型：
* redis：list、set、hash、string、zset等
* memcache：string

== http\https ==
* 默认端口不同80：443
* https需要颁发证书
* HTTPS协议的安全性更高
* https缺点
** 速度慢
** 服务器成本

== 数据库的存储引擎应用场景，索引结构 ==

MyISAM表使用B型树索引。读取场景下性能好，表锁，不能事务

InnoDB是为处理巨大数据量时的最大性能设计。B树。由于是行锁，写入、更新速度可能会快。

MEMORY表被存储在内存中，且默认使用哈希索引

为什么索引结构默认使用B-Tree，而不是hash，二叉树，红黑树？
* hash：虽然可以快速定位，但是没有顺序，IO复杂度高。
* 二叉树：树的高度不均匀，不能自平衡，查找效率跟数据有关（树的高度），并且IO代价高。
* 红黑树：树的高度随着数据量增加而增加，IO代价高。

为什么建议使用自增长主键作为索引。

结合B+Tree的特点，自增主键是连续的，在插入过程中尽量减少页分裂，即使要进行页分裂，也只会分裂很少一部分。并且能减少数据的移动，每次插入都是插入到最后。总之就是减少分裂和移动的频率。

== 大数据量的优化 ==
* 分区、分表、分库

== 设计一个权限系统 ==
== 算法题 ==
== 红黑树 ==
== 多线程，sleep，wait，yield ==
== restful ==
== 设计模式，单例模式，适配器模式 ==
== 操作系统，死锁 ==
== 快排时间复杂度 ==
== nginx可承受的压力 ==
== 项目 ==
* 项目难点
* 架构优化
* 难点
* 主要业务
== 服务调用超时可能由什么造成 ==

* 网络问题，是否繁忙？
* cpu、内存排查，cpu消耗高，处理不过来
* 服务端有没有收到请求，看请求响应时间
* 客服端网络、cpu等有问题

== 进程间的通信方式 ==
== fpm ==
* 合适的超时时间request_terminate_timeout、max_execution_time
* 看服务器性能，设置进程数量max_children
* fpm进程处理最大请求数max_requests

== nginx ==

* worker_processes 8; #nginx进程数，建议按照cpu数目来指定，一般为它的倍数,平时设置为2倍。

* 静态资源缓存

* nginx打开文件的最大个数

* buffer：如果buffer太小，Nginx会不停的写一些临时文件，这样会导致磁盘不停的去读写

== php array 结构 ==

hashtable+映射表的方式

hash=>映射表=>bucket

映射表与bucket长度相同

hash冲突的情况：链地址法。next设置为相同hash的索引，然后在映射表里的值替换成当前元素在bucket中的位置。

== 处理负载，高并发？==

# HTML静态化
效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。
# 图片服务器分离
把图片单独存储，尽量减少图片等大流量的开销，可以放在一些相关的平台上，如七牛等
# 数据库集群和库表散列及缓存
数据库的并发连接为100，一台数据库远远不够，可以从读写分离、主从复制，数据库集群方面来着手。另外尽量减少数据库的访问，可以使用缓存数据库如memcache、redis。
# 镜像：
尽量减少下载，可以把不同的请求分发到多个镜像端。
# 负载均衡：
Apache的最大并发连接为1500，只能增加服务器，可以从硬件上着手，如F5服务器。当然硬件的成本比较高，我们往往从软件方面着手。

== Laravel请求生命周期 ==

#、Laravel 采用了单一入口模式，应用的所有请求入口都是 public/index.php 文件。
#、注册类文件自动加载器 : Laravel通过 composer 进行依赖管理，无需开发者手动导入各种类文件，而由自动加载器自行导入。
#、创建服务容器：从 bootstrap/app.php 文件中取得 Laravel 应用实例 $app (服务容器)。
#、创建 HTTP / Console 内核：传入的请求会被发送给 HTTP 内核或者 console 内核进行处理
#、载入服务提供者至容器：在内核引导启动的过程中最重要的动作之一就是载入服务提供者到你的应用，服务提供者负责引导启动框架的全部各种组件，例如数据库、队列、验证器以及路由组件。
#、分发请求：一旦应用完成引导和所有服务提供者都注册完成，Request 将会移交给路由进行分发。路由将分发请求给一个路由或控制器，同时运行路由指定的中间件

https://blog.csdn.net/wuhuagu_wuhuaguo/article/details/80637277

== php生命周期 ==
# 模块初始化阶段 --- php_module_startup()
这个阶段主要进行php框架、zend引擎的初始化操作。这个阶段一般是在SAPI启动时执行一次，对于FPM而言，就是在fpm的master进行启动时执行的。php加载每个扩展的代码并调用其模块初始化例程（MINIT），进行一些模块所需变量的申请,内存分配等。
# 请求初始化阶段 --- php_request_startup()
当一个页面请求发生时，在请求处理前都会经历的一个阶段。对于fpm而言，是在worker进程accept一个请求并读取、解析完请求数据后的一个阶段。在这个阶段内，SAPI层将控制权交给PHP层，PHP初始化本次请求执行脚本所需的环境变量。
# 执行脚本阶段 --- php_execute_script()
php代码解析执行的过程。Zend引擎接管控制权，将php脚本代码编译成opcodes并顺次执行
# 请求关闭阶段 --- php_request_shutdown()
请求处理完后就进入了结束阶段，PHP就会启动清理程序。这个阶段，将flush输出内容、发送http响应内容等，然后它会按顺序调用各个模块的RSHUTDOWN方法。 RSHUTDOWN用以清除程序运行时产生的符号表，也就是对每个变量调用unset函数。
# 模块关闭阶段 --- php_module_shutdown()
该阶段在SAPI关闭时执行，与模块初始化阶段对应，这个阶段主要是进行资源的清理、php各模块的关闭操作，同时，将回调各扩展的module shutdown钩子函数。这是发生在所有请求都已经结束之后，例如关闭fpm的操作。（这个是对于CGI和CLI等SAPI，没有“下一个请求”，所以SAPI立刻开始关闭。）

常见问题

2019-10-22T06:55:15Z

Yaosong：/* Laravel请求生命周期 */

== cookie 和 session 的区别 ==
* 作用范围不同，Cookie 保存在客户端（浏览器），Session 保存在服务器端。
* 存取方式的不同，Cookie 只能保存 ASCII，Session 可以存任意数据类型，一般情况下我们可以在 Session 中保持一些常用变量信息，比如说 UserId 等。
* 有效期不同，Cookie 可设置为长时间保持，比如我们经常使用的默认登录功能，Session 一般失效时间较短，客户端关闭或者 Session 超时都会失效。
* 隐私策略不同，Cookie 存储在客户端，比较容易遭到不法获取，早期有人将用户的登录名和密码存储在 Cookie 中导致信息被窃取；Session 存储在服务端，安全性相对 Cookie 要好一些。
* 存储大小不同，单个 Cookie 保存的数据不能超过 4K，Session 可存储数据远高于 Cookie。

分布式session

ip_hash
Session 复制
缓存中间件

== post 和 get 的区别 ==
https://www.w3school.com.cn/tags/html_ref_httpmethods.asp

GET 用于获取信息，是无副作用的，是幂等的，且可缓存
POST 用于修改服务器上的数据，有副作用，非幂等，不可缓存
* 安全？post请求不会保留在浏览器历史记录中

{|class="wikitable"
!colspan="2"|GET
|POST
|-
|后退按钮/刷新
| 无害
|数据会被重新提交（浏览器应该告知用户数据会被重新提交）。
|-
|书签
|可收藏为书签
|不可收藏为书签
|-
|缓存
|能被缓存
|不能缓存
|-
|编码类型
| application/x-www-form-urlencoded
|application/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。
|-
|历史
|参数保留在浏览器历史中。
|参数不会保存在浏览器历史中。
|-
|对数据长度的限制
|是的。当发送数据时，GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。
|无限制。
|-
|对数据类型的限制
|只允许 ASCII 字符。
|没有限制。也允许二进制数据。
|-
|安全性
|与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。
在发送密码或其他敏感信息时绝不要使用 GET ！
|POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
|-
|可见性
|数据在 URL 中对所有人都是可见的。
|数据不会显示在 URL 中。
|}

== 转发和重定向的区别 ==
转发

1. 是服务器内部的重定向，服务器直接访问目标地址的 url网址，把里面的东西读取出来，但是客户端并不知道，因此用forward的话，客户端浏览器的网址是不会发生变化的。

2. 关于request: 由于在整个定向的过程中用的是同一个request，因此forward会将request的信息带到被重定向的地址中。

重定向

1.是客户端的重定向，是完全的跳转。即服务器返回的一个url给客户端浏览器，然后客户端浏览器会重新发送一次请求，到新的url里面，因此浏览器中显示的url网址会发生变化。

2.因为这种方式比forward多了一次网络请求，因此效率会低于forward。

== 堆栈区别 ==
== 并发和并行的区别 ==
行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

== 索引 ==
=== 不走索引 ===
=== 行级锁和表级锁 ===

行级锁定的优点：

· 当在许多线程中访问不同的行时只存在少量锁定冲突。

· 回滚时只有少量的更改。

· 可以长时间锁定单一的行。

行级锁定的缺点：

· 比页级或表级锁定占用更多的内存。

· 当在表的大部分中使用时，比页级或表级锁定速度慢，因为你必须获取更多的锁。

· 如果你在大部分数据上经常进行GROUP BY操作或者必须经常扫描整个表，比其它锁定明显慢很多。

· 用高级别锁定，通过支持不同的类型锁定，你也可以很容易地调节应用程序，因为其锁成本小于行级锁定。

== 存储引擎 ==
* InnoDB
== 数据库，事务，隔离级别，存储引擎 ==
* 数据库，三大范式
== redis，有什么优势 -memcache对比 ==
数据存储位置
* redis：内存、磁盘(数据持久化)
* memcache: 内存

存储数据的类型（都是键值对的形式）值的类型：
* redis：list、set、hash、string、zset等
* memcache：string

== http\https ==
* 默认端口不同80：443
* https需要颁发证书
* HTTPS协议的安全性更高
* https缺点
** 速度慢
** 服务器成本

== 数据库的存储引擎应用场景，索引结构 ==

MyISAM表使用B型树索引。读取场景下性能好，表锁，不能事务

InnoDB是为处理巨大数据量时的最大性能设计。B树。由于是行锁，写入、更新速度可能会快。

MEMORY表被存储在内存中，且默认使用哈希索引

为什么索引结构默认使用B-Tree，而不是hash，二叉树，红黑树？
* hash：虽然可以快速定位，但是没有顺序，IO复杂度高。
* 二叉树：树的高度不均匀，不能自平衡，查找效率跟数据有关（树的高度），并且IO代价高。
* 红黑树：树的高度随着数据量增加而增加，IO代价高。

为什么建议使用自增长主键作为索引。

结合B+Tree的特点，自增主键是连续的，在插入过程中尽量减少页分裂，即使要进行页分裂，也只会分裂很少一部分。并且能减少数据的移动，每次插入都是插入到最后。总之就是减少分裂和移动的频率。

== 大数据量的优化 ==
* 分区、分表、分库

== 设计一个权限系统 ==
== 算法题 ==
== 红黑树 ==
== 多线程，sleep，wait，yield ==
== restful ==
== 设计模式，单例模式，适配器模式 ==
== 操作系统，死锁 ==
== 快排时间复杂度 ==
== nginx可承受的压力 ==
== 项目 ==
* 项目难点
* 架构优化
* 难点
* 主要业务
== 服务调用超时可能由什么造成 ==

* 网络问题，是否繁忙？
* cpu、内存排查，cpu消耗高，处理不过来
* 服务端有没有收到请求，看请求响应时间
* 客服端网络、cpu等有问题

== 进程间的通信方式 ==
== fpm ==
* 合适的超时时间request_terminate_timeout、max_execution_time
* 看服务器性能，设置进程数量max_children
* fpm进程处理最大请求数max_requests

== nginx ==

* worker_processes 8; #nginx进程数，建议按照cpu数目来指定，一般为它的倍数,平时设置为2倍。

* 静态资源缓存

* nginx打开文件的最大个数

* buffer：如果buffer太小，Nginx会不停的写一些临时文件，这样会导致磁盘不停的去读写

== php array 结构 ==

hashtable+映射表的方式

hash=>映射表=>bucket

映射表与bucket长度相同

hash冲突的情况：链地址法。next设置为相同hash的索引，然后在映射表里的值替换成当前元素在bucket中的位置。

== 处理负载，高并发？==

# HTML静态化
效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。
# 图片服务器分离
把图片单独存储，尽量减少图片等大流量的开销，可以放在一些相关的平台上，如七牛等
# 数据库集群和库表散列及缓存
数据库的并发连接为100，一台数据库远远不够，可以从读写分离、主从复制，数据库集群方面来着手。另外尽量减少数据库的访问，可以使用缓存数据库如memcache、redis。
# 镜像：
尽量减少下载，可以把不同的请求分发到多个镜像端。
# 负载均衡：
Apache的最大并发连接为1500，只能增加服务器，可以从硬件上着手，如F5服务器。当然硬件的成本比较高，我们往往从软件方面着手。

== Laravel请求生命周期 ==

#、Laravel 采用了单一入口模式，应用的所有请求入口都是 public/index.php 文件。
#、注册类文件自动加载器 : Laravel通过 composer 进行依赖管理，无需开发者手动导入各种类文件，而由自动加载器自行导入。
#、创建服务容器：从 bootstrap/app.php 文件中取得 Laravel 应用实例 $app (服务容器)。
#、创建 HTTP / Console 内核：传入的请求会被发送给 HTTP 内核或者 console 内核进行处理
#、载入服务提供者至容器：在内核引导启动的过程中最重要的动作之一就是载入服务提供者到你的应用，服务提供者负责引导启动框架的全部各种组件，例如数据库、队列、验证器以及路由组件。
#、分发请求：一旦应用完成引导和所有服务提供者都注册完成，Request 将会移交给路由进行分发。路由将分发请求给一个路由或控制器，同时运行路由指定的中间件

https://blog.csdn.net/wuhuagu_wuhuaguo/article/details/80637277

常见问题

2019-10-22T06:54:27Z

Yaosong：/* Laravel请求生命周期 */

== cookie 和 session 的区别 ==
* 作用范围不同，Cookie 保存在客户端（浏览器），Session 保存在服务器端。
* 存取方式的不同，Cookie 只能保存 ASCII，Session 可以存任意数据类型，一般情况下我们可以在 Session 中保持一些常用变量信息，比如说 UserId 等。
* 有效期不同，Cookie 可设置为长时间保持，比如我们经常使用的默认登录功能，Session 一般失效时间较短，客户端关闭或者 Session 超时都会失效。
* 隐私策略不同，Cookie 存储在客户端，比较容易遭到不法获取，早期有人将用户的登录名和密码存储在 Cookie 中导致信息被窃取；Session 存储在服务端，安全性相对 Cookie 要好一些。
* 存储大小不同，单个 Cookie 保存的数据不能超过 4K，Session 可存储数据远高于 Cookie。

分布式session

ip_hash
Session 复制
缓存中间件

== post 和 get 的区别 ==
https://www.w3school.com.cn/tags/html_ref_httpmethods.asp

GET 用于获取信息，是无副作用的，是幂等的，且可缓存
POST 用于修改服务器上的数据，有副作用，非幂等，不可缓存
* 安全？post请求不会保留在浏览器历史记录中

{|class="wikitable"
!colspan="2"|GET
|POST
|-
|后退按钮/刷新
| 无害
|数据会被重新提交（浏览器应该告知用户数据会被重新提交）。
|-
|书签
|可收藏为书签
|不可收藏为书签
|-
|缓存
|能被缓存
|不能缓存
|-
|编码类型
| application/x-www-form-urlencoded
|application/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。
|-
|历史
|参数保留在浏览器历史中。
|参数不会保存在浏览器历史中。
|-
|对数据长度的限制
|是的。当发送数据时，GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。
|无限制。
|-
|对数据类型的限制
|只允许 ASCII 字符。
|没有限制。也允许二进制数据。
|-
|安全性
|与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。
在发送密码或其他敏感信息时绝不要使用 GET ！
|POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
|-
|可见性
|数据在 URL 中对所有人都是可见的。
|数据不会显示在 URL 中。
|}

== 转发和重定向的区别 ==
转发

1. 是服务器内部的重定向，服务器直接访问目标地址的 url网址，把里面的东西读取出来，但是客户端并不知道，因此用forward的话，客户端浏览器的网址是不会发生变化的。

2. 关于request: 由于在整个定向的过程中用的是同一个request，因此forward会将request的信息带到被重定向的地址中。

重定向

1.是客户端的重定向，是完全的跳转。即服务器返回的一个url给客户端浏览器，然后客户端浏览器会重新发送一次请求，到新的url里面，因此浏览器中显示的url网址会发生变化。

2.因为这种方式比forward多了一次网络请求，因此效率会低于forward。

== 堆栈区别 ==
== 并发和并行的区别 ==
行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

== 索引 ==
=== 不走索引 ===
=== 行级锁和表级锁 ===

行级锁定的优点：

· 当在许多线程中访问不同的行时只存在少量锁定冲突。

· 回滚时只有少量的更改。

· 可以长时间锁定单一的行。

行级锁定的缺点：

· 比页级或表级锁定占用更多的内存。

· 当在表的大部分中使用时，比页级或表级锁定速度慢，因为你必须获取更多的锁。

· 如果你在大部分数据上经常进行GROUP BY操作或者必须经常扫描整个表，比其它锁定明显慢很多。

· 用高级别锁定，通过支持不同的类型锁定，你也可以很容易地调节应用程序，因为其锁成本小于行级锁定。

== 存储引擎 ==
* InnoDB
== 数据库，事务，隔离级别，存储引擎 ==
* 数据库，三大范式
== redis，有什么优势 -memcache对比 ==
数据存储位置
* redis：内存、磁盘(数据持久化)
* memcache: 内存

存储数据的类型（都是键值对的形式）值的类型：
* redis：list、set、hash、string、zset等
* memcache：string

== http\https ==
* 默认端口不同80：443
* https需要颁发证书
* HTTPS协议的安全性更高
* https缺点
** 速度慢
** 服务器成本

== 数据库的存储引擎应用场景，索引结构 ==

MyISAM表使用B型树索引。读取场景下性能好，表锁，不能事务

InnoDB是为处理巨大数据量时的最大性能设计。B树。由于是行锁，写入、更新速度可能会快。

MEMORY表被存储在内存中，且默认使用哈希索引

为什么索引结构默认使用B-Tree，而不是hash，二叉树，红黑树？
* hash：虽然可以快速定位，但是没有顺序，IO复杂度高。
* 二叉树：树的高度不均匀，不能自平衡，查找效率跟数据有关（树的高度），并且IO代价高。
* 红黑树：树的高度随着数据量增加而增加，IO代价高。

为什么建议使用自增长主键作为索引。

结合B+Tree的特点，自增主键是连续的，在插入过程中尽量减少页分裂，即使要进行页分裂，也只会分裂很少一部分。并且能减少数据的移动，每次插入都是插入到最后。总之就是减少分裂和移动的频率。

== 大数据量的优化 ==
* 分区、分表、分库

== 设计一个权限系统 ==
== 算法题 ==
== 红黑树 ==
== 多线程，sleep，wait，yield ==
== restful ==
== 设计模式，单例模式，适配器模式 ==
== 操作系统，死锁 ==
== 快排时间复杂度 ==
== nginx可承受的压力 ==
== 项目 ==
* 项目难点
* 架构优化
* 难点
* 主要业务
== 服务调用超时可能由什么造成 ==

* 网络问题，是否繁忙？
* cpu、内存排查，cpu消耗高，处理不过来
* 服务端有没有收到请求，看请求响应时间
* 客服端网络、cpu等有问题

== 进程间的通信方式 ==
== fpm ==
* 合适的超时时间request_terminate_timeout、max_execution_time
* 看服务器性能，设置进程数量max_children
* fpm进程处理最大请求数max_requests

== nginx ==

* worker_processes 8; #nginx进程数，建议按照cpu数目来指定，一般为它的倍数,平时设置为2倍。

* 静态资源缓存

* nginx打开文件的最大个数

* buffer：如果buffer太小，Nginx会不停的写一些临时文件，这样会导致磁盘不停的去读写

== php array 结构 ==

hashtable+映射表的方式

hash=>映射表=>bucket

映射表与bucket长度相同

hash冲突的情况：链地址法。next设置为相同hash的索引，然后在映射表里的值替换成当前元素在bucket中的位置。

== 处理负载，高并发？==

# HTML静态化
效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。
# 图片服务器分离
把图片单独存储，尽量减少图片等大流量的开销，可以放在一些相关的平台上，如七牛等
# 数据库集群和库表散列及缓存
数据库的并发连接为100，一台数据库远远不够，可以从读写分离、主从复制，数据库集群方面来着手。另外尽量减少数据库的访问，可以使用缓存数据库如memcache、redis。
# 镜像：
尽量减少下载，可以把不同的请求分发到多个镜像端。
# 负载均衡：
Apache的最大并发连接为1500，只能增加服务器，可以从硬件上着手，如F5服务器。当然硬件的成本比较高，我们往往从软件方面着手。

== Laravel请求生命周期 ==

#、Laravel 采用了单一入口模式，应用的所有请求入口都是 public/index.php 文件。
#、注册类文件自动加载器 : Laravel通过 composer 进行依赖管理，无需开发者手动导入各种类文件，而由自动加载器自行导入。
#、创建服务容器：从 bootstrap/app.php 文件中取得 Laravel 应用实例 $app (服务容器)。
#、创建 HTTP / Console 内核：传入的请求会被发送给 HTTP 内核或者 console 内核进行处理
#、载入服务提供者至容器：在内核引导启动的过程中最重要的动作之一就是载入服务提供者到你的应用，服务提供者负责引导启动框架的全部各种组件，例如数据库、队列、验证器以及路由组件。
#、分发请求：一旦应用完成引导和所有服务提供者都注册完成，Request 将会移交给路由进行分发。路由将分发请求给一个路由或控制器，同时运行路由指定的中间件

常见问题

2019-10-22T06:53:49Z

Yaosong：/* Laravel请求生命周期 */

== cookie 和 session 的区别 ==
* 作用范围不同，Cookie 保存在客户端（浏览器），Session 保存在服务器端。
* 存取方式的不同，Cookie 只能保存 ASCII，Session 可以存任意数据类型，一般情况下我们可以在 Session 中保持一些常用变量信息，比如说 UserId 等。
* 有效期不同，Cookie 可设置为长时间保持，比如我们经常使用的默认登录功能，Session 一般失效时间较短，客户端关闭或者 Session 超时都会失效。
* 隐私策略不同，Cookie 存储在客户端，比较容易遭到不法获取，早期有人将用户的登录名和密码存储在 Cookie 中导致信息被窃取；Session 存储在服务端，安全性相对 Cookie 要好一些。
* 存储大小不同，单个 Cookie 保存的数据不能超过 4K，Session 可存储数据远高于 Cookie。

分布式session

ip_hash
Session 复制
缓存中间件

== post 和 get 的区别 ==
https://www.w3school.com.cn/tags/html_ref_httpmethods.asp

GET 用于获取信息，是无副作用的，是幂等的，且可缓存
POST 用于修改服务器上的数据，有副作用，非幂等，不可缓存
* 安全？post请求不会保留在浏览器历史记录中

{|class="wikitable"
!colspan="2"|GET
|POST
|-
|后退按钮/刷新
| 无害
|数据会被重新提交（浏览器应该告知用户数据会被重新提交）。
|-
|书签
|可收藏为书签
|不可收藏为书签
|-
|缓存
|能被缓存
|不能缓存
|-
|编码类型
| application/x-www-form-urlencoded
|application/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。
|-
|历史
|参数保留在浏览器历史中。
|参数不会保存在浏览器历史中。
|-
|对数据长度的限制
|是的。当发送数据时，GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。
|无限制。
|-
|对数据类型的限制
|只允许 ASCII 字符。
|没有限制。也允许二进制数据。
|-
|安全性
|与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。
在发送密码或其他敏感信息时绝不要使用 GET ！
|POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
|-
|可见性
|数据在 URL 中对所有人都是可见的。
|数据不会显示在 URL 中。
|}

== 转发和重定向的区别 ==
转发

1. 是服务器内部的重定向，服务器直接访问目标地址的 url网址，把里面的东西读取出来，但是客户端并不知道，因此用forward的话，客户端浏览器的网址是不会发生变化的。

2. 关于request: 由于在整个定向的过程中用的是同一个request，因此forward会将request的信息带到被重定向的地址中。

重定向

1.是客户端的重定向，是完全的跳转。即服务器返回的一个url给客户端浏览器，然后客户端浏览器会重新发送一次请求，到新的url里面，因此浏览器中显示的url网址会发生变化。

2.因为这种方式比forward多了一次网络请求，因此效率会低于forward。

== 堆栈区别 ==
== 并发和并行的区别 ==
行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

== 索引 ==
=== 不走索引 ===
=== 行级锁和表级锁 ===

行级锁定的优点：

· 当在许多线程中访问不同的行时只存在少量锁定冲突。

· 回滚时只有少量的更改。

· 可以长时间锁定单一的行。

行级锁定的缺点：

· 比页级或表级锁定占用更多的内存。

· 当在表的大部分中使用时，比页级或表级锁定速度慢，因为你必须获取更多的锁。

· 如果你在大部分数据上经常进行GROUP BY操作或者必须经常扫描整个表，比其它锁定明显慢很多。

· 用高级别锁定，通过支持不同的类型锁定，你也可以很容易地调节应用程序，因为其锁成本小于行级锁定。

== 存储引擎 ==
* InnoDB
== 数据库，事务，隔离级别，存储引擎 ==
* 数据库，三大范式
== redis，有什么优势 -memcache对比 ==
数据存储位置
* redis：内存、磁盘(数据持久化)
* memcache: 内存

存储数据的类型（都是键值对的形式）值的类型：
* redis：list、set、hash、string、zset等
* memcache：string

== http\https ==
* 默认端口不同80：443
* https需要颁发证书
* HTTPS协议的安全性更高
* https缺点
** 速度慢
** 服务器成本

== 数据库的存储引擎应用场景，索引结构 ==

MyISAM表使用B型树索引。读取场景下性能好，表锁，不能事务

InnoDB是为处理巨大数据量时的最大性能设计。B树。由于是行锁，写入、更新速度可能会快。

MEMORY表被存储在内存中，且默认使用哈希索引

为什么索引结构默认使用B-Tree，而不是hash，二叉树，红黑树？
* hash：虽然可以快速定位，但是没有顺序，IO复杂度高。
* 二叉树：树的高度不均匀，不能自平衡，查找效率跟数据有关（树的高度），并且IO代价高。
* 红黑树：树的高度随着数据量增加而增加，IO代价高。

为什么建议使用自增长主键作为索引。

结合B+Tree的特点，自增主键是连续的，在插入过程中尽量减少页分裂，即使要进行页分裂，也只会分裂很少一部分。并且能减少数据的移动，每次插入都是插入到最后。总之就是减少分裂和移动的频率。

== 大数据量的优化 ==
* 分区、分表、分库

== 设计一个权限系统 ==
== 算法题 ==
== 红黑树 ==
== 多线程，sleep，wait，yield ==
== restful ==
== 设计模式，单例模式，适配器模式 ==
== 操作系统，死锁 ==
== 快排时间复杂度 ==
== nginx可承受的压力 ==
== 项目 ==
* 项目难点
* 架构优化
* 难点
* 主要业务
== 服务调用超时可能由什么造成 ==

* 网络问题，是否繁忙？
* cpu、内存排查，cpu消耗高，处理不过来
* 服务端有没有收到请求，看请求响应时间
* 客服端网络、cpu等有问题

== 进程间的通信方式 ==
== fpm ==
* 合适的超时时间request_terminate_timeout、max_execution_time
* 看服务器性能，设置进程数量max_children
* fpm进程处理最大请求数max_requests

== nginx ==

* worker_processes 8; #nginx进程数，建议按照cpu数目来指定，一般为它的倍数,平时设置为2倍。

* 静态资源缓存

* nginx打开文件的最大个数

* buffer：如果buffer太小，Nginx会不停的写一些临时文件，这样会导致磁盘不停的去读写

== php array 结构 ==

hashtable+映射表的方式

hash=>映射表=>bucket

映射表与bucket长度相同

hash冲突的情况：链地址法。next设置为相同hash的索引，然后在映射表里的值替换成当前元素在bucket中的位置。

== 处理负载，高并发？==

# HTML静态化
效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。
# 图片服务器分离
把图片单独存储，尽量减少图片等大流量的开销，可以放在一些相关的平台上，如七牛等
# 数据库集群和库表散列及缓存
数据库的并发连接为100，一台数据库远远不够，可以从读写分离、主从复制，数据库集群方面来着手。另外尽量减少数据库的访问，可以使用缓存数据库如memcache、redis。
# 镜像：
尽量减少下载，可以把不同的请求分发到多个镜像端。
# 负载均衡：
Apache的最大并发连接为1500，只能增加服务器，可以从硬件上着手，如F5服务器。当然硬件的成本比较高，我们往往从软件方面着手。

== Laravel请求生命周期 ==

#、Laravel 采用了单一入口模式，应用的所有请求入口都是 public/index.php 文件。
#、注册类文件自动加载器 : Laravel通过 composer 进行依赖管理，无需开发者手动导入各种类文件，而由自动加载器自行导入。
#、创建服务容器：从 bootstrap/app.php 文件中取得 Laravel 应用实例 $app (服务容器)
创建 HTTP / Console 内核：传入的请求会被发送给 HTTP 内核或者 console 内核进行处理
#、载入服务提供者至容器：在内核引导启动的过程中最重要的动作之一就是载入服务提供者到你的应用，服务提供者负责引导启动框架的全部各种组件，例如数据库、队列、验证器以及路由组件。
#、分发请求：一旦应用完成引导和所有服务提供者都注册完成，Request 将会移交给路由进行分发。路由将分发请求给一个路由或控制器，同时运行路由指定的中间件

常见问题

2019-10-22T06:53:35Z

Yaosong：/* Laravel请求生命周期 */

== cookie 和 session 的区别 ==
* 作用范围不同，Cookie 保存在客户端（浏览器），Session 保存在服务器端。
* 存取方式的不同，Cookie 只能保存 ASCII，Session 可以存任意数据类型，一般情况下我们可以在 Session 中保持一些常用变量信息，比如说 UserId 等。
* 有效期不同，Cookie 可设置为长时间保持，比如我们经常使用的默认登录功能，Session 一般失效时间较短，客户端关闭或者 Session 超时都会失效。
* 隐私策略不同，Cookie 存储在客户端，比较容易遭到不法获取，早期有人将用户的登录名和密码存储在 Cookie 中导致信息被窃取；Session 存储在服务端，安全性相对 Cookie 要好一些。
* 存储大小不同，单个 Cookie 保存的数据不能超过 4K，Session 可存储数据远高于 Cookie。

分布式session

ip_hash
Session 复制
缓存中间件

== post 和 get 的区别 ==
https://www.w3school.com.cn/tags/html_ref_httpmethods.asp

GET 用于获取信息，是无副作用的，是幂等的，且可缓存
POST 用于修改服务器上的数据，有副作用，非幂等，不可缓存
* 安全？post请求不会保留在浏览器历史记录中

{|class="wikitable"
!colspan="2"|GET
|POST
|-
|后退按钮/刷新
| 无害
|数据会被重新提交（浏览器应该告知用户数据会被重新提交）。
|-
|书签
|可收藏为书签
|不可收藏为书签
|-
|缓存
|能被缓存
|不能缓存
|-
|编码类型
| application/x-www-form-urlencoded
|application/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。
|-
|历史
|参数保留在浏览器历史中。
|参数不会保存在浏览器历史中。
|-
|对数据长度的限制
|是的。当发送数据时，GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。
|无限制。
|-
|对数据类型的限制
|只允许 ASCII 字符。
|没有限制。也允许二进制数据。
|-
|安全性
|与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。
在发送密码或其他敏感信息时绝不要使用 GET ！
|POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
|-
|可见性
|数据在 URL 中对所有人都是可见的。
|数据不会显示在 URL 中。
|}

== 转发和重定向的区别 ==
转发

1. 是服务器内部的重定向，服务器直接访问目标地址的 url网址，把里面的东西读取出来，但是客户端并不知道，因此用forward的话，客户端浏览器的网址是不会发生变化的。

2. 关于request: 由于在整个定向的过程中用的是同一个request，因此forward会将request的信息带到被重定向的地址中。

重定向

1.是客户端的重定向，是完全的跳转。即服务器返回的一个url给客户端浏览器，然后客户端浏览器会重新发送一次请求，到新的url里面，因此浏览器中显示的url网址会发生变化。

2.因为这种方式比forward多了一次网络请求，因此效率会低于forward。

== 堆栈区别 ==
== 并发和并行的区别 ==
行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

== 索引 ==
=== 不走索引 ===
=== 行级锁和表级锁 ===

行级锁定的优点：

· 当在许多线程中访问不同的行时只存在少量锁定冲突。

· 回滚时只有少量的更改。

· 可以长时间锁定单一的行。

行级锁定的缺点：

· 比页级或表级锁定占用更多的内存。

· 当在表的大部分中使用时，比页级或表级锁定速度慢，因为你必须获取更多的锁。

· 如果你在大部分数据上经常进行GROUP BY操作或者必须经常扫描整个表，比其它锁定明显慢很多。

· 用高级别锁定，通过支持不同的类型锁定，你也可以很容易地调节应用程序，因为其锁成本小于行级锁定。

== 存储引擎 ==
* InnoDB
== 数据库，事务，隔离级别，存储引擎 ==
* 数据库，三大范式
== redis，有什么优势 -memcache对比 ==
数据存储位置
* redis：内存、磁盘(数据持久化)
* memcache: 内存

存储数据的类型（都是键值对的形式）值的类型：
* redis：list、set、hash、string、zset等
* memcache：string

== http\https ==
* 默认端口不同80：443
* https需要颁发证书
* HTTPS协议的安全性更高
* https缺点
** 速度慢
** 服务器成本

== 数据库的存储引擎应用场景，索引结构 ==

MyISAM表使用B型树索引。读取场景下性能好，表锁，不能事务

InnoDB是为处理巨大数据量时的最大性能设计。B树。由于是行锁，写入、更新速度可能会快。

MEMORY表被存储在内存中，且默认使用哈希索引

为什么索引结构默认使用B-Tree，而不是hash，二叉树，红黑树？
* hash：虽然可以快速定位，但是没有顺序，IO复杂度高。
* 二叉树：树的高度不均匀，不能自平衡，查找效率跟数据有关（树的高度），并且IO代价高。
* 红黑树：树的高度随着数据量增加而增加，IO代价高。

为什么建议使用自增长主键作为索引。

结合B+Tree的特点，自增主键是连续的，在插入过程中尽量减少页分裂，即使要进行页分裂，也只会分裂很少一部分。并且能减少数据的移动，每次插入都是插入到最后。总之就是减少分裂和移动的频率。

== 大数据量的优化 ==
* 分区、分表、分库

== 设计一个权限系统 ==
== 算法题 ==
== 红黑树 ==
== 多线程，sleep，wait，yield ==
== restful ==
== 设计模式，单例模式，适配器模式 ==
== 操作系统，死锁 ==
== 快排时间复杂度 ==
== nginx可承受的压力 ==
== 项目 ==
* 项目难点
* 架构优化
* 难点
* 主要业务
== 服务调用超时可能由什么造成 ==

* 网络问题，是否繁忙？
* cpu、内存排查，cpu消耗高，处理不过来
* 服务端有没有收到请求，看请求响应时间
* 客服端网络、cpu等有问题

== 进程间的通信方式 ==
== fpm ==
* 合适的超时时间request_terminate_timeout、max_execution_time
* 看服务器性能，设置进程数量max_children
* fpm进程处理最大请求数max_requests

== nginx ==

* worker_processes 8; #nginx进程数，建议按照cpu数目来指定，一般为它的倍数,平时设置为2倍。

* 静态资源缓存

* nginx打开文件的最大个数

* buffer：如果buffer太小，Nginx会不停的写一些临时文件，这样会导致磁盘不停的去读写

== php array 结构 ==

hashtable+映射表的方式

hash=>映射表=>bucket

映射表与bucket长度相同

hash冲突的情况：链地址法。next设置为相同hash的索引，然后在映射表里的值替换成当前元素在bucket中的位置。

== 处理负载，高并发？==

# HTML静态化
效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。
# 图片服务器分离
把图片单独存储，尽量减少图片等大流量的开销，可以放在一些相关的平台上，如七牛等
# 数据库集群和库表散列及缓存
数据库的并发连接为100，一台数据库远远不够，可以从读写分离、主从复制，数据库集群方面来着手。另外尽量减少数据库的访问，可以使用缓存数据库如memcache、redis。
# 镜像：
尽量减少下载，可以把不同的请求分发到多个镜像端。
# 负载均衡：
Apache的最大并发连接为1500，只能增加服务器，可以从硬件上着手，如F5服务器。当然硬件的成本比较高，我们往往从软件方面着手。

== Laravel请求生命周期 ==

1、Laravel 采用了单一入口模式，应用的所有请求入口都是 public/index.php 文件。
2、注册类文件自动加载器 : Laravel通过 composer 进行依赖管理，无需开发者手动导入各种类文件，而由自动加载器自行导入。
3、创建服务容器：从 bootstrap/app.php 文件中取得 Laravel 应用实例 $app (服务容器)
创建 HTTP / Console 内核：传入的请求会被发送给 HTTP 内核或者 console 内核进行处理
4、载入服务提供者至容器：在内核引导启动的过程中最重要的动作之一就是载入服务提供者到你的应用，服务提供者负责引导启动框架的全部各种组件，例如数据库、队列、验证器以及路由组件。
5、分发请求：一旦应用完成引导和所有服务提供者都注册完成，Request 将会移交给路由进行分发。路由将分发请求给一个路由或控制器，同时运行路由指定的中间件

常见问题

2019-10-22T06:36:03Z

Yaosong：/* Laravel请求生命周期 */

== cookie 和 session 的区别 ==
* 作用范围不同，Cookie 保存在客户端（浏览器），Session 保存在服务器端。
* 存取方式的不同，Cookie 只能保存 ASCII，Session 可以存任意数据类型，一般情况下我们可以在 Session 中保持一些常用变量信息，比如说 UserId 等。
* 有效期不同，Cookie 可设置为长时间保持，比如我们经常使用的默认登录功能，Session 一般失效时间较短，客户端关闭或者 Session 超时都会失效。
* 隐私策略不同，Cookie 存储在客户端，比较容易遭到不法获取，早期有人将用户的登录名和密码存储在 Cookie 中导致信息被窃取；Session 存储在服务端，安全性相对 Cookie 要好一些。
* 存储大小不同，单个 Cookie 保存的数据不能超过 4K，Session 可存储数据远高于 Cookie。

分布式session

ip_hash
Session 复制
缓存中间件

== post 和 get 的区别 ==
https://www.w3school.com.cn/tags/html_ref_httpmethods.asp

GET 用于获取信息，是无副作用的，是幂等的，且可缓存
POST 用于修改服务器上的数据，有副作用，非幂等，不可缓存
* 安全？post请求不会保留在浏览器历史记录中

{|class="wikitable"
!colspan="2"|GET
|POST
|-
|后退按钮/刷新
| 无害
|数据会被重新提交（浏览器应该告知用户数据会被重新提交）。
|-
|书签
|可收藏为书签
|不可收藏为书签
|-
|缓存
|能被缓存
|不能缓存
|-
|编码类型
| application/x-www-form-urlencoded
|application/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。
|-
|历史
|参数保留在浏览器历史中。
|参数不会保存在浏览器历史中。
|-
|对数据长度的限制
|是的。当发送数据时，GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。
|无限制。
|-
|对数据类型的限制
|只允许 ASCII 字符。
|没有限制。也允许二进制数据。
|-
|安全性
|与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。
在发送密码或其他敏感信息时绝不要使用 GET ！
|POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
|-
|可见性
|数据在 URL 中对所有人都是可见的。
|数据不会显示在 URL 中。
|}

== 转发和重定向的区别 ==
转发

1. 是服务器内部的重定向，服务器直接访问目标地址的 url网址，把里面的东西读取出来，但是客户端并不知道，因此用forward的话，客户端浏览器的网址是不会发生变化的。

2. 关于request: 由于在整个定向的过程中用的是同一个request，因此forward会将request的信息带到被重定向的地址中。

重定向

1.是客户端的重定向，是完全的跳转。即服务器返回的一个url给客户端浏览器，然后客户端浏览器会重新发送一次请求，到新的url里面，因此浏览器中显示的url网址会发生变化。

2.因为这种方式比forward多了一次网络请求，因此效率会低于forward。

== 堆栈区别 ==
== 并发和并行的区别 ==
行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

== 索引 ==
=== 不走索引 ===
=== 行级锁和表级锁 ===

行级锁定的优点：

· 当在许多线程中访问不同的行时只存在少量锁定冲突。

· 回滚时只有少量的更改。

· 可以长时间锁定单一的行。

行级锁定的缺点：

· 比页级或表级锁定占用更多的内存。

· 当在表的大部分中使用时，比页级或表级锁定速度慢，因为你必须获取更多的锁。

· 如果你在大部分数据上经常进行GROUP BY操作或者必须经常扫描整个表，比其它锁定明显慢很多。

· 用高级别锁定，通过支持不同的类型锁定，你也可以很容易地调节应用程序，因为其锁成本小于行级锁定。

== 存储引擎 ==
* InnoDB
== 数据库，事务，隔离级别，存储引擎 ==
* 数据库，三大范式
== redis，有什么优势 -memcache对比 ==
数据存储位置
* redis：内存、磁盘(数据持久化)
* memcache: 内存

存储数据的类型（都是键值对的形式）值的类型：
* redis：list、set、hash、string、zset等
* memcache：string

== http\https ==
* 默认端口不同80：443
* https需要颁发证书
* HTTPS协议的安全性更高
* https缺点
** 速度慢
** 服务器成本

== 数据库的存储引擎应用场景，索引结构 ==

MyISAM表使用B型树索引。读取场景下性能好，表锁，不能事务

InnoDB是为处理巨大数据量时的最大性能设计。B树。由于是行锁，写入、更新速度可能会快。

MEMORY表被存储在内存中，且默认使用哈希索引

为什么索引结构默认使用B-Tree，而不是hash，二叉树，红黑树？
* hash：虽然可以快速定位，但是没有顺序，IO复杂度高。
* 二叉树：树的高度不均匀，不能自平衡，查找效率跟数据有关（树的高度），并且IO代价高。
* 红黑树：树的高度随着数据量增加而增加，IO代价高。

为什么建议使用自增长主键作为索引。

结合B+Tree的特点，自增主键是连续的，在插入过程中尽量减少页分裂，即使要进行页分裂，也只会分裂很少一部分。并且能减少数据的移动，每次插入都是插入到最后。总之就是减少分裂和移动的频率。

== 大数据量的优化 ==
* 分区、分表、分库

== 设计一个权限系统 ==
== 算法题 ==
== 红黑树 ==
== 多线程，sleep，wait，yield ==
== restful ==
== 设计模式，单例模式，适配器模式 ==
== 操作系统，死锁 ==
== 快排时间复杂度 ==
== nginx可承受的压力 ==
== 项目 ==
* 项目难点
* 架构优化
* 难点
* 主要业务
== 服务调用超时可能由什么造成 ==

* 网络问题，是否繁忙？
* cpu、内存排查，cpu消耗高，处理不过来
* 服务端有没有收到请求，看请求响应时间
* 客服端网络、cpu等有问题

== 进程间的通信方式 ==
== fpm ==
* 合适的超时时间request_terminate_timeout、max_execution_time
* 看服务器性能，设置进程数量max_children
* fpm进程处理最大请求数max_requests

== nginx ==

* worker_processes 8; #nginx进程数，建议按照cpu数目来指定，一般为它的倍数,平时设置为2倍。

* 静态资源缓存

* nginx打开文件的最大个数

* buffer：如果buffer太小，Nginx会不停的写一些临时文件，这样会导致磁盘不停的去读写

== php array 结构 ==

hashtable+映射表的方式

hash=>映射表=>bucket

映射表与bucket长度相同

hash冲突的情况：链地址法。next设置为相同hash的索引，然后在映射表里的值替换成当前元素在bucket中的位置。

== 处理负载，高并发？==

# HTML静态化
效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。
# 图片服务器分离
把图片单独存储，尽量减少图片等大流量的开销，可以放在一些相关的平台上，如七牛等
# 数据库集群和库表散列及缓存
数据库的并发连接为100，一台数据库远远不够，可以从读写分离、主从复制，数据库集群方面来着手。另外尽量减少数据库的访问，可以使用缓存数据库如memcache、redis。
# 镜像：
尽量减少下载，可以把不同的请求分发到多个镜像端。
# 负载均衡：
Apache的最大并发连接为1500，只能增加服务器，可以从硬件上着手，如F5服务器。当然硬件的成本比较高，我们往往从软件方面着手。

== Laravel请求生命周期 ==

# index.php
# app.php 获取app实例
# http kernel 或者 console kernel
## bootstrappers，执行请求之前运行的数组，配置错误处理、配置日志记录、检测应用程序环境以及执行其他需要完成的任务
## 中间件列表
## handle处理请求，Request，返回Response
# 服务提供器，负责引导所有框架的各种组件

常见问题

2019-10-22T06:35:44Z

Yaosong：/* 处理负载，高并发？ */

== cookie 和 session 的区别 ==
* 作用范围不同，Cookie 保存在客户端（浏览器），Session 保存在服务器端。
* 存取方式的不同，Cookie 只能保存 ASCII，Session 可以存任意数据类型，一般情况下我们可以在 Session 中保持一些常用变量信息，比如说 UserId 等。
* 有效期不同，Cookie 可设置为长时间保持，比如我们经常使用的默认登录功能，Session 一般失效时间较短，客户端关闭或者 Session 超时都会失效。
* 隐私策略不同，Cookie 存储在客户端，比较容易遭到不法获取，早期有人将用户的登录名和密码存储在 Cookie 中导致信息被窃取；Session 存储在服务端，安全性相对 Cookie 要好一些。
* 存储大小不同，单个 Cookie 保存的数据不能超过 4K，Session 可存储数据远高于 Cookie。

分布式session

ip_hash
Session 复制
缓存中间件

== post 和 get 的区别 ==
https://www.w3school.com.cn/tags/html_ref_httpmethods.asp

GET 用于获取信息，是无副作用的，是幂等的，且可缓存
POST 用于修改服务器上的数据，有副作用，非幂等，不可缓存
* 安全？post请求不会保留在浏览器历史记录中

{|class="wikitable"
!colspan="2"|GET
|POST
|-
|后退按钮/刷新
| 无害
|数据会被重新提交（浏览器应该告知用户数据会被重新提交）。
|-
|书签
|可收藏为书签
|不可收藏为书签
|-
|缓存
|能被缓存
|不能缓存
|-
|编码类型
| application/x-www-form-urlencoded
|application/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。
|-
|历史
|参数保留在浏览器历史中。
|参数不会保存在浏览器历史中。
|-
|对数据长度的限制
|是的。当发送数据时，GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。
|无限制。
|-
|对数据类型的限制
|只允许 ASCII 字符。
|没有限制。也允许二进制数据。
|-
|安全性
|与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。
在发送密码或其他敏感信息时绝不要使用 GET ！
|POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
|-
|可见性
|数据在 URL 中对所有人都是可见的。
|数据不会显示在 URL 中。
|}

== 转发和重定向的区别 ==
转发

1. 是服务器内部的重定向，服务器直接访问目标地址的 url网址，把里面的东西读取出来，但是客户端并不知道，因此用forward的话，客户端浏览器的网址是不会发生变化的。

2. 关于request: 由于在整个定向的过程中用的是同一个request，因此forward会将request的信息带到被重定向的地址中。

重定向

1.是客户端的重定向，是完全的跳转。即服务器返回的一个url给客户端浏览器，然后客户端浏览器会重新发送一次请求，到新的url里面，因此浏览器中显示的url网址会发生变化。

2.因为这种方式比forward多了一次网络请求，因此效率会低于forward。

== 堆栈区别 ==
== 并发和并行的区别 ==
行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

== 索引 ==
=== 不走索引 ===
=== 行级锁和表级锁 ===

行级锁定的优点：

· 当在许多线程中访问不同的行时只存在少量锁定冲突。

· 回滚时只有少量的更改。

· 可以长时间锁定单一的行。

行级锁定的缺点：

· 比页级或表级锁定占用更多的内存。

· 当在表的大部分中使用时，比页级或表级锁定速度慢，因为你必须获取更多的锁。

· 如果你在大部分数据上经常进行GROUP BY操作或者必须经常扫描整个表，比其它锁定明显慢很多。

· 用高级别锁定，通过支持不同的类型锁定，你也可以很容易地调节应用程序，因为其锁成本小于行级锁定。

== 存储引擎 ==
* InnoDB
== 数据库，事务，隔离级别，存储引擎 ==
* 数据库，三大范式
== redis，有什么优势 -memcache对比 ==
数据存储位置
* redis：内存、磁盘(数据持久化)
* memcache: 内存

存储数据的类型（都是键值对的形式）值的类型：
* redis：list、set、hash、string、zset等
* memcache：string

== http\https ==
* 默认端口不同80：443
* https需要颁发证书
* HTTPS协议的安全性更高
* https缺点
** 速度慢
** 服务器成本

== 数据库的存储引擎应用场景，索引结构 ==

MyISAM表使用B型树索引。读取场景下性能好，表锁，不能事务

InnoDB是为处理巨大数据量时的最大性能设计。B树。由于是行锁，写入、更新速度可能会快。

MEMORY表被存储在内存中，且默认使用哈希索引

为什么索引结构默认使用B-Tree，而不是hash，二叉树，红黑树？
* hash：虽然可以快速定位，但是没有顺序，IO复杂度高。
* 二叉树：树的高度不均匀，不能自平衡，查找效率跟数据有关（树的高度），并且IO代价高。
* 红黑树：树的高度随着数据量增加而增加，IO代价高。

为什么建议使用自增长主键作为索引。

结合B+Tree的特点，自增主键是连续的，在插入过程中尽量减少页分裂，即使要进行页分裂，也只会分裂很少一部分。并且能减少数据的移动，每次插入都是插入到最后。总之就是减少分裂和移动的频率。

== 大数据量的优化 ==
* 分区、分表、分库

== 设计一个权限系统 ==
== 算法题 ==
== 红黑树 ==
== 多线程，sleep，wait，yield ==
== restful ==
== 设计模式，单例模式，适配器模式 ==
== 操作系统，死锁 ==
== 快排时间复杂度 ==
== nginx可承受的压力 ==
== 项目 ==
* 项目难点
* 架构优化
* 难点
* 主要业务
== 服务调用超时可能由什么造成 ==

* 网络问题，是否繁忙？
* cpu、内存排查，cpu消耗高，处理不过来
* 服务端有没有收到请求，看请求响应时间
* 客服端网络、cpu等有问题

== 进程间的通信方式 ==
== fpm ==
* 合适的超时时间request_terminate_timeout、max_execution_time
* 看服务器性能，设置进程数量max_children
* fpm进程处理最大请求数max_requests

== nginx ==

* worker_processes 8; #nginx进程数，建议按照cpu数目来指定，一般为它的倍数,平时设置为2倍。

* 静态资源缓存

* nginx打开文件的最大个数

* buffer：如果buffer太小，Nginx会不停的写一些临时文件，这样会导致磁盘不停的去读写

== php array 结构 ==

hashtable+映射表的方式

hash=>映射表=>bucket

映射表与bucket长度相同

hash冲突的情况：链地址法。next设置为相同hash的索引，然后在映射表里的值替换成当前元素在bucket中的位置。

== 处理负载，高并发？==

# HTML静态化
效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。
# 图片服务器分离
把图片单独存储，尽量减少图片等大流量的开销，可以放在一些相关的平台上，如七牛等
# 数据库集群和库表散列及缓存
数据库的并发连接为100，一台数据库远远不够，可以从读写分离、主从复制，数据库集群方面来着手。另外尽量减少数据库的访问，可以使用缓存数据库如memcache、redis。
# 镜像：
尽量减少下载，可以把不同的请求分发到多个镜像端。
# 负载均衡：
Apache的最大并发连接为1500，只能增加服务器，可以从硬件上着手，如F5服务器。当然硬件的成本比较高，我们往往从软件方面着手。

== Laravel请求生命周期 ==

# index.php
# app.php 获取app实例
# http kernel 或者 console kernel
# bootstrappers，执行请求之前运行的数组，配置错误处理、配置日志记录、检测应用程序环境以及执行其他需要完成的任务
# 中间件列表
# handle处理请求，Request，返回Response

# 服务提供器，负责引导所有框架的各种组件

Linux

2019-09-21T08:15:04Z

Yaosong：

Linux

2019-09-06T02:03:00Z

Yaosong：/* nginx fpm connect() to unix:xxx failed. http 502 */

Linux

2019-09-05T09:30:29Z

Yaosong：/* nginx fpm connect() to unix:xxx failed. http 502 */

== 工具 ==

* [[https://stedolan.github.io/jq/ jq]] 一个轻量级且灵活的命令行JSON处理器

* [[https://geoff.greer.fm/ag/ ag]] The Silver Searcher代码搜索工具
* [[https://github.com/yaosonglive/vim .vimrc]] vim制表符换成控制配置

== Nginx ==
* [[Nginx灰度]] cookie实现灰度
* 常见错误
** 413 Request Entity Too Large
**: <code>client_max_body_size 8m;</code>

== 图片压缩 ==
使用imagemagick进行图片压缩
首先安装apt install imagemagick

下面是demo，把再当前路径下的public目录中的图片进行压缩:
<nowiki>
import os

arr = [
'/upload/images/c0d0d881b2d742165999d91ec6380de2.jpg',
'/upload/images/4e16982954bcbe89667ec70f67c02f20.jpg',
]

for i in arr:
try:
# print i
kb = os.path.getsize('./public%s' % i)
newNames = os.path.splitext(i)
strname = '%s_s%s' % newNames
if kb/1024 > 1:
shell = "convert -sample 30%%x30%% ./public%s ./public%s" % (i, strname)
os.system(shell)
# print "update themes set preview='%s' where preview='%s';" % (strname, i)
except Exception,e :
print e
pass

</nowiki>
-resize 是缩小，-sample 是压缩

== 其他 ==
* [[公钥]]

* 终端不能输入中文
*# 先<code>locale -a</code>查看，是否有<code>zh_CN.utf8</code>
*# 如果没有,安装：
*#: centos: yum install glibc-common
*#: ubuntu: apt-get -y install language-pack-zh-hans
*# 重新进入终端，检查环境变量, 如果还是不行，修改环境变量:
*#* LANG=zh_CN.UTF-8
*#* LC_ALL=LC_ALL=zh_CN.UTF-8

== 端口检测 ==
* telnet
:在telnet连接成功后，使用<code>Control +]</code>然后使用<code>Control + D</code>退出它。
:列出所有TCP连接套接字
<nowiki>
telnet localhost 80</nowiki>

* lsof
:监听ipv4进程
<nowiki>
sudo lsof -n -i4TCP:5672 | grep LISTEN</nowiki>
:IPv6的程序：
<nowiki>
sudo lsof -n -i6TCP:5672 | grep LISTEN</nowiki>

* ss
:使用ss显示使用IPv4及其操作系统进程的侦听TCP套接字：
<nowiki>
sudo ss --tcp -f inet --listening --numeric --processes</nowiki>
:同样，对于使用IPv6的TCP套接字：
<nowiki>
sudo ss --tcp -f inet6 --listening --numeric --processes</nowiki>

* netstat
<nowiki>
sudo netstat --all --numeric --tcp --programs</nowiki>

== nginx fpm connect() to unix:xxx failed. http 502 ==
https://forum.nginx.org/read.php?11,215606,215606#msg-215606

pm

pm.max_children

listen.backlog = 4096

* nginx

<nowiki>
server {
listen 80 backlog=1024;
... ...
}
</nowiki>

开多个fpm

Linux

2019-09-05T09:28:50Z

Yaosong：/* nginx fpm connect() to unix:xxx failed. http 502 */

== 工具 ==

* [[https://stedolan.github.io/jq/ jq]] 一个轻量级且灵活的命令行JSON处理器

* [[https://geoff.greer.fm/ag/ ag]] The Silver Searcher代码搜索工具
* [[https://github.com/yaosonglive/vim .vimrc]] vim制表符换成控制配置

== Nginx ==
* [[Nginx灰度]] cookie实现灰度
* 常见错误
** 413 Request Entity Too Large
**: <code>client_max_body_size 8m;</code>

== 图片压缩 ==
使用imagemagick进行图片压缩
首先安装apt install imagemagick

下面是demo，把再当前路径下的public目录中的图片进行压缩:
<nowiki>
import os

arr = [
'/upload/images/c0d0d881b2d742165999d91ec6380de2.jpg',
'/upload/images/4e16982954bcbe89667ec70f67c02f20.jpg',
]

for i in arr:
try:
# print i
kb = os.path.getsize('./public%s' % i)
newNames = os.path.splitext(i)
strname = '%s_s%s' % newNames
if kb/1024 > 1:
shell = "convert -sample 30%%x30%% ./public%s ./public%s" % (i, strname)
os.system(shell)
# print "update themes set preview='%s' where preview='%s';" % (strname, i)
except Exception,e :
print e
pass

</nowiki>
-resize 是缩小，-sample 是压缩

== 其他 ==
* [[公钥]]

* 终端不能输入中文
*# 先<code>locale -a</code>查看，是否有<code>zh_CN.utf8</code>
*# 如果没有,安装：
*#: centos: yum install glibc-common
*#: ubuntu: apt-get -y install language-pack-zh-hans
*# 重新进入终端，检查环境变量, 如果还是不行，修改环境变量:
*#* LANG=zh_CN.UTF-8
*#* LC_ALL=LC_ALL=zh_CN.UTF-8

== 端口检测 ==
* telnet
:在telnet连接成功后，使用<code>Control +]</code>然后使用<code>Control + D</code>退出它。
:列出所有TCP连接套接字
<nowiki>
telnet localhost 80</nowiki>

* lsof
:监听ipv4进程
<nowiki>
sudo lsof -n -i4TCP:5672 | grep LISTEN</nowiki>
:IPv6的程序：
<nowiki>
sudo lsof -n -i6TCP:5672 | grep LISTEN</nowiki>

* ss
:使用ss显示使用IPv4及其操作系统进程的侦听TCP套接字：
<nowiki>
sudo ss --tcp -f inet --listening --numeric --processes</nowiki>
:同样，对于使用IPv6的TCP套接字：
<nowiki>
sudo ss --tcp -f inet6 --listening --numeric --processes</nowiki>

* netstat
<nowiki>
sudo netstat --all --numeric --tcp --programs</nowiki>

== nginx fpm connect() to unix:xxx failed. http 502 ==
https://forum.nginx.org/read.php?11,215606,215606#msg-215606

pm

pm.max_children

listen.backlog = 4096

* nginx

<nowiki>
server {
listen 80 backlog=1024;
... ...
}
</nowiki>

Linux

2019-09-05T09:01:30Z

Yaosong：

常见问题

2019-09-04T15:26:04Z

Yaosong：/* 处理负载，高并发？ */

常见问题

2019-09-04T15:25:08Z

Yaosong：

常见问题

2019-09-04T15:19:32Z

Yaosong：/* redis，有什么优势 -memcache对比 */

常见问题

2019-09-04T15:10:36Z

Yaosong：/* php array */

常见问题

2019-09-04T15:06:18Z

Yaosong：

面试

2019-09-02T09:59:54Z

Yaosong：清空页面

常见问题

2019-09-02T09:59:19Z

Yaosong：Yaosong移动页面面试至常见问题

面试

2019-09-02T09:59:19Z

Yaosong：Yaosong移动页面面试至常见问题

#重定向 [[常见问题]]