PHPor 的Blog – 第6页

golang 字符串截取

示例：

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	substr()
}

type String struct  {
	str *byte
	length int
}

func (s *String) String() string {
	return fmt.Sprintf("str: %p\nlen: %d", s.str, s.length)
}

func inspectString(s *string) {
	a := (*String)(unsafe.Pointer(s))
	fmt.Printf("%s\n", a.String())
}

// 变量a的地址比变量b的地址大16字节，一方面体现了栈是向下走的，先分配a，在分配b
// 另一方面，也体现了字符串变量占用的内存大小是16字节，一个指针和一个int
// 变量b的str指针比变量a的str指针大2，说明b没有产生新的字符串内容
func substr() {
	a := "12345"
	b := a[2:4]
	println("a:", &a)
	inspectString(&a)
	println("b:", &b)
	inspectString(&b)
}

package main

import (

"fmt"

"unsafe"

)

func main() {

substr()

}

type String struct {

str *byte

length int

}

func (s *String) String() string {

return fmt.Sprintf("str: %p\nlen: %d", s.str, s.length)

}

func inspectString(s *string) {

a := (*String)(unsafe.Pointer(s))

fmt.Printf("%s\n", a.String())

}

// 变量a的地址比变量b的地址大16字节，一方面体现了栈是向下走的，先分配a，在分配b

// 另一方面，也体现了字符串变量占用的内存大小是16字节，一个指针和一个int

// 变量b的str指针比变量a的str指针大2，说明b没有产生新的字符串内容

func substr() {

a := "12345"

b := a[2:4]

println("a:", &a)

inspectString(&a)

println("b:", &b)

inspectString(&b)

}

这里的字符串b复用了字符串a的一部分，使得
1. 截取操作很快
2. 字符串a离开作用域而字符串b没有离开作用域的话，a不能被gc

golang http-server 知识点

连接状态：

关于测试

go语言开创性的让对测试的支持成为了语言本身的重要组成部分，足以说明go语言对测试的重视以及测试本身的重要性

儿子国旗下讲话 – 读书让我快乐

dolthub/dolt: Dolt – It’s Git for Data

https://github.com/dolthub/dolt

让MySQL表也能版本管理，这个对于存储配置的数据库非常不错。

通常使用git存储配置的好处是方便查看变更历史。然而，如何让生产服务器访问却不太方便。

所以，很多时候使用MySQL存储配置，但是，查看变更历史就不那么方便了。

现在，有了dolt，简直太棒了！

让tcpdump 不需要sudo

setcap cap_net_raw,cap_net_admin=eip /usr/sbin/tcpdump

1	setcap cap_net_raw,cap_net_admin=eip /usr/sbin/tcpdump

golang 之静态链接

golang程序如果build时不是static的话，Linux上基本会依赖glibc的动态库的，通常也不是啥问题，但是，如果你期望一个更高版本的glibc，但是目标机器上没有，就尴尬了，这时候，其实可以编译成一个静态链接的二进制程序的，这时候需要的就是编译环境上有glibc-static，centos上的安装方法为：

 yum install glibc-static -y

1	yum install glibc-static -y

那么，静态链接和动态链接后的目标文件差别会非常大吗？

从目标文件大小上来看，应该会大一些，但是并不大的离谱：

 # ll -h ./build/manager*
-rwxr-xr-x  1 junjie20  staff    24M Feb 20 11:42 ./build/manager
-rwxr-xr-x  1 junjie20  staff    28M Feb 20 11:57 ./build/manager-static

# ll -h ./build/manager*

-rwxr-xr-x 1 junjie20 staff 24M Feb 20 11:42 ./build/manager

-rwxr-xr-x 1 junjie20 staff 28M Feb 20 11:57 ./build/manager-static

或许这个差值基本比较固定，你的程序越大，这个差值的占比就越小；但是，和你使用到的glibc中的代码的多少有关系
从执行的角度来看，动态链接是会启动更快一些，也比较节省内存，因为底层的动态库在内存中只需要加载一次；但是，如果我们的程序是跑在容器中的，而且，通常容器中只有一个进程，那么，扩容器共享底层动态库的可能性就很小，因为它能不是同一个文件（或许有技术可以做到这一点）。
编译的时候，静态链接会比动态链接要慢一点点，应该差别也不会太明显
所以，过时的静态链接可能真的又可以回来了

静态链接只需要添加选项：

--ldflags '--extldflags "-static -fpic"'

1	--ldflags '--extldflags "-static -fpic"'

注意：

静态链接不代表完全没有依赖，有些情况下对内核版本是有要求的

如何做Redis的持久化？

参考资料： http://tech.it168.com/a2012/0806/1381/000001381007_1.shtml

方式1：简单的aof文件方式

这种方式只生成aof文件；

优点：不会定期生成snapshot，对磁盘消耗小（不是少），也不会因为生成snapshot时写磁盘对服务带来影响（虽然影响不太大）

缺点：重新启动服务时可能需要无法估计的时间

方式2： snapshot方式

该方式不生成aof文件，定期产生snapshot文件

优点：重启服务时，启动速度快

缺点：会丢失最后一次产生snapshot到意外宕机之间的写数据

方式3： aof + bgrewriteaof

1. 产生aof文件

2. 通过 bgrewriteaof 命令定期压缩aof（其实是根据内容中的数据重新生成aof）文件

优点：不会导致aof文件太大而占用太大的磁盘文件，不会因为aof文件太大而导致重启服务时太慢

缺点：毕竟重启服务还是要加载aof文件的

方式4： snapshot + aof + snapshot点（该方式是否可行未经验证）

1. 定期产生snapshot文件

2. 产生snapshot文件后，删除文件中snapshot点之前的数据，这样aof就不会太大了

3. 服务重启时，先加载snapshop，在加载snapshot时间点后的aof文件

4. 这样的话，aof文件中记录的命令不应该有类似 incr decr之类的命令，应该都是set、delete之类的命令，这个和snapshot点的选择有关系（没法选择一个确切的snapshot点）; 或者： snapshot期间允许用户执行写操作吗？不允许的话就没有这个问题了，如果不允许的话，这个条件也太苛刻了

5. ~~从redis的源码来看，是不会同时参考snapshot的rdb文件和aof文件的~~：

/* Function called at startup to load RDB or AOF file in memory. */
void loadDataFromDisk(void) {
    long long start = ustime();
    if (server.aof_state == AOF_ON) {
        if (loadAppendOnlyFile(server.aof_filename) == C_OK)
            serverLog(LL_NOTICE,"DB loaded from append only file: %.3f seconds",(float)(ustime()-start)/1000000);
    } else {
        rdbSaveInfo rsi = RDB_SAVE_INFO_INIT;
        errno = 0; /* Prevent a stale value from affecting error checking */
        if (rdbLoad(server.rdb_filename,&rsi,RDBFLAGS_NONE) == C_OK) {
            serverLog(LL_NOTICE,"DB loaded from disk: %.3f seconds",
                (float)(ustime()-start)/1000000);

            /* Restore the replication ID / offset from the RDB file. */
            if ((server.masterhost ||
                (server.cluster_enabled &&
                nodeIsSlave(server.cluster->myself))) &&
                rsi.repl_id_is_set &&
                rsi.repl_offset != -1 &&
                /* Note that older implementations may save a repl_stream_db
                 * of -1 inside the RDB file in a wrong way, see more
                 * information in function rdbPopulateSaveInfo. */
                rsi.repl_stream_db != -1)
            {
                memcpy(server.replid,rsi.repl_id,sizeof(server.replid));
                server.master_repl_offset = rsi.repl_offset;
                /* If we are a slave, create a cached master from this
                 * information, in order to allow partial resynchronizations
                 * with masters. */
                replicationCacheMasterUsingMyself();
                selectDb(server.cached_master,rsi.repl_stream_db);
            }
        } else if (errno != ENOENT) {
            serverLog(LL_WARNING,"Fatal error loading the DB: %s. Exiting.",strerror(errno));
            exit(1);
        }
    }
}

/* Function called at startup to load RDB or AOF file in memory. */

void loadDataFromDisk(void) {

long long start = ustime();

if (server.aof_state == AOF_ON) {

if (loadAppendOnlyFile(server.aof_filename) == C_OK)

serverLog(LL_NOTICE,"DB loaded from append only file: %.3f seconds",(float)(ustime()-start)/1000000);

} else {

rdbSaveInfo rsi = RDB_SAVE_INFO_INIT;

errno = 0; /* Prevent a stale value from affecting error checking */

if (rdbLoad(server.rdb_filename,&rsi,RDBFLAGS_NONE) == C_OK) {

serverLog(LL_NOTICE,"DB loaded from disk: %.3f seconds",

(float)(ustime()-start)/1000000);

/* Restore the replication ID / offset from the RDB file. */

if ((server.masterhost ||

(server.cluster_enabled &&

nodeIsSlave(server.cluster->myself))) &&

rsi.repl_id_is_set &&

rsi.repl_offset != -1 &&

/* Note that older implementations may save a repl_stream_db

* of -1 inside the RDB file in a wrong way, see more

* information in function rdbPopulateSaveInfo. */

rsi.repl_stream_db != -1)

{

memcpy(server.replid,rsi.repl_id,sizeof(server.replid));

server.master_repl_offset = rsi.repl_offset;

/* If we are a slave, create a cached master from this

* information, in order to allow partial resynchronizations

* with masters. */

replicationCacheMasterUsingMyself();

selectDb(server.cached_master,rsi.repl_stream_db);

}

} else if (errno != ENOENT) {

serverLog(LL_WARNING,"Fatal error loading the DB: %s. Exiting.",strerror(errno));

exit(1);

}

其实， redis4.0之后，是支持rdb+aof 方式的，这时候，loadAppendOnlyFile() 函数中有rdb相关逻辑，而且，这时候的aof文件的前面部分其实就是rdb文件的内容，但是依然叫做aof文件，所以，依然时候loadAppendOnlyFile() 函数就搞定了。

参考： Redis-4.0以后的混合持久化_gdlsky的博客-CSDN博客_redis混合持久化

关于snapshot的频率：

原来以为 save 300 10 解释为：超过300s或者超过10条变更就snapshot，其实不是的，而是：超过300s并且超过10条变更就snapshot

################################ SNAPSHOTTING  #################################
#
# Save the DB on disk:
#
#   save &lt;seconds&gt; &lt;changes&gt;
#
#   Will save the DB if both the given number of seconds and the given
#   number of write operations against the DB occurred.
#
#   In the example below the behaviour will be to save:
#   after 900 sec (15 min) if at least 1 key changed
#   after 300 sec (5 min) if at least 10 keys changed
#   after 60 sec if at least 10000 keys changed
#
#   Note: you can disable saving at all commenting all the "save" lines.
#
#   It is also possible to remove all the previously configured save
#   points by adding a save directive with a single empty string argument
#   like in the following example:
#
#   save ""

save 900 1
save 300 10
save 60 10000

################################ SNAPSHOTTING #################################

# Save the DB on disk:

# save <seconds> <changes>

# Will save the DB if both the given number of seconds and the given

# number of write operations against the DB occurred.

# In the example below the behaviour will be to save:

# after 900 sec (15 min) if at least 1 key changed

# after 300 sec (5 min) if at least 10 keys changed

# after 60 sec if at least 10000 keys changed

# Note: you can disable saving at all commenting all the "save" lines.

# It is also possible to remove all the previously configured save

# points by adding a save directive with a single empty string argument

# like in the following example:

# save ""

save 900 1

save 300 10

save 60 10000

curl代理

默认情况下：

curl -x ip:port http://phpor.net/

1	curl -x ip:port http://phpor.net/

使用的是普通代理，就是：

如果访问https地址，就是隧道代理：

curl -x ip:port https://phpor.net/

1	curl -x ip:port https://phpor.net/

如果要让http请求也是用隧道代理，则添加 -p 选项:

curl -p -x 10.222.101.37:8080 -v http://phpor.net/blog

1	curl -p -x 10.222.101.37:8080 -v http://phpor.net/blog

如果要让https请求使用普通代理呢？没有找到这个选项

c++之typedef 和 typename

c中就有typedef 就是定义一个类型别名。

typename是c++中的，只是名字上和typedef相似，有时候还挨着用，就会感觉显得啰嗦。

typename用来告诉编译器后面这个东西是个名字空间或类中定义的类型，而不是成员变量

参考：

https://blog.csdn.net/zhangxiao93/article/details/50569924