maxima复制代码package main
func tree() {
  ctx1 := context.Background()
  ctx2, _ := context.WithCancel(ctx1)
  ctx3, _ := context.WithTimeout(ctx2, time.Second * 5)
  ctx4, _ := context.WithTimeout(ctx3, time.Second * 3)
  ctx5, _ := context.WithTimeout(ctx3, time.Second * 6)
  ctx6 := context.WithValue(ctx5, "userID", 12)
}

reasonml复制代码type Context interface {
  //  啥时候退出
  Deadline() (deadline time.Time, ok bool)
  Done() <-chan struct{}
  Err() error
  //  设置变量
  Value(key interface{}) interface{}
}

livecodeserver复制代码ctx, cancel := context.WithTimeout(parentCtx, time.Second * 2)
defer cancel()

elm复制代码type Group struct {
	cancel  func()
	wg      sync.WaitGroup
	errOnce sync.Once
	err     error
}

autoit复制代码func WithContext(ctx context.Context) (*Group, context.Context) {
  ctx, cancel := context.WithCancel(ctx)
  return &Group{cancel: cancel}, ctx
}

go复制代码func (g *Group) Go(f func() error) {
  g.wg.Add(1)
  go func() {
    defer g.wg.Done()
    if err := f(); err != nil {
      g.errOnce.Do(func() {
        g.err = err
        if g.cancel != nil {
          g.cancel()
        }
      })
    }
  }()
}

stylus复制代码func (g *Group) Wait() error {
  g.wg.Wait()
  if g.cancel != nil {
    g.cancel()
  }
  return g.err
}

go复制代码package main
func DoTwoRequestsAtOnce(ctx context.Context) error {
  eg, egCtx := errgroup.WithContext(ctx)
  var resp1, resp2 *http.Response
  f := func(loc string, respIn **http.Response) func() error {
    return func() error {
      reqCtx, cancel := context.WithTimeout(egCtx, time.Second)
      defer cancel()
      req, _ := http.NewRequest("GET", loc, nil)
      var err error
      *resp, err = http.DefaultClient.Do(req.WithContext(reqCtx))
      if err == nil && (*respIn).StatusCode >= 500 {
        return errors.New("unexpected!")
      }
      return err
    }
  }
  eg.Go(f("http://localhost:8080/fast_request", &resp1))
  eg.Go(f("http://localhost:8080/slow_request", &resp2))
  return eg.Wait()
}

fsharp复制代码package context
type valueCtx struct {
  Context
  key, val interface{}
}
func WithValue(parent Context, key, val interface{}) Context {
  //  ...
  return &valueCtx{parent, key, val}
}
func (c *valueCtx) Value(key interface{}) interface{} {
  if c.key == key {
    return c.val
  }
  return c.Context.Value(key)
}

go复制代码type privateCtxType string
var (
  reqID = privateCtxType("req-id")
)
func GetRequestID(ctx context.Context) (int, bool) {
  id, exists := ctx.Value(reqID).(int)
  return id, exists
}
func WithRequestID(ctx context.Context, reqid int) context.Context {
  return context.WithValue(ctx, reqID, reqid)
}

reasonml复制代码func Add(ctx context.Context) int {
  return ctx.Value("first").(int) + ctx.Value("second").(int)
}

go复制代码func IsAdminUser(ctx context.Context) bool {
  userID := GetUser(ctx)
  return authSingleton.IsAdmin(userID)
}

reasonml复制代码func IsAdminUser(ctx context.Context, userID string, authenticator auth.Service) bool

go复制代码package main
func trace(req *http.Request, c *http.Client) {
  trace := &httptrace.ClientTrace{
    GotConn: func(connInfo httptrace.GotConnInfo) {
      fmt.Println("Got Conn")
    },
    ConnectStart: func(network, addr string) {
      fmt.Println("Dial Start")
    },
    ConnectDone: func(network, addr string, err error) {
      fmt.Println("Dial done")
    },
  }
  req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace))
  c.Do(req)
}

go复制代码package http
func (req *Request) write(w io.Writer, usingProxy bool, extraHeaders Header, waitForContinue func() bool) (err error) {
  //  ...
  trace := httptrace.ContextClientTrace(req.Context())
  //  ...
  if trace != nil && trace.WroteHeaders != nil {
    trace.WroteHeaders()
  }
}

go复制代码package main
import "github.com/golang/oauth2"
func oauth() {
  c := &http.Client{Transport: &mockTransport{}}
  ctx := context.WithValue(context.Background(), oauth2.HTTPClient, c)
  conf := &oauth2.Config{ /* ... */ }
  conf.Exchange(ctx, "code")
}

复制代码192.168.116.115 rocketmq1
192.168.116.116 rocketmq2

复制代码git clone -b develop https://github.com/apache/rocketmq.git
cd rocketmq
mvn -Prelease-all -DskipTests clean install -U
cd distribution/target/apache-rocketmq

本版本是基于4.1.0的，之后apache-rocketmq_4.1.0.tar.gz拷贝集群所有机器进行解压
tar -zxvf apache-rocketmq_4.1.0.tar.gz

复制代码#所属集群名字
brokerClusterName=rocketmq-cluster
#broker名字，注意此处不同的配置文件填写的不一样
brokerName=broker-a
#0 表示 Master，>0 表示 Slave
brokerId=0
#nameServer地址，分号分割
namesrvAddr=rocketmq1:9876;rocketmq2:9876
#在发送消息时，自动创建服务器不存在的topic，默认创建的队列数
defaultTopicQueueNums=4
#是否允许 Broker 自动创建Topic，建议线下开启，线上关闭
autoCreateTopicEnable=true
#是否允许 Broker 自动创建订阅组，建议线下开启，线上关闭
autoCreateSubscriptionGroup=true
#Broker 对外服务的监听端口
listenPort=10911
#删除文件时间点，默认凌晨 4点
deleteWhen=04
#文件保留时间，默认 72 小时
fileReservedTime=120
#commitLog每个文件的大小默认1G
mapedFileSizeCommitLog=1073741824
#ConsumeQueue每个文件默认存30W条，根据业务情况调整
mapedFileSizeConsumeQueue=300000
#destroyMapedFileIntervalForcibly=120000
#redeleteHangedFileInterval=120000
#检测物理文件磁盘空间
diskMaxUsedSpaceRatio=75
#存储路径
storePathRootDir=/appl/rocketmq/store
#commitLog 存储路径
storePathCommitLog=/appl/rocketmq/store/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/appl/rocketmq/store/consumequeue
#消息索引存储路径
storePathIndex=/appl/rocketmq/store/index
#checkpoint 文件存储路径
storeCheckpoint=/appl/rocketmq/store/checkpoint
#abort 文件存储路径
abortFile=/appl/rocketmq/store/abort
#限制的消息大小 默认4M
#maxMessageSize=4194304

#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000
#Broker 的角色
#- ASYNC_MASTER 异步复制Master
#- SYNC_MASTER 同步双写Master
#- SLAVE
brokerRole=ASYNC_MASTER

#刷盘方式
#- ASYNC_FLUSH 异步刷盘
#- SYNC_FLUSH 同步刷盘
flushDiskType=ASYNC_FLUSH

复制代码#所属集群名字
brokerClusterName=rocketmq-cluster
#broker名字，注意此处不同的配置文件填写的不一样
brokerName=broker-b
#0 表示 Master，>0 表示 Slave
brokerId=1
#nameServer地址，分号分割
namesrvAddr=rocketmq1:9876;rocketmq2:9876
#在发送消息时，自动创建服务器不存在的topic，默认创建的队列数
defaultTopicQueueNums=4
#是否允许 Broker 自动创建Topic，建议线下开启，线上关闭
autoCreateTopicEnable=true
#是否允许 Broker 自动创建订阅组，建议线下开启，线上关闭
autoCreateSubscriptionGroup=true
#Broker 对外服务的监听端口
listenPort=11911
#删除文件时间点，默认凌晨 4点
deleteWhen=04
#文件保留时间，默认 72 小时
fileReservedTime=120
#commitLog每个文件的大小默认1G
mapedFileSizeCommitLog=1073741824
#ConsumeQueue每个文件默认存30W条，根据业务情况调整
mapedFileSizeConsumeQueue=300000
#destroyMapedFileIntervalForcibly=120000
#redeleteHangedFileInterval=120000
#检测物理文件磁盘空间
diskMaxUsedSpaceRatio=75
#存储路径
storePathRootDir=/appl/rocketmq-s/store
#commitLog 存储路径
storePathCommitLog=/appl/rocketmq-s/store/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/appl/rocketmq-s/store/consumequeue
#消息索引存储路径
storePathIndex=/appl/rocketmq-s/store/index
#checkpoint 文件存储路径
storeCheckpoint=/appl/rocketmq-s/store/checkpoint
#abort 文件存储路径
abortFile=/appl/rocketmq-s/store/abort
#限制的消息大小 默认4M
#maxMessageSize=4194304

#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000
#Broker 的角色
#- ASYNC_MASTER 异步复制Master
#- SYNC_MASTER 同步双写Master
#- SLAVE
brokerRole=SLAVE

#刷盘方式
#- ASYNC_FLUSH 异步刷盘
#- SYNC_FLUSH 同步刷盘
flushDiskType=ASYNC_FLUSH

复制代码sed -i 's#${user.home}#/appl/rocketmq#g' *.xml

# sed -i 's#${user.home}#/appl/rocketmq-s#g' *.xml 由于一台机器部署了2个结点

复制代码-server -Xms4g -Xmx4g -Xmn2g -XX:PermSize=128m -XX:MaxPermSize=320m

复制代码-Xms1G -Xmx1G -Xmn512m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=320m

复制代码sed -i 's#PermSize#MetaspaceSize#g' *
sed -i 's#MaxPermSize#MaxMetaspaceSize#g' *

复制代码-Xms8g -Xmx8g -Xmn4g

复制代码JAVA_OPT="${JAVA_OPT} -server -Xms1g -Xmx1g -Xmn512m"
JAVA_OPT="${JAVA_OPT} -XX:+UseG1GC -XX:G1HeapRegionSize=16m 
-XX:G1ReservePercent=25 -XX:InitiatingHeapOccupancyPercent=30
-XX:SoftRefLRUPolicyMSPerMB=0 -XX:SurvivorRatio=8 -XX:+DisableExplicitGC"
JAVA_OPT="${JAVA_OPT} -verbose:gc -Xloggc:/dev/shm/mq_gc_%p.log 
-XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCApplicationStoppedTime 
-XX:+PrintAdaptiveSizePolicy"
JAVA_OPT="${JAVA_OPT} -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=5 
-XX:GCLogFileSize=30m"
JAVA_OPT="${JAVA_OPT} -XX:-OmitStackTraceInFastThrow"
JAVA_OPT="${JAVA_OPT} -XX:+AlwaysPreTouch"
JAVA_OPT="${JAVA_OPT} -XX:MaxDirectMemorySize=15g"
JAVA_OPT="${JAVA_OPT} -XX:-UseLargePages -XX:-UseBiasedLocking"
JAVA_OPT="${JAVA_OPT} -Djava.ext.dirs=${BASE_DIR}/lib"
JAVA_OPT="${JAVA_OPT} ${JAVA_OPT_EXT}"
JAVA_OPT="${JAVA_OPT} -cp ${CLASSPATH}"

复制代码 nohup sh /appl/apache-rocketmq/bin/mqnamesrv &
tail -f /appl/rocketmq-s/logs/rocketmqlogs/namesrv.log
#tail -f /appl/rocketmq/logs/rocketmqlogs/namesrv.log
INFO main - The Name Server boot success. serializeType=JSON

复制代码rocketmq1机器:
nohup sh /appl/apache-rocketmq/bin/mqbroker -c /appl/apache-rocketmq/conf/2m-2s-async/broker-a.properties >/dev/null 2>&1 &

nohup sh /appl/apache-rocketmq-s/bin/mqbroker -c /appl/apache-rocketmq-s/conf/2m-2s-async/broker-b-s.properties >/dev/null 2>&1 &  

rocketmq2机器:
nohup sh /appl/apache-rocketmq/bin/mqbroker -c /appl/apache-rocketmq/conf/2m-2s-async/broker-b.properties >/dev/null 2>&1 &

nohup sh /appl/apache-rocketmq-s/bin/mqbroker -c /appl/apache-rocketmq-s/conf/2m-2s-async/broker-a-s.properties >/dev/null 2>&1 &   



tail -f /appl/rocketmq/logs/rocketmqlogs/broker.log 
……
INFO main - The broker[broker-a, 192.168.116.116:10911] boot success. serializeType=JSON and name server is rocketmq1:9876;rocketmq2:9876
……

tail -f /appl/rocketmq/logs/rocketmqlogs/namesrv.log
……
new broker registerd, 192.168.116.116:11911 HAServer: 192.168.116.116:11912
……
new broker registerd, 192.168.116.115:11911 HAServer: 192.168.116.115:11912
……

复制代码sh bin/mqshutdown broker
sh bin/mqshutdown namesrv

复制代码git clone https://github.com/brendangregg/FlameGraph

复制代码c()
{
    for(int i=0;i<1000;i++);
}
b()
{
    for(int i=0;i<1000;i++);
    c();
}
a()
{
    for(int i=0;i<1000;i++);
    b();
}

复制代码/*
 * One example to demo flamegraph
 *
 * Copyright (c) Barry Song
 *
 * Licensed under GPLv2
 */

#include <pthread.h>

func_d()
{
    int i;
    for(i=0;i<50000;i++);
}

func_a()
{
    int i;
    for(i=0;i<100000;i++);
    func_d();
}

func_b()
{
    int i;
    for(i=0;i<200000;i++);
}

func_c()
{
    int i;
    for(i=0;i<300000;i++);
}

void* thread_fun(void* param)
{
    while(1) {
        int i;
        for(i=0;i<100000;i++);

        func_a();
        func_b();
        func_c();
    }
}

int main(void)
{
    pthread_t tid1,tid2;
    int ret;

    ret=pthread_create(&tid1,NULL,thread_fun,NULL);
    if(ret==-1){
        ...
    }

    ret=pthread_create(&tid2,NULL,thread_fun,NULL);
    ...

    if(pthread_join(tid1,NULL)!=0){
        ...
    }

    if(pthread_join(tid2,NULL)!=0){
        ...
    }

    return 0;
}

复制代码$gcc exam.c -pthread
$./a.out&
$sudo perf top

复制代码perf record -F 99 -a -g -- sleep 60
perf script | ./stackcollapse-perf.pl > out.perf-folded
./flamegraph.pl out.perf-folded > perf-kernel.svg

复制代码$ pip install git+https://github.com/hylang/hy.git
# 注意 这里不要直接 pip install hy 这样从pypi直接安装，有坑...我已经踩过了

复制代码(import [matplotlib [pyplot :as plt]])
(import time)
(.xkcd plt)
(def (, fig, ax) (.subplots plt))
(defn draw-circle [r0 r-max r-step]
  (setv r r0)
  (if (< r r-max) (do (-> (.Circle plt (, 0.5 0.5) r :color "black" :fill False) (ax.add-artist))
      (setv r (+ r r-step))
      (draw-circle r r-max r-step))))
(draw-circle 0.2 1 0.02)
(.text plt 0.5 0.5 (.upper "happy hack with hy!") :va "center" :ha "center")
(.show plt)

复制代码;字符串
;Hy的字符机制和Python3是一致的，统一使用Unicode，摒弃了Python2的错误
;Hy的字符串有两种写法,第一种在Hy中称为Symbol,语法是在字母前加一个单引号：
=>'hello
u"hello"
=> '你好
u'\u4f60\u597d'
;第二种是双引号括起来的字符串，可以表示多行字符类似于Python中的三引号
=> "[Q]:what is hy?
... [A]:A dialect of Lisp 
... that's embedded in Python"
u"[Q]:what is hy?\n[A]:A dialect of Lisp \nthat's embedded in Python"
;列表
;Python中最常用的数据结构在Hy中还是用方括号括起来只不过不用写中间的逗号了
=> [1 2 3 4]
[1L, 2L, 3L, 4L]
=> (def data ["panty" "stocking" "garterbelt"])
=> (get data 1)
u"stocking"
;元组
;用S表达式来表达，操作符是逗号
=> (, "hello" "hy")
(u'hello', u'hy')
;字典
=> {'Sunday '星期天 'Saturday '星期天}
{u'Sunday': u'\u661f\u671f\u5929', u'Saturday': u'\u661f\u671f\u5929'}
=> (print (get _ 'Sunday))
星期天

复制代码;赋值可用 def 或者 setv 但一般def用于定义全局变量,setv用于定义局部变量
=> (def n 41)
=> (print n)
41
=> (setv n (inc n))
=> (print n)
42
;除了这些，还有Lisp中的let，可以用来显式地创建词法作用域
=> (let [n 'nana
...      q 'haqi]
...     (print (+ n " " q)))
nana haqi
=> n
42L
=> q
Traceback (most recent call last):
  File "<input type="text" />", line 1, in 
NameError: name 'q' is not defined
;条件语句
=> (print (if (< n 0.0) "negative" ... (= n 0.0) "zero" ... (> n 0.0) "positive"
...            "not a number"))
positive
;或者用cond
=> (print (cond [(< n 0.0) "negative"] ... [(= n 0.0) "zero"] ... [(> n 0.0) "positive"]
...              [True "not a number"]))
positive
;for循环
=> (for [x (range 3)] (print x))
0
1
2
;while循环
(while True (print 'hy))
hy
hy
hy
...
;函数定义，没有显式的return，最后一条表达式的求值结果就是返回值
=> (defn fizzbuzz [i]
...   (cond [(= 0 (% i 15)) 'FizzBuzz]
...         [(= 0 (% i 3)) 'Fizz]
...         [(= 0 (% i 5)) 'Buzz]
...         [True i]))
;函数调用
=> (fizzbuzz 15)
u'FizzBuzz'

复制代码;列表推导
=> (list-comp (** x 2) [x (range 10)])
[0L, 1L, 4L, 9L, 16L, 25L, 36L, 49L, 64L, 81L]
;带条件后缀的列表推导
=> (list-comp (** x 2) [x (range 10)] (odd? x))
[1L, 9L, 25L, 49L, 81L]
;字典推导
=> (dict-comp x (* x 2) [x (range 10)] (odd? x))
{1: 2, 3: 6, 9: 18, 5: 10, 7: 14}
;genexpr ；类似于列表推导但产生的是一个generator
=> (def filtered (genexpr x [x (range 10)] (even? x)))
=> (list filtered)
[0, 2, 4, 6, 8]
;with
=> (with [f (open "./test.txt")] (print (.read f)))
first line
second line
;生成器函数(yield)
=> (defn fib []
...   (setv (, a b) (, 0 1))
...   (while True
...     (yield a)
...     (setv (, a b) (, b (+ a b)))))
=> (list (take 10 (fib)))
[0L, 1L, 1L, 2L, 3L, 5L, 8L, 13L, 21L, 34L]

复制代码;这样定义类
=> (defclass FooBar [object]
...   "Yet Another Example Class"
... 
...   (defn --init-- [self x]
...     (setv self.x x))
... 
...   (defn get-x [self]
...     "Return our copy of x"
...     self.x))
;创建对象
=> (def foobar (FooBar 42))
=> foobar
=> foobar.x
42L
;方法调用
=> (foobar.get-x)
42L
;你也可以用前缀表达式调用类方法，并且更建议这么做
=> (.get-x foobar)
42L

复制代码;首先Python中的 map、reduce、filter 以及 lambda 这些函数式编程的基本组件在Hy中还是一样的
;lambda算子(匿名函数) 和可以使用fn或者lambda来表示
=> (fn [x] (+ x 1))
=> (lambda [x] (+ x 1))
<function <lambda> at 0x7f9b61fe1de8>
=> (_ 1)
2L
;Hy中的map、filter和Python3是一致的，返回的是一个可迭代的延迟求值的对象，而非Python2那样直接返回列表
;map
=> (map (fn [x] (* x x)) (range 1 11))
=> (list _) ;这时把它转换成list的时候才会对map进行求值
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
;filter
=> (filter odd? (range 1 11))
=> (list _)
[1, 3, 5, 7, 9]
;reduce
=> (reduce (fn [a b] (* a b)) (range 1 11)) ;从1开始累乘到10
3628800

复制代码(require [hy.contrib.loop [loop]]) ;导入外部宏
(defn factorial [n]
  (loop [[i n] [acc 1]]
  ;通过loop创建递归的开始点，并初始化递归参数
    (if (zero? i)
      acc
      ;通过recur进入下一轮递归，如果recur不写在结尾位置就会报错
      (recur (dec i) (* acc i)))))
(factorial 1000)

复制代码=> (filter odd? (map inc (map (fn [x] (* x x)) (range 100))))
=> (list _)
[1L, 5L, 17L, 37L, 65L, 101L, 145L, 197L, 257L, 325L, 401L, ...]

复制代码=> (->> (range 100) (map (fn [x] (* x x))) (map inc) (filter odd?))
=> (list _)
[1L, 5L, 17L, 37L, 65L, 101L, 145L, 197L, 257L, 325L, 401L, ...]

复制代码=> (import [sh [cat grep wc]]) ;需要事先安装sh模块: pip install sh
=> (-> (cat "/usr/share/dict/words") (grep "-E" "^hy") (wc "-l"))
210

复制代码(require [hy.contrib.anaphoric [ap-pipe]])
=> (ap-pipe 3 (+ it 1) (/ 5 it))
1.25
=> (ap-pipe [4 5 6 7] (list (rest it)) (len it))
3

复制代码=> (doto [] (.append 1) (.append 2) .reverse)
[2L, 1L]

复制代码(require [hy.contrib.loop [loop]])
(import time)
(import sys)
(.setrecursionlimit sys 1000) ;放宽递归深度限制
(defn fib-recur [n] ;递归的写法
  (if (in n '(0 1))
    (long n)
    (+ (fib-recur (- n 1)) (fib-recur (- n 2)))))
(defn fib-iter [n &optional [a 0] [b 1]] ;迭代的写法，但形式上还是递归的
  (if (zero? n)
    a
    (fib-iter (dec n) b (+ a b))))
(defn fib-tco [n] ;使用尾调用优化的写法
  (loop [[i n] [a 0] [b 1]]
    (if (zero? i)
      a
      (recur (dec i) b (+ a b)))))
(defn fib-gen [] ;使用生成器的写法
  (setv (, a b) (, 0 1))
  (while True
    (yield a)
    (setv (, a b) (, b (+ a b)))))

复制代码(def s (.time time))
(-> (fib-iter 500) print)
(-> (- (.time time) s) print)

复制代码(defmacro timeit [code &optional [label "code"]]
  `(do 
      (setv s (.time time))
      ~code
      (print (.format "{l} run cost {t}s.\n" :l ~label :t (- (.time time) s)))))

复制代码;递归写法的fib计算实在太慢，这里就不考虑它了...
(timeit (-> (fib-iter 500) print) 'fib-iter)
(timeit (-> (fib-tco 500) print) 'fib-tco)
(timeit (-> (nth (fib-gen) 500) print) 'fib-gen)
;运行结果：
;139423224561697880139724382870407283950070256587697307264108962948325571622863290691557658876222521294125
;fib_iter run cost 0.000308990478516s.
;
;139423224561697880139724382870407283950070256587697307264108962948325571622863290691557658876222521294125
;fib_tco run cost 0.000863075256348s.
;
;139423224561697880139724382870407283950070256587697307264108962948325571622863290691557658876222521294125
;fib_gen run cost 0.000124216079712s.

复制代码(defreader t [code]
  `(do
      (setv s (.time time))
      ~code
      (print (.format "code run cost {t}s.\n" :t (- (.time time) s)))))
#t(-> (nth (fib-gen) 500) print)
;结果:
;139423224561697880139724382870407283950070256587697307264108962948325571622863290691557658876222521294125
;code run cost 0.000133037567139s.

复制代码(import requests) ;相当于 import requests
(import [Bio [Seq Align]]) ;from Bio import Seq, Align
(import [Bio [*]]) ;from Bio import *
(import [matplotlib [pyplot :as plt]]) ;from matplotlib import pyplot as plt

复制代码>>> import hy # 在导入Hy模块前需要先import hy
>>> from fib_bench import *
>>> [fib_iter(i) for i in range(10)]
[0L, 1L, 1L, 2L, 3L, 5L, 8L, 13L, 21L, 34L]

复制代码{
 "id":xx,"time":"2017-11-19","key1":"value1","key2":"value2".......  
}

复制代码var wirteChan = make(chan []byte) //用于写入文件
var waitgroup sync.WaitGroup //用于控制同步
func main(){
    //省略写入文件的打开操作，毕竟我们主要讲并发这块
    
    //初始化写入的channel
	InitWriter(outLogFileWriter)
	//接下来去遍历每个日志文件，每读出一个日志项就开一个gorountine去处理
	for _,file := range logDir {
	    if file.IsDir() {
			continue
		} else {
			HandlerFile(arg.dir + "/" + file.Name()) //处理每个文件
		}
	}
}
/**
 * 初始化Writer的channel
 */
func InitWriter(outLogFileWriter *bufio.Writer) {
	go func() {
		for data := range wirteChan {
			nn, err := outLogFileWriter.Write(data)
		}
	}()
}
//处理每个文件，然后开G去处理每个日志项
func HandlerFile(fileName string) {
	file, err := os.Open(fileName)
	defer file.Close()
	br := bufio.NewReader(file)
	for {
		data, err := br.ReadBytes('\n')
		if err == io.EOF {
			break
		} else {
			go Handler(data) //每次开一个G去处理，处理完写入writeChannel
		}
	}
}

复制代码/**
 * Job结构体，包含要处理的数据和处理函数（这个可根据需要修改）
 */
type Job struct {
	Data []byte
	Proc func([]byte)
}
//Job队列，存储要做的Job,将每个任务打包成Job发送到这里
var JobQueue chan Job = make(chan Job, arg.maxqueue)
//启动处理函数处理
func Handler(Data []byte) {
    for range job := <-Queue {
        job.Proc(Data)
    }
}

复制代码type Job struct {
	Data interface{}
	Proc func(interface{})
}
//Job队列，存储要做的Job
var JobQueue chan Job = make(chan Job, arg.maxqueue)
//Woker,用来从Job队列中取出Job执行
type Worker struct {
	WokerPool  chan chan Job //表示属于哪个Worker池,同时接收JobChannel注册
	JobChannel chan Job      //任务管道，通过这个管道获取任务执行
	Quit       chan bool     //用来停止Worker
}
//新建一个Worker,需要传入Worker池参数
func NewWorker(wokerPool chan chan Job) Worker {
	return Worker{
		WokerPool:  wokerPool,
		JobChannel: make(chan Job),
		Quit:       make(chan bool),
	}
}
//Worker的启动：包含：(1) 把该worker的JobChannel注册到WorkerPool中去  (2) 监听JobChannel上有没有新的任务到来 (3) 监听是否受到关闭的请求
func (worker Worker) Start() {
	go func() {
		for {
			worker.WokerPool <- worker.JobChannel //每次做完任务后就重新注册上去通知本worker又处于可用状态了
			select {
			case job := <-worker.JobChannel:
				job.Proc(job.Data)
			case quit := <-worker.Quit: //接收到关闭信息，直接退出即可
				if quit {
					return
				}
			}
		}
	}()
}
//Worker的关闭：只要发送一个关闭信号即可
func (worker Worker) Stop() {
	go func() {
		worker.Quit <- true
	}()
}
//管理Worker的调度器,包含最大worker数量和workerpool
type Dispatcher struct {
	MaxWorker  int
	WorkerPool chan chan Job
}

//启动一个调度器
func (dispatcher *Dispatcher) Run() {
	//启动maxworker个worker
	for i := 0; i < dispatcher.MaxWorker; i++ {
		worker := NewWorker(dispatcher.WorkerPool)
		worker.Start()
	}
	//接下来启动调度服务
	go dispatcher.dispatch()
}

func (dispatcher *Dispatcher) dispatch() {
	for {
		select {
		case job := <-JobQueue:
			go func(job Job) {
				jobChannel := <-dispatcher.WorkerPool //获取一个可用的worker
				jobChannel <- job                     //将该job发送给该worker
			}(job)
		}
	}
}

//新建一个调度器
func NewDispatcher(maxWorker int) *Dispatcher {
	workerPool := make(chan chan Job, maxWorker)
	return &Dispatcher{
		WorkerPool: workerPool,
		MaxWorker:  maxWorker,
	}
}

复制代码	int check(int sp) {
	   // 檢查同行、列、九宮格有沒有相同的數字，若有傳回 1
	   int fg= 0 ;
	   if(!fg) fg= check1(sp, startH[sp], addH) ;   // 檢查同列有沒有相同的數字
	   if(!fg) fg= check1(sp, startV[sp], addV) ;   // 檢查同行有沒有相同的數字
	   if(!fg) fg= check1(sp, startB[sp], addB) ;   // 檢查同九宮格有沒有相同的數字
	   return(fg) ;
	}

	int check1(int sp, int start, int *addnum) {
	   // 檢查指定的行、列、九宮格有沒有相同的數字，若有傳回 1
	   int fg= 0, i, sp1  ;
	   //万恶的for循环
	   for(i=0; i<9; i++) {
	      sp1= start+ addnum[i] ;
	      if(sp!=sp1 && sudoku[sp]==sudoku[sp1]) fg++ ;
	   }
	   return(fg) ;
	}

复制代码	// sp 是当前位置索引，indexV 行索引，indexH 列索引，indexB九宫格索引
	int check(int sp,int indexV,int indexH,int indexB) {
	   // 检查同行、列、九宮格沒有用到的数字，若已经用过返回 1
		int status = statusV[indexV]|statusH[indexH]|statusB[indexB];
		//9个数字都被用了
		if (status>=STATUS_MAX_VALUE)
		{
			return 1;
		}
		int number=sudoku[sp];
		//取右数第k位,若是1表明这个值已经存在了
		return status>>(number-1)&1;
	}

复制代码	// 行、列、宫二进制数据指定位置标记为1
	int markStatus(int indexV,int indexH,int indexB,int number){
		if (number<1)
		{
			return 0;
		}
		//把右数第k(从1计数)位变成1 
   	  	statusV[indexV]|=(1<<(number-1));
    	statusH[indexH]|=(1<<(number-1));
    	statusB[indexB]|=(1<<(number-1));
	}

复制代码int swap(int a, int b)  
{  
    if (a != b)  
    {  
        a ^= b;  
        b ^= a;  
        a ^= b;  
    }  
}

复制代码int abs(int a)  
{  
    int i = a >> 31;  
    return ((a ^ i) - i);  
}

复制代码int nlz(unsigned x)
{
   int n;

   if (x == 0) return(32);
   n = 1;
   if ((x >> 16) == 0) {n = n +16; x = x <<16;}
   if ((x >> 24) == 0) {n = n + 8; x = x << 8;}
   if ((x >> 28) == 0) {n = n + 4; x = x << 4;}
   if ((x >> 30) == 0) {n = n + 2; x = x << 2;}
   n = n - (x >> 31);
   return n;
}

复制代码int reverse_order(int n){

  n = ((n & 0xAAAAAAAA) >> 1) | ((n & 0x55555555) << 1);
  n = ((n & 0xCCCCCCCC) >> 2) | ((n & 0x33333333) << 2);
  n = ((n & 0xF0F0F0F0) >> 4) | ((n & 0x0F0F0F0F) << 4);
  n = ((n & 0xFF00FF00) >> 8) | ((n & 0x00FF00FF) << 8);
  n = ((n & 0xFFFF0000) >> 16) | ((n & 0x0000FFFF) << 16);

  return n;
}

复制代码 unsigned int BitCount_e(unsigned int value) {
        unsigned int count = 0;
        // 解释下下面这句话代码，这句话求得两两相加的结果，例如 11 01 00 10
        // 11 01 00 10 = 01 01 00 00 + 10 00 00 10，即由奇数位和偶数位相加而成
        // 记 value = 11 01 00 10，high_v = 01 01 00 00， low_v = 10 00 00 10
        // 则 value = high_v + low_v，high_v 右移一位得 high_v_1，
        // 即 high_v_1 = high_v >> 1 = high_v / 2
        // 此时 value 可以表示为 value = high_v_1 + high_v_1 + low_v，
        // 可见 我们需要 high_v + low_v 的和即等于 value - high_v_1
        // 写简单点就是 value = value & 0x55555555 + (value >> 1) & 0x55555555;
        value = value - ((value >> 1) & 0x55555555);

        // 之后的就好理解了
        value = (value & 0x33333333) + ((value >> 2) & 0x33333333);
        value = (value & 0x0f0f0f0f) + ((value >> 4) & 0x0f0f0f0f);
        value = (value & 0x00ff00ff) + ((value >> 4) & 0x00ff00ff);
        value = (value & 0x0000ffff) + ((value >> 8) & 0x0000ffff);
        return value;

        // 另一种写法，原理一样，原因在最后一种解法中有提到
        //value = (value & 0x55555555) + (value >> 1) & 0x55555555;
        //value = (value & 0x33333333) + ((value >> 2) & 0x33333333);
        //value = (value & 0x0f0f0f0f) + ((value >> 4) & 0x0f0f0f0f);
        //value = value + (value >> 8);
        //value = value + (value >> 16);
        //return (value & 0x0000003f);
    }

复制代码type I interface {
    f1(name string)
    f2(name string) (error, float32)
    f3() int64
}

复制代码type T int64
func (T) f1(name string) {
    fmt.Println(name)
}
func (T) f2(name string) (error, float32) {
    return nil, 10.2
}
func (T) f3() int64 {
    return 10
}

复制代码type I interface {
    M() string
}
type T struct {
    name string
}
func (t T) M() string {
    return t.name
}
func Hello(i I) {
    fmt.Printf("Hi, my name is %s\n", i.M())
}
func main() {
    Hello(T{name: "Michał"}) // "Hi, my name is Michał"
}

复制代码type I1 interface {
    M1()
}
type I2 interface {
    M2()
}
type T struct{}
func (T) M1() { fmt.Println("T.M1") } // 类型T实现了接口I1
func (T) M2() { fmt.Println("T.M2") } // 类型T实现了接口I2
func f1(i I1) { i.M1() }
func f2(i I2) { i.M2() }
func main() {
    t := T{}
    f1(t) // "T.M1"
    f2(t) // "T.M2"
}

复制代码type I interface {
    M()
}
type T1 struct{}
func (T1) M() { fmt.Println("T1.M") } // 类型T1实现了接口I
type T2 struct{}
func (T2) M() { fmt.Println("T2.M") } // 类型T2实现了接口I
func f(i I) { i.M() }
func main() {
    f(T1{}) // "T1.M"
    f(T2{}) // "T2.M"
}

复制代码type I interface { // 定义了一个接口I，它包含四个方法
    m1()
    m2(int)
    m3(int) int
    m4() int
}

复制代码import "fmt"
type I interface {
     m1()
}
type J interface {
    m2()
    I
    fmt.Stringer
}

复制代码type I interface {
    J
    i()
}
type J interface {
    K
    j()
}
type K interface {
    k()
}

复制代码type I interface {
    J
    i()
}
type J interface {
    K
    j()
}
type K interface {
    k()
    I
}

复制代码type I interface {
    J
    i()
}
type J interface {
    j()
    i(int)
}

复制代码type ReadWriter interface {
    Reader
    Writer
}

复制代码type I interface {
    method1()
}
type T struct{}
func (T) method1() {}
func main() {
    var i I = T{} // 变量i是接口类型I的变量, T实现了接口I, 则i可以保存类型为T的变量值
    fmt.Println(i)
}

复制代码type I interface {
    M()
}
type T1 struct {}
func (T1) M() {} // 类型T1实现了接口I
type T2 struct {}
func (T2) M() {} // 类型T2实现了接口I
func main() {
    var i I = T1{} // 接口类型变量i，可以赋值为T1，也可以被赋值为类型T2
    fmt.Printf("%T\n", i) // 输出main.T1
    i = T2{}
    fmt.Printf("%T\n", i) // 输出main.T2
    _ = i
}

复制代码fmt.Println(reflect.TypeOf(i).PkgPath(), reflect.TypeOf(i).Name())
fmt.Println(reflect.TypeOf(i).String())

复制代码fmt.Printf("%T\n", i)

复制代码type I interface {
    M()
}
type T struct {}
func (T) M() {} // 类型T实现了接口I
func main() {
    var t *T // 变量t必然是空值nil
    if t == nil {
        fmt.Println("t is nil")  // 输出这里
    } else {
        fmt.Println("t is not nil")
    }
    var i I = t // t是空值，但i呢？
    if i == nil {
        fmt.Println("i is nil")
    } else {
        fmt.Println("i is not nil")
    }
}

复制代码t is nil
i is not nil

复制代码type I interface {}
type T struct {}
func F() I { // 函数F应该返回接口类型I，在此例中接口类型的返回值=返回类型为*T，值为nil
    var t *T
    if false { // not reachable but it actually sets value
        t = &T{}
    }
    return t // 这里返回的变量t是空值nil
}
func main() {
    fmt.Printf("F() = %v\n", F()) // 返回参数的动态值为nil
    fmt.Printf("F() is nil: %v\n", F() == nil) // 返回参数为接口类型，此接口类型的值并不为nil
    fmt.Printf("type of F(): %T", F()) // 返回参数类型为类型T
}

复制代码F() = <nil>
F() is nil: false
type of F(): *main.T

复制代码type I interface {}
type T struct {}
func (T) M() {}
func main() {
    var i I = T{}
    _ = i
}

复制代码import (
    "fmt"
    "regexp"
)
type I interface {
    Find(b []byte) []byte // 接口I包含方法Find，而Regexp实现包含此方法实现(方法名+签名)，则Regexp实现了接口I
}
func f(i I) {
    fmt.Printf("%s\n", i.Find([]byte("abc")))
}
func main() {
    var re = regexp.MustCompile(`b`) // 返回类型为*Regexp
    f(re)
}

复制代码type I interface {
    M1()
}
type T int64
func (T) M1() {}
func (T) M2() {}
func main() {
    var i I = T(10) // 接口类型值i只能访问M1()方法
    i.M1()
    i.M2() // i.M2 undefined (type I has no field or method M2)
}