标签归档：go

// 文件名: main.go
// Python实用宝典
package main

import (
	"fmt"
	"time"

	"github.com/gocelery/gocelery"
	"github.com/gomodule/redigo/redis"
)

func minus() {
    start := time.Now()
    decrement(100000000)
    fmt.Println(time.Since(start))
}

func decrement(n int) {
    for n > 0 {
        n -= 1
    }
}


func main() {

	// create redis connection pool
	redisPool := &redis.Pool{
		MaxIdle:     3,                 // maximum number of idle connections in the pool
		MaxActive:   0,                 // maximum number of connections allocated by the pool at a given time
		IdleTimeout: 240 * time.Second, // close connections after remaining idle for this duration
		Dial: func() (redis.Conn, error) {
			c, err := redis.DialURL("redis://")
			if err != nil {
				return nil, err
			}
			return c, err
		},
		TestOnBorrow: func(c redis.Conn, t time.Time) error {
			_, err := c.Do("PING")
			return err
		},
	}

	// initialize celery client
	cli, _ := gocelery.NewCeleryClient(
		gocelery.NewRedisBroker(redisPool),
		&gocelery.RedisCeleryBackend{Pool: redisPool},
		5, // number of workers
	)

	// register task
	cli.Register("go_tasks.minus", minus)

	// start workers (non-blocking call)
	cli.StartWorker()

	// wait for client request
	time.Sleep(1000 * time.Second)

	// stop workers gracefully (blocking call)
	cli.StopWorker()
}

输入命令：

go run main.go

即可运行该worker

2.编写Python客户端

# 文件名: go_tasks.py
# Python实用宝典
from celery import Celery

app = Celery('go_tasks',broker='redis://127.0.0.1:6379')

app.conf.update(
    CELERY_TASK_SERIALIZER='json',
    CELERY_ACCEPT_CONTENT=['json'],  # Ignore other content
    CELERY_RESULT_SERIALIZER='json',
    CELERY_ENABLE_UTC=True,
    CELERY_TASK_PROTOCOL=1,
)


@app.on_after_configure.connect
def setup_periodic_tasks(sender, **kwargs):
    # 每5秒调度一次1亿减到1，不过不跑Python worker，
    # 由于Go Worker在运行，这里的minus会被Go Worker消费。
    sender.add_periodic_task(5.0, minus.s())


@app.task
def minus():
    x = 100000000
    while x > 1:
        x = x-1

每5秒调度一次1亿减到1，不过不跑Python worker. 由于Go Worker在运行，这里的minus会被Go Worker消费。

另外请注意，这里的minus函数实际上只是为了能被识别到而编写的，其内容毫无意义，直接写个pass都没问题（因为实际上是Go Worker在消费）。

编写完后，针对go_tasks模块启动beat：

celery -A go_tasks beat

此时，调度器就会调度Go Worker执行任务：

可以看到，我们成功用Python的Celery Beat调度了Go写的Worker！可喜可贺。

接下来可以看看如果单纯用Python的Worker做这样的计算是有多耗时：

# 文件名: python_tasks
# Python实用宝典
from celery import Celery

app = Celery('python_tasks')


@app.on_after_configure.connect
def setup_periodic_tasks(sender, **kwargs):
    sender.add_periodic_task(1.0, minus.s())

@app.task
def minus():
    x = 100000000
    while x > 1:
        x = x-1

启动worker:

celery worker -A python_tasks -l info --pool=eventlet

启动beat调度器:

celery -A python_tasks beat

结果如下：

可以看到，Python从1亿减到1平均需要5.2秒左右的时间，和Go版相差了100倍左右。

如果我们将调度器的频率提高到每秒计算1次，Python版的Worker，其任务队列一定会堵塞，因为Worker消费能力不够强大。相比之下，Go版的Worker可就非常给力了。

因此，如果你的项目中有这种计算密集型的任务，可以尝试将其提取成Go版本试试，说不定有惊喜呢。

我们的文章到此就结束啦，如果你喜欢今天的Python 实战教程，请持续关注Python实用宝典。

有任何问题，可以在公众号后台回复：加群，回答相应验证信息，进入互助群询问。

原创不易，希望你能在下面点个赞和在看支持我继续创作，谢谢！

Python实用宝典 (pythondict.com)
不只是一个宝典
欢迎关注公众号：Python实用宝典

解决方案

优劣互补! Python+Go结合开发的探讨

2020年6月27日 Python实用宝典留下评论

1.都说Go语言性能非常强大，那么到底比Python强多少？

为了比较Go语言和Python语言在单线程性能上的差距，我们可以做一个简单实验，从1亿减到1：

Python代码：

import time
def decrement(n):
    while n > 0:
         n -= 1

start = time.time()
decrement(100000000)
end = time.time()
print(f"{end - start}s.")

结果如下：

大约需要4秒-5秒才能完成这项工作，那么Go语言呢？

package main

import "fmt"
import "time"

var c chan int

func decrement(n int) {
    for n > 0 {
        n -= 1
    }
}

func main() {
    start := time.Now()
    decrement(100000000)
    fmt.Println(time.Since(start))
}

结果如下：

确实，两者差了不止100倍，看得出来Go是一个比较有前途的语言，具有强大的性能（除此之外，它还有简单易学、能轻松实现高并发的特点）。

不过，它的社区建设和Python相比还是有很大的差距，许多第三方库依然还没有支持Go语言。因此，它想要替代Python还有非常长的路要走。

2.Go性能强大、Python社区强大，两者能否结合起来？

我们试试看能否在Python中调用Go的方法，在Go中从1亿减到1。

首先，将刚刚go语言版的1亿减到1改为在一个函数中进行，并返回结果：

package main

import (
    "C"
    "time"
)

var c chan int

func decrement(n int) {
    for n > 0 {
        n -= 1
    }
}

//export count_time
func count_time() *C.char {
    start := time.Now()
    decrement(100000000)
    total_time := time.Since(start).String()
    return C.CString(total_time)
}

func main() {}

然后生成动态链接库以便Python调用Go里写的函数：

go build -buildmode=c-shared -o main.so count.go

这样会在当前文件夹中生成 main.so 和 main.h.

在Python中我们需要加载该生成的main.so动态链接库，并配置好输出变量的类型，最后调用方法得到结果：

import time
from ctypes import cdll, c_char_p

start = time.time()

# 加载动态链接库
lib = cdll.LoadLibrary('./main.so')

# 配置输出参数变量类型
lib.count_time.restype = c_char_p

# 调用方法
rest = lib.count_time()

end = time.time()

print(f"Go 内部执行时间：{rest}")
print(f"Python 整体执行时间: {end - start}s")

结果如下：

可以看到，使用这个方案将Python和Go两者结合起来的性能依然非常高，但就是多了一个生成和调用动态链接库的过程，增加了代码的耦合性。

其实，这也是C+Python的开发方式，只不过我们将C换成了Go，因为Go开发起来实在是舒服多了。

如果以后你的Python代码中有某个部分计算特别复杂，你可以尝试将其改写成go，通过动态链接库的方式调用go写的代码，将能大大提高性能。

这样，既能安心享受Python带来的丰富社区资源，又能享受Go语言的性能优势，真的美滋滋。

我们的文章到此就结束啦，如果你喜欢我们今天的Python 实战教程，请持续关注我们，如果对你有帮助，麻烦在下面点一个赞/在看哦有任何问题都可以在下方留言区留言，我们都会耐心解答的！

Python实用宝典 (pythondict.com)
不只是一个宝典
欢迎关注公众号：Python实用宝典

Python 实用宝典

标签归档：go

Flatbuffers-FlatBuffers：内存效率高的串行化库

Flatbuffers

支持的操作系统

支持的编程语言

贡献

安全性

许可

什么？Python Celery 也能调度Go worker？

1.编写Go Worker

2.编写Python客户端

优劣互补! Python+Go结合开发的探讨

有趣好用的Python教程

<img decoding="async" src="https://camo.githubusercontent.com/668b1f99285d0f37b92887c976a731854d87eb6e9344f2208dbad61aefdf8492/687474703a2f2f676f6f676c652e6769746875622e696f2f666c6174627566666572732f66706c5f6c6f676f5f736d616c6c2e706e67" alt="logo" width="474" height="400">Flatbuffers

支持的操作系统

支持的编程语言

贡献

安全性

许可

1.编写Go Worker

2.编写Python客户端

有趣好用的Python教程

Flatbuffers