package main

import (
  "fmt"
  "log"
  "os"
)

func main(){
  logfile,err := os.OpenFile("d:/workspace/golang/test.log",os.O\_RDWR|os.O\_CREATE|os.O_APPEND,0);
  if err!=nil {
    fmt.Printf("%s\r\n",err.Error());
    os.Exit(-1);
  }
  defer logfile.Close();
  
  logger := log.New(logfile,"\r\n",log.Ldate|log.Ltime|log.Llongfile);
  logger.Println("hello");
  logger.Println("oh….");
  logger.Fatal("test");
  logger.Fatal("test2");
}

这里打开日志文件的时候,同时使用了””os.O_APPEND”这个,这样的话,日志会一直在文件最后面打印出来.

在登录Linux时要执行文件的过程如下： 在刚登录Linux时，首先启动 /etc/profile 文件，然后再启动用户目录下的 ~/.bash_profile、 ~/.bash_login或 ~/.profile文件中的其中一个，

执行的顺序为：~/.bash_profile、 ~/.bash_login、 ~/.profile。

如果 ~/.bash_profile文件存在的话，一般还会执行 ~/.bashrc文件。

因为在 ~/.bash_profile文件中一般会有下面的代码：

if [ -f ~/.bashrc ] ; then
. ./bashrc
fi

~/.bashrc中，一般还会有以下代码：

if [ -f /etc/bashrc ] ; then
. /etc/bashrc
fi

所以，~/.bashrc会调用 /etc/bashrc文件。最后，在退出shell时，还会执行 ~/.bash_logout文件。

执行顺序为： /etc/profile -> (~/.bash_profile | ~/.bash_login | ~/.profile) -> ~/.bashrc -> /etc/bashrc -> ~/.bash_logout

关于各个文件的作用域，在网上找到了以下说明：

（1） /etc/profile： 此文件为系统的每个用户设置环境信息,当用户第一次登录时,该文件被执行. 并从/etc/profile.d目录的配置文件中搜集shell的设置。

（2） /etc/bashrc: 为每一个运行bash shell的用户执行此文件.当bash shell被打开时,该文件被读取（即每次新开一个终端，都会执行bashrc）。

（3） ~/.bash_profile: 每个用户都可使用该文件输入专用于自己使用的shell信息,当用户登录时,该文件仅仅执行一次。默认情况下,设置一些环境变量,执行用户的.bashrc文件。

（4） ~/.bashrc: 该文件包含专用于你的bash shell的bash信息,当登录时以及每次打开新的shell时,该该文件被读取。

（5） ~/.bash_logout: 当每次退出系统(退出bash shell)时,执行该文件. 另外,/etc/profile中设定的变量(全局)的可以作用于任何用户,而~/.bashrc等中设定的变量(局部)只能继承 /etc/profile中的变量,他们是”父子”关系。

如果你是一名使用过多种框架的php程序员，你一定见过这样的查询语句：

$result = $mysqlDb->limit(’0,10′)->order(‘id desc’)->findall();

上面的查询语句，连续使用->操作符进行操作，并最终返回一个查询结果，那么这是如何实现的呢。

我们来简单分析一下：

->操作符用来访问对象，上面的语句一共使用了3次->操作符，而最后一次返回的是查询结果，这说明，前2次->访问后，返回的应该是一个对象，因为在php中，如果你对一个非对象使用->操作符是不可能的。这告诉我们，$mysql实例中的limit和order方法都返回一个对其所在类自身的引用即 return $this，了解了这一点，那么我们就可以实现连贯查询了。请看站长写的示例代码：

/*
 *类功能：实现数据库的连贯查询操作
 */
 class mysql_query{
 var $tbl=’user’;//要操作的表名
 var $limit=”;//存储limit语句的变量
 var $order=”;//存储order语句的变量
 var $sql=”;//存储完整sql语句的变量

function limit($str) {
 $this->limit=’limit ‘.$str;//设置limit语句
 //返回对类自身的引用，这里不能使用return new mysql_qery()，
 //因为这样相当于又创建了类的一个新实例，那么上一步设置的limit语句，在新实例中是不存在的
 //大家可以自己实验
 //因此要返回$this，即当前类的实例
 return $this;
}

function order($str) {
 $this->order=’order by ‘.$str;//设置order语句
 return $this;//返回对类自身的引用
}

function findall() {
 $this->sql=’select * from ‘.$this->tbl.’ ‘.$this->order.’ ‘.$this->limit;//拼接sql语句
 echo $this->sql;//输出，由于是示例，所以没有写查询数据库的代码
}

 }

//Example
$mysqlDb=new mysql_query();
$result = $mysqlDb->limit(’0,10′)->order(‘id desc’)->findall();
print_r($result);

============================================================ 另外也有框架是使用 __call() 这个魔术方法来实现的.

class Test {

protected $options = array();

//这里就是了, 通过判断调用的函数名, 如果存在, 那么设置参数, 返回自己
public function __call($func, $args) {
if (in_array($func, array('form', 'field', 'join', 'order', 'where', 'limit', '更多....'))) {
$this->options[$func] = $args;
return $this; //这里返回了本对象
}
}

}

//Example
$test = new Test();
$test->form('test'); // 这样调用就相当于设置 $test->options['form'] = 'test';

//在ThinkPHP中这种连贯操作都是以find或者findAll结尾的. //所以前面这些方法的调用只是在设置查询的参数而已 //在find或者findAll方法中, 是根据$this->options参数的不同执行不同的SQL //比如这样

在编写 golang 程序的过程中，channel 会经常使用。本文对 channel 的使用的确很特别，同时也非常实用。

原文在此： http://dave.cheney.net/2013/04/30/curious-channels

在编写 golang 程序的过程中，channel 会经常使用。本文对 channel 的使用的确很特别，同时也非常实用。

原文在此：http://dave.cheney.net/2013/04/30/curious-channels

翻译:http://mikespook.com/2013/05/%E7%BF%BB%E8%AF%91%E7%BB%9D%E5%A6%99%E7%9A%84-channel/#more-1635

Go in Vim

The standard Go distribution includes a Go syntax file for Vim in go/misc/vim/.

Installation Instructions

Place $GOROOT/misc/vim/syntax/go.vim in ~/.vim/syntax/ and put the following in ~/.vim/ftdetect/go.vim:

在go的安装目录里有/misc/vim/syntax 他 /misc/vim/ftdetect 两个目录，将里面的文件复制到~/.vim/相应的目录里即可。

au BufRead,BufNewFile *.go set filetype=go

Extras and Alternative Files

An alternative indent file for Vim by Alecs King can be found here.

Autocompletion

The gocode daemon by nsf includes a vim script to do autocompletion.

Other

See the vim-golang repo in Github for alternative syntax highlight, auto-indentation, gofmt and other useful scripts and plugins.

Publish-subscribe Pattern：发布订阅模式。

现实中，并不是所有请求都期待答复，而不期待答复，自然就没有了状态。所以相对于REQ-REP，PUB-SUB模式容易理解也简单得多。广播听过吧?收音机用过吧?就这个意思。

相应地，该模式下的socket也就两种：ZMQ_PUB & ZMQ_SUB。 分别对应电台和收音机。

ZMQ_PUB

ZMQ_PUB主要用来让消息发布者用来散发消息的。所有连接上的peer都能收到由它散发的消息。 zmq_recv(3) 这个API是不能用在这个socket上的，原因显而易见。而zmq_send作用在该socket上时是永远不会阻塞的，如果订阅者异常，发出的消息则会被丢弃。

Summary of ZMQ_PUB characteristics

Compatible peer sockets ZMQ_SUB Direction

Unidirectional

Send/receive pattern

Send only

Incoming routing strategy

N/A

Outgoing routing strategy

Fan out

ZMQ_HWM option action

Drop

ZMQ_SUB

很明显，订阅者通过这个socket来接受发布者发布的消息。需要注意的是，在使用该socket时，必须显式地调用 `` zmq_setsockopt ，设置ZMQ_SUBSCRIBE和filter。如果不设置的话，是收不到任何消息的。

Summary of ZMQ_SUB characteristics

Compatible peer sockets ZMQ_PUB Direction

Unidirectional

Send/receive pattern

Receive only

Incoming routing strategy

Fair-queued

Outgoing routing strategy

N/A

ZMQ_HWM option action

Drop

总结

PUB-SUB模式一般处理的都不是系统的关键数据。发布者不关注订阅者是否收到发布的消息，订阅者也不知道自己是否收到了发布者发出的所有消息。你也不知道订阅者何时开始收到消息。因此逻辑上，它都不是可靠的。

通过对 Guide 的阅读，可以发现ZeroMQ对这个世界中消息传输的模式进行了很好的抽象。为了描述模式，0mq定义了不同的socket。 0mq socket是0mq世界的东西，跟传统世界的socket是不一样的。

我们知道，传统的socket其实就是访问下面两种(TCP & UDP)对象的同步的接口：

1. 面向连接的可靠字节流(SOCK_STREAM)
2. 无连接的不可靠的数据报文(SOCK_DGRAM)

所以你可以说传统socket传输的是字节流或者独立的报文。

而0mq的socket传输的是消息(Message)。它是对异步_消息_队列(MQ)的一种抽象。官方的原话是：

ØMQ sockets present an abstraction of an asynchronous message queue, with the exact queueing semantics depending on the socket type in use.

异步的意思在这里指的是物理连接的创建、销毁、重连、传输对于用户来说都是透明的，这些东西都由0mq组织好了。它传输的是独立的**消息**。_队列_隐含的意思是万一消息无法到达对端则可能会被排队。

除了传统socket实现的一对一、多对一以及一对多(广播）外，0mq的socket还可以用zmq_connect()发起连接到多个对端，并同时接受从多个用zmq_bind()绑定了0mq-socket的对端发起的链接，从而实现多对多。

0mq归纳的模式有四种：

1. Request-reply Pattern
2. Publish-subscribe Pattern
3. Pipeline Pattern
4. Exclusive pair Pattern

我想搞懂了这些模式，可能也就理解了zeromq的精髓和用法。只有这样才能灵活地、根据场景使用不同的模式，利用zeromq快速搭建网络拓扑。

转自： http://www.kongch.com/2012/01/zeromq-patterns/

参考：

http://www.cnblogs.com/dirlt/archive/2011/09/27/2192462.html http://robinqu.me/blog/2013/07/24/zmq-learning-notes-part-1/

http://blogs.ejb.cc/archives/5556/zeromq-via-c-sharp-a-communication-pattern

我们先来看看第一种模式:Request-Reply Pattern。 请求应答模式。

Request-Reply这个名字很直白，口语点说就是一问一答。可以使同步的遵循请求序的一问一答，也可以是异步的不按请求序的一问一答；其中也可以包含各种不同的路由策略——让谁来回答。zeromq定义的为这个模式服务的socket有：ZMQ_REQ, ZMQ_REP, ZMQ_ROUTER以及ZMQ_DEALER. 用他们进行合理的组合，就可以实现现实世界中各种不同的请求应答模式。

分别来看：

ZMQ_REQ

ZMQ_REQ做的事情就是发问，然后收答。发、收必须是严格按序进行。请求时对对端进行Round Robin，遇到异常则阻塞。官方对这个socket的总结如下：

Summary of ZMQ_REQ characteristics

Compatible peer sockets ZMQ_REP Direction

Bidirectional

Send/receive pattern

Send, Receive, Send, Receive, …

Outgoing routing strategy

Round-robin

Incoming routing strategy

Last peer

ZMQ_HWM option action

Block

ZMQ_REP

ZMQ_REP做的事情是收问题然后回答。收、发严格按序调用。对收到的问题公平排队,逐一作答。回答发出时遇到异常则直接丢弃，不会阻塞。

Summary of ZMQ_REP characteristics

Compatible peer sockets ZMQ_REQ Direction

Bidirectional

Send/receive pattern

Receive, Send, Receive, Send, …

Incoming routing strategy

Fair-queued

Outgoing routing strategy

Last peer

ZMQ_HWM option action

Pipeline pattern 管道模式。

这种模式描述的场景是数据被散布到以管道方式组织的各个节点上。管道的每一步都连接一个或多个节点，连接多个节点时数据以RR方式往下流。

注意是流，意味着数据跟发布模式一样是单向的。这个模式对应的socket是ZMQ_PUSH和ZMQ_PULL.

ZMQ_PUSH

用来向下游节点发消息。下游多个节点时采取RoundRobin分发，_zmq_recv()_对于这个socket也是无效的。

与Pub不同的是,当下游节点达到高水位(HWM)或者根本没有下游节点时，_zmq_send()_就阻塞了，消息并不丢失。

Summary of ZMQ_PUSH characteristics

Compatible peer sockets ZMQ_PULL Direction

Unidirectional

Send/receive pattern

Send only

Incoming routing strategy

N/A

Outgoing routing strategy

Round-robin

ZMQ_HWM option action

Block

ZMQ_PULL

下游节点在这个socket上进行_zmq_recv()_，来收取上游发来的消息。_zmq_send()_在此socket上是没有意义的。

Summary of ZMQ_PULL characteristics

Compatible peer sockets ZMQ_PUSH Direction

Unidirectional

Send/receive pattern

Receive only

Incoming routing strategy

Fair-queued

Outgoing routing strategy

N/A

ZMQ_HWM option action

N/A

总结

流行的map-reduce可以说就是这样的模式。数据从头开始，map到许多节点进行计算，计算结果最终reduce到一处。单向，没有回头。

事实上，这种模式也多见于并行计算、分布式计算这些场景中。

这个模式跟pub-sub一样容易理解，因此也没必要再赘述了。

转自： http://www.kongch.com/2012/01/zeromq-pattern-pipeline/

实现功能：用go实现消息队列的写入与读取(打算用在发送邮件服务)

环境工具： Centos 64X 6.4 zeromq 3.2.4： zeromq.org golang： http://golang.org/

一．安装golang( http://golang.org/doc/install) 这一步很简单，只需要从 http://code.google.com/p/go/downloads 下载到服务器，解压到/usr/local/go目录，再设置一下系统变量就可以了．

wget https://go.googlecode.com/files/go1.1.2.linux-amd64.tar.gz
tar -C /usr/local -xzf go1.1.2.linux-amd64.tar.gz

设置系统变量GOROOT

Add /usr/local/go/bin to the PATH environment variable. You can do this by adding this line to your /etc/profile (for a system-wide installation) or $HOME/.profile:

export PATH=$PATH:/usr/local/go/bin

执行命令 #source /etc/profile 使环境变量生效．

设置项目环境变量GOPATH

下面我们需要设置开发项目使用的环境变量GOPATH的路径．可直接在命令行下执行下面的命令，也可以将下面的命令写入/etc/profile(或者 $HOME/.profile)中，这样下次使用的时候变量不会丢失．参考：

$ mkdir $HOME/go For convenience, add the workspace’s bin subdirectory to your PATH:

$ export GOPATH=$HOME/go
$ export PATH=$PATH:$GOPATH/bin

也可以将上面两条命令写到/etc/profile里，然后再执行 #source /etc/profile 命令，使环境变量生效．

Git Community Book 中文版

Git 是一个很强大的分布式版本管理工具，它不但适用于管理大型开源软件的源代码（如： linux kernel），管理私人的文档和源代码也有很多优势（如： wsi-lgame-pro）

Git 的更多介绍，请参考我的上一篇博客： Git 版本管理工具

一、 Git 命令初识

在正式介绍Git命令之前，先介绍一下Git 的基本命令和操作，对Git命令有一个总体的认识

示例：从Git 版本库的初始化，通常有两种方式：

1）git clone：这是一种较为简单的初始化方式，当你已经有一个远程的Git版本库，只需要在本地克隆一份

例如：git  clone  git://github.com/someone/some_project.git   some_project

上面的命令就是将’git://github.com/someone/some_project.git’这个URL地址的远程版本库，完全克隆到本地some_project目录下

2）git init 和 git remote：这种方式稍微复杂一些，当你本地创建了一个工作目录，你可以进入这个目录，使用’git init’命令进行初始化；Git以后就会对该目录下的文件进行版本控制，这时候如果你需要将它放到远程服务器上，可以在远程服务器上创建一个目录，并把可访问的URL记录下来，此时你就可以利用’git remote add’命令来增加一个远程服务器端，

例如：git  remote  add  origin  git://github.com/someone/another_project.git

上面的命令就会增加URL地址为’git: //github.com/someone/another_project.git’，名称为origin的远程服务器，以后提交代码的时候只需要使用 origin别名即可

二、 Git 常用命令

1. 远程仓库相关命令

检出仓库：        $ git clone git://github.com/jquery/jquery.git

查看远程仓库：$ git remote -v

添加远程仓库：$ git remote add [name] [url]

删除远程仓库：$ git remote rm [name]

修改远程仓库：$ git remote set-url –push [name] [newUrl]

一、获取锁等待情况

可以通过检查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
[email protected].

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)

}

执行结果如下：