一、获取锁等待情况

可以通过检查table_locks_waited和table_locks_immediate状态变量来分析系统上的表锁定争夺： mysql> show status like ‘Table%’; +—————————-+———-+ | Variable_name       | Value | +—————————-+———-+ | Table_locks_immediate   | 105       | | Table_locks_waited  | 3     | +—————————-+———-+ 2 rows in set (0.00 sec)

Table_locks_immediate 表示立即释放MySQL表锁数， Table_locks_waited 表示需要等待的MySQL表锁数

如果Table_locks_waited的值比较高，则说明存在着较严重的表级锁争用情况。这时，需要我们对应用做进一步的检查，来确定问题所在。

可以通过检查Innodb_row_lock状态变量来分析系统上的行锁的争夺情况： mysql> show status like ‘innodb_row_lock%’; +—————————————-+———-+ | Variable_name               | Value | +—————————————-+———-+ | Innodb_row_lock_current_waits   | 0     | | Innodb_row_lock_time            | 2001  | | Innodb_row_lock_time_avg        | 667       | | Innodb_row_lock_time_max    | 845       | | Innodb_row_lock_waits       | 3     | +—————————————-+———-+ 5 rows in set (0.00 sec)

自定义一个结构体

type Rect struct {
    x, y float64
    width, height float64
}

初始化方法：

rect1 := new(Rect)
rect2 := &Rect{}
rect3 := &Rect{0, 0, 100, 200}
rect4 := &Rect{width:100, height:200}

注意这几个变量全部为指向Rect结构的指针(指针变量)，因为使用了new()函数和&操作符。

而如果使用方法

a := Rect{}

则表示这个是一个Rect{}结构类型．两者是不一样的．参考代码：

func main() {
a := Rect{}
a.x = 15

rect1 := &Rect{0, 0, 100, 200}
rect1.x = 10

fmt.Printf("%v\n%T\n", a, a)
fmt.Printf("%v\n%T\n", rect1, rect1)
}

运行结果为:

{15 0 0 0}
 main.Rect
 &{10 0 100 200}
 *main.Rect

从结果中可以清楚的看到两者的不同．一个是结构类型，另一个是结构类型的指针。

在Go语言中，未进行初始化的变量都会被初始化为该类型的零值，例如bool类型的零值为false, int类型的零值为0, string类型的零值为空字符串． 在Go语言中没有构造函数的概念,对象的创建通常交由一个全局的创建函数来完成,以NewXXX来命令,表示”构造函数”:

foo.go

// CopyRight 2013 The Go Author. All Right reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE fifle.

/*
Package foo implements a set of simple mathematical functions. These comments are for
demonstration purpose only. Nothing more.

If you have any questions,please don’t hesitate to add yourself to
golang-uns@googlegroups.com.

you can alse visit golang.org for full Go documentation.
*/

package foo

import (
	"fmt"
)

// Foo compares the two input values and retrens the larger
// Value, If the two values are equal, return 0.
func Foo(a, b int) (ret int, err error) {
  if a > b {
    return a, nil
  } else {
    return b, nil
  }

  return 0, nil
}

// BUG(jack): #1: i’m sorry but this code has an issue to be solved.

// BUG(tom): #2: An issue assigned to anothoer person.

生成文档摘要

package main

import (
	"fmt"
)

type stu struct {
	Name string
	Age  int
}

func main() {

	// 声明一个map变量student,键名为string,值为stu
	var student map[string]stu

	// 给map变量创建值,同时指定最多可以存储5个stu值
	student = make(map[string]stu, 5)

	// map元素赋值
	student["stu1"] = stu{"zhao", 25}
	student["stu2"] = stu{"zhang", 28}
	student["stu3"] = stu{"sun", 32}
	student["stu4"] = stu{"li", 40}
	student["stu5"] = stu{}

	//上面方式的简写方法
	/*
	   student := map[string]stu{
	   "stu1": stu{"zhao", 25},
	   "stu2": stu{"zhang", 28},
	   "stu3": stu{"sun", 32},
	   "stu4": stu{"li", 40},
	   "stu5": stu{},
	   }
	*/

	// 打印map信息
	fmt.Printf("%vn", student)

	// 查询一个map值
	s1, ok := student["stu2"]
	if ok {
		fmt.Println("Ｆound stu2, Name:", s1.Name)
	} else {
		fmt.Println("Not Found stu2")
	}

	// 删除一个map值,如果stu2不存在，则什么也不会发生，但如果传入的map变量的值为nil的话，则会抛出一个 panic 异常
	delete(student, "stu2")

	fmt.Printf("%vn", student)

}

执行结果如下：

Go本身提供了一套轻量级的测试框架．符合规则的测试代码会在运行测试时被自动识别并执行．单元测试源文件的命名规则如平衡点：在需要测试的包下面创建以”_test”结尾的go文件,开如[^.]*_test.go

Go单元测试函数分为两在类．功能测试函数和性能测试函数，分别以Test和Benchmark为函数名前缀并以*testing.T 和 *testing.B 为单一参数的函数。

func TestAdd1(t *testing.T)
func BenchmarkAdd1(t *testing.T)

测试工具会根据函数中的实际执行动作得到不同的测试结果。

功能测试函数会根据测试代码执行过程中是否发生错误来反馈结果； 性能测试函数仅仅打印出来测试所花费时间，用来判断程序性能；

准备

新建一个文件，命名为 go_test.go

package go_test

import "testing"

func Add(a, b int) int {
    return a + b
}

功能测试

在go_test.go文件里添加以下代码

func TestAdd1(t *testing.T) {
    r := Add(1, 2)
    if r != 2 { //这里为了测试，写成2
        t.Errorf("Add(1,2) failed. Got %d, expected 3.", r)
    }
}

执行功能单元测试非常的简单，直接执行

go test

输出以下内容

--- FAIL: TestAdd1 (0.00s)
go_test.go:12: Add(1,2) failed. Got 3, expected 3.
FAIL
exit status 1
FAIL gotest 0.130s

可以看到输出具体出错的位置为第12行，控制台并打印出了用户定义的错误信息。最后的FAIL表示测试未通过，如果为 ok 的话，则为通过。我们修正问题后再次执行结果为

配置文件参数说明:

1. Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程

daemonize no

2. 当Redis以守护进程方式运行时，Redis默认会把pid写入/var/run/redis.pid文件，可以通过pidfile指定

pidfile /var/run/redis.pid

3. 指定Redis监听端口，默认端口为6379，作者在自己的一篇博文中解释了为什么选用6379作为默认端口，因为6379在手机按键上MERZ对应的号码，而MERZ取自意大利歌女Alessia Merz的名字

** port 6379**

4. 绑定的主机地址

bind 127.0.0.1

5.当 客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能

timeout 300

6. 指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为verbose

loglevel verbose

7. 日志记录方式，默认为标准输出，如果配置Redis为守护进程方式运行，而这里又配置为日志记录方式为标准输出，则日志将会发送给/dev/null

logfile stdout

8. 设置数据库的数量，默认数据库为0，可以使用SELECT 命令在连接上指定数据库id

databases 16

9. 指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合

**save **

Redis默认配置文件中提供了三个条件：

save 900 1

save 300 10

save 60 10000

分别表示900秒（15分钟）内有1个更改，300秒（5分钟）内有10个更改以及60秒内有10000个更改。

10. 指定存储至本地数据库时是否压缩数据，默认为yes，Redis采用LZF压缩，如果为了节省CPU时间，可以关闭该选项，但会导致数据库文件变的巨大

rdbcompression yes

11. 指定本地数据库文件名，默认值为dump.rdb

dbfilename dump.rdb

12. 指定本地数据库存放目录

dir ./

13. 设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步

**slaveof **

14. 当master服务设置了密码保护时，slav服务连接master的密码

**masterauth **

15. 设置Redis连接密码，如果配置了连接密码，客户端在连接Redis时需要通过AUTH 命令提供密码，默认关闭

requirepass foobared

16. 设置同一时间最大客户端连接数，默认无限制，Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数，如果设置 maxclients 0，表示不作限制。当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回max number of clients reached错误信息

maxclients 128

在使用golang开发的时候，有些时间github.com上面的包需要执行hg命令(hg命令简介).这个时候就需要安装一下才可以．

Linux下安装Mercurial(hg)：

安装Mercurial

在进行后面的操作之前需要安装Mercurial( 百科)版本管理系统（可以输出hg名词检测是否安装）。输入以下命令安装：

sudo easy_install mercurial

对于 Ubuntu/Debian 系统，easy_install 命令可以用

apt-get install python-setuptools python-dev build-essential

安装。 如果上述命令安装失败的话，还可以尝试去官方网站 下载

Windows下安装

国内国度网盘下载(32位): http://pan.baidu.com/share/link?shareid=3528053518&uk=2365864479

(64位): http://pan.baidu.com/share/link?shareid=3560201274&uk=2365864479

在windows下要用 golang 实现操作 zeromq 消息队列，发现在sublime下进行

go get -tags zmq_3_x github.com/alecthomas/gozmq

操作的时候，提示

# pkg-config –cflags libzmq libzmq libzmq libzmq exec: “pkg-config”: executable file not found in %PATH% exit status 2

原因是因为没有安装pkg-config．需要手动安装，并设置一下环境变量.pkg-config下载地址： http://ftp.acc.umu.se/pub/gnome/binaries/win32/dependencies/pkg-config_0.23-3_win32.zip ( http://ftp.acc.umu.se/pub/gnome/binaries/win64/dependencies/pkg-config_0.23-2_win64.zip)

如果无法下载，直接打开所在的目录，找到合适的软件包下载．然后将包里bin目录里的pkg-config.exe放在一个目录，在新建一个＂环境变量＂，变量名为 PKG_CONFIG_PATH ．值为pkg-config.exe所在的目录即可.

不过我这里好像还有其它的问题．提示错误,暂不知道如何解决.

# pkg-config –cflags libzmq libzmq libzmq Package libzmq was not found in the pkg-config search path. Perhaps you should add the directory containing `libzmq.pc’ to the PKG_CONFIG_PATH environment variable No package ‘libzmq’ found Package libzmq was not found in the pkg-config search path. Perhaps you should add the directory containing `libzmq.pc’ to the PKG_CONFIG_PATH environment variable No package ‘libzmq’ found Package libzmq was not found in the pkg-config search path. Perhaps you should add the directory containing `libzmq.pc’ to the PKG_CONFIG_PATH environment variable No package ‘libzmq’ found exit status 1

配置文件 conf.json

{
"Username": "sunxxg@163.com",
"Password": "123456",
"Smtphost":"smtp.163.com:25"
}

主程序 　sendmail.go

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/smtp"
	"os"
	"strings"
)

type cfgmail struct {
	Username string
	Password string
	Smtphost string
}

type cfg struct {
	Name, Text string
}

func main() {

	// 从json文件中读取发送邮件服务器配置信息
	cfgjson := getConf()

	var cfg cfgmail
	dec := json.NewDecoder(strings.NewReader(cfgjson))

	if err := dec.Decode(&cfg); err == io.EOF {
		break
	} else if err != nil {
		log.Fatal(err)
	}

	//fmt.Printf("%sn%sn%sn", cfg.Username, cfg.Password, cfg.Smtphost)

	username := cfg.Username
	password := cfg.Password
	host := cfg.Smtphost

	to := "10010@qq.com"

	fmt.Printf("============")
	fmt.Println(username)
	subject := "能否收到邮件哟？Test send email by golang"

	body := `
<html>
<body>
<h3>
"Test send email by golang，来个测试试一下"
</h3>
</body>
</html>
`
	err := SendMail(username, password, host, to, subject, body, "html")
	if err != nil {
		fmt.Println("send mail error!")
		fmt.Println(err)
	} else {
		fmt.Println("send mail success!")
	}

}

func SendMail(user, password, host, to, subject, body, mailtype string) error {
	hp := strings.Split(host, ":")
	auth := smtp.PlainAuth("", user, password, hp[0])
	var content_type string
	if mailtype == "html" {
		content_type = "Content-Type: text/" + mailtype + "; charset=UTF-8"
	} else {
		content_type = "Content-Type: text/plain" + "; charset=UTF-8"
	}

	msg := []byte("To: " + to + "rnFrom: " + user + "<" + user + ">rnSubject: " + subject + "rn" + content_type + "rnrn" + body)
	send_to := strings.Split(to, ";")
	err := smtp.SendMail(host, auth, user, send_to, msg)
	return err
}

func getConf() string {
	filename := "conf.json"
	file, err := os.Open(filename)

	defer file.Close()
	if err != nil {
		fmt.Println("read conf file error")
		log.Fatal(err)
	}

	buf := make([]byte, 512)
	var str1 string
	for {
		n, _ := file.Read(buf)
		if 0 == n {
			break
		}
		//os.Stdout.Write(buf[:n])

		str := string(buf[:n])

		str1 = str1 + str
	}
	return str1
}

然后执行

nginx的日志文件没有rotate功能。如果你不处理，日志文件将变得越来越大，还好我们可以写一个nginx日志切割脚本来自动切割日志文件。

第一步就是重命名日志文件，不用担心重命名后nginx找不到日志文件而丢失日志。在你未重新打开原名字的日志文件前，nginx还是会向你重命名的文件写日志，linux是靠文件描述符而不是文件名定位文件。

第二步向nginx主进程发送USR1信号。

nginx主进程接到信号后会从配置文件中读取日志文件名称，重新打开日志文件(以配置文件中的日志名称命名)，并以工作进程的用户作为日志文件的所有者。

重新打开日志文件后，nginx主进程会关闭重名的日志文件并通知工作进程使用新打开的日志文件。

工作进程立刻打开新的日志文件并关闭重名名的日志文件。

然后你就可以处理旧的日志文件了。

nginx日志按日期自动切割脚本如下 [shell] #nginx日志切割脚本 #author: http://www.nginx.cn #!/bin/bash #设置日志文件存放目录 logs_path="/usr/local/nginx/logs/" #设置pid文件 pid_path="/usr/local/nginx/nginx.pid" #重命名日志文件 mv ${logs_path}access.log ${logs_path}access_$(date -d “yesterday” +"%Y%m%d").log #向nginx主进程发信号重新打开日志 kill -USR1 `cat ${pid_path}`[/shell] 保存以上脚本nginx_log.sh,或者点此下载

crontab 设置作业

[shell]0 0 * * * bash /usr/local/nginx/nginx_log.sh[/shell] 这样就每天的0点0分把nginx日志重命名为日期格式，并重新生成今天的新日志文件。

作/译者：叶金荣（imysql#imysql.com>），来源： http://imysql.com，欢迎转载。

起因：在innodb表上做count(*)统计实在是太慢了，因此想办法看能不能再快点。

现象：先来看几个测试案例，如下

一、 sbtest 表上的测试

show create table sbtest\G
*************************** 1. row ***************************
Table: sbtest
Create Table: CREATE TABLE `sbtest` (
`aid` bigint(20) unsigned NOT NULL auto_increment,
`id` int(10) unsigned NOT NULL default '0',
`k` int(10) unsigned NOT NULL default '0',
`c` char(120) NOT NULL default '',
`pad` char(60) NOT NULL default '',
PRIMARY KEY  (`aid`),
KEY `k` (`k`),
KEY `id` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1000001 DEFAULT CHARSET=latin1

show index from sbtest;
+--------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+
| Table  | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment |
+--------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+
| sbtest |          0 | PRIMARY  |            1 | aid         | A         |     1000099 |     NULL | NULL   |      | BTREE      |         |
| sbtest |          1 | k        |            1 | k           | A         |          18 |     NULL | NULL   |      | BTREE      |         |
| sbtest |          1 | id       |            1 | id          | A         |     1000099 |     NULL | NULL   |      | BTREE      |         |
+--------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+

填充了 100万条 记录。

https://github.com/laruence/php-yaf

yaf框架中文手册：

yaf手册：

1.下载并安装yaf扩展 http://pecl.php.net/package/yaf

#wget http://pecl.php.net/get/yaf-2.2.9.tgz
#tar zxvf yaf-2.2.9.tgz
#cd yaf-2.2.9

[root@bogon yaf-2.2.9]# whereis phpize
phpize: /usr/bin/phpize /usr/share/man/man1/phpize.1.gz
/usr/bin/phpize

[root@bogon yaf-2.2.9]# /usr/bin/phpize
Configuring for:
PHP Api Version: 20090626
Zend Module Api No: 20090626
Zend Extension Api No: 220090626
#whereis php-config
php-config: /usr/bin/php-config /usr/share/man/man1/php-config.1.gz

#./configure --with-php-config=/usr/bin/php-config
#make && make install

2.添加扩展配置到php.ini

在/etc/php.ini文件里添加一行

extension=yaf.so

重启webserver　即可.

=========================== 如果在./configure的时候遇到以下错误：

configure: error: in `/root/yaf-2.2.9′:configure: error: no acceptable C compiler found in $PATHSee `config.log’ for more details.

通过网卡属性查看

命令：ifconfig

注释：有 “inet6 addr：。。。。。。。“ 的表示开启了ipv6功能.使用下面的方法可以关闭ipv6

1.修改/etc/modprobe.d/dist.conf

[shell]#vi /etc/modprobe.d/dist.conf[/shell]

添加下面两行内容

alias net-pf-10 off alias ipv6 off

保存退出，并且重新启动系统

2.验证ipv6模块是否加载

[shell]#lsmod|grep ipv6[/shell]

4.开机不启动

[shell]#chkconfig ip6tables off[/shell]

重启 用命令“lsmod | grep v6”查看，是否启动加载！

=======================================

1.修改/etc/sysconfig/network，追加：

NETWORKING_IPV6=no

2.修改/etc/hosts文件，把ipv6的那句本地主机名解析的也注释掉：

#::1   localhost localhost6 localhost6.localdomain6

IPv6是默认支持的，所以当你要重新开起IPv6支持时，将/etc/modprobe.d/dist.conf中的两条指令注释掉就可以了。

更多参考：

“并发 (concurrency)” 和 “并行 ( parallelism)” 是不同的。在单个 CPU 核上，线程通过时间片或者让出控制权来实现任务切换，达到 “同时” 运行多个任务的⺫的，这就是所谓的并发。但实际上任何时刻都只有一个任务被执行，其他任务通过某种算法来排队。

多核 CPU 可以让同个进程内的 “多个线程” 做到真正意义上的同时运，它们之间不需要排队 (依然会发生排队，因为线程数量可能超出 CPU 核数量，还有其他的进程等等。这里说的是一个理想状况)，这才是并行。除了多核，并行计算还可能是多台机器上部署运行。

package main

import (
"fmt"
"runtime"
)

func test(c chan bool, n int) {

x := 0
for i := 0; i < 1000000000; i++ {
x += i
}

println(n, x)

if n == 9 {
c <- true
}
}

func main() {
runtime.GOMAXPROCS(1) //设置cpu的核的数量，从而实现高并发
c := make(chan bool)

for i := 0; i < 10; i++ {
　go test(c, i)
}

<-c

fmt.Println("main ok")

}

测试结果如下：

**注意slice和数组在声明时的区别：**声明数组时，方括号内写明了数组的长度或使用...自动计算长度，而声明slice时，方括号内没有任何字符。

arr1 := [10]int{1,2,3,4} //数组,长度为10,只有4个元素指定,其它的元素值默认为0
arr2 := [...]string{"a","b","c"} //数组,长度自适应,这里长度为3
s1 := []int{1,2,3,4} //slice,目前长度为4,可能通过append来动态添加元素个数

示例:

package main

import (
 "fmt"
)

func main() {

//array example
 arr := [10]int{1, 2, 3} //array 指定前三个值,其它值使用默认类型值0
 fmt.Println(len(arr))
 fmt.Println(arr)
 //a1 := append(arr, 4, 5) //数组不支持append,只有slice才支持append
 //fmt.Println(a1)

//slice example
 slice := []string{"a", "b", "c"} // slice
 s1 := append(slice, "d")
 fmt.Println(s1)

slice2 := []string{"x", "y", "x"}
 len1 := len(slice2)
 cap1 := cap(slice2)
 fmt.Println(slice2) // [x y x]
 fmt.Println("len:", len1, "cap:", cap1) //len: 3 cap: 3

s2 := append(slice, slice2...)
 len2 := len(slice2)
 cap2 := cap(s2)
 fmt.Println(s2) //[a b c x y x]
 fmt.Println("len:", len2, "cap:", cap2) //len: 3 cap: 6

}

===========================================