作者：瀚高PG实验室 （Highgo PG Lab）- 徐云鹤
 背景：
 小L:鹤神鹤神，为什么我设置的同步流复制，主库提交之后备库查不到数据呢？
 我：估计是你设置的同步级别不够高~
 小L:还分同步级别？同步模式不就是保证两边数据一致的吗？怎么还会出现主库能查到数据备库查不到数据的情况呢？查询pg_stat_replication里边显示sync不就是代表数据一致吗？
 我：带我给你慢慢道来。
 
pg同步流复制和异步流复制关键在于两个参数：
 synchronous_standby_names 控制哪些standby被应用同步策略，该参数使用方法不在此赘述；
 synchronous_commit控制同步策略级别。
 你以为的同步可能不是你以为的同步。
 即使是通过pg_stat_replication查询出sync_state列值为sync也不一定是真正的同步。
 下边通过一个图片和表格来直观提现什么时候是同步，什么时候是异步，及不同等级之间的区别。
 
 synchronous_commit参数：
 
同步等级
设定值
概述
保证范围
同步
remote_apply
应用发起提交后，等到在备库上应用WAL（更新数据）后，它将返回COMMIT响应，并且可以在备库上进行引用。由于完全保证了数据同步，因此它适合需要备库始终保持最新数据的负载分配场景。
1-9
同步
on（默认）
应用发起提交后，在备库上写入WAL之后，返回COMMIT响应。该选项是性能和可靠性之间的最佳平衡。
1-6
准同步的
remote_write
应用发起提交后，等到WAL已传输到备库后，返回COMMIT响应。
1-5
异步
local
应用发起提交后，写入主库WAL之后，返回COMMIT响应。
1-2
异步
off
应用发起提交后，直接返回COMMIT响应，而无需等待主库WAL完成写入。
1
最后举个例子，主库设置synchronous_commit为on，备库设置recovery_min_apply_delay = ‘1d’。
 这样就会出现主库pg_stat_replication查询出sync_state列值为sync，提交一条数据后备库查不到的现象。

同步方式与异步方式的区别
 
 
异步请求是进行局部刷新，同步请求是进行整体刷新
 
 
异步请求是由ajax的引擎发起的，同步请求是由浏览器发起的
 
 
异步请求在请求发起之后还没收到响应之前还可以再次发起其它请求不影响当前页面的操作，而同步请求在发起之后，只有收到了响应后才能进行其它操作。
 
同步方式发送请求
 
 
        发送一个请求，需要等待响应返回，然后才能够发送下一个请求，如果该请求没有响应，不能发送下一个请求，客户端会处于一直等待过程中。
 
异步方式发送请求
 
 
发送一个请求，不需要等待响应返回，随时可以再发送下一个请求，即不需要等待。

摘要：Lua中的协程是用户级线程，任何时候只有一个协程在真正运行，程序员能够控制协程的切换和运行，可以用同步的方式编写异步的逻辑。
 
进程、线程、协程
 
在操作系统中，进程拥有自己独立的内存空间，多个进程同时运行不会相互干扰，但是进程之间的通信比较麻烦；线程拥有独立的栈但共享内存，因此数据共享比较容易，但是多线程中需要利用加锁来进行访问控制：这是个非常头痛的问题，不加锁非常容易导致数据的错误，加锁容易出现死锁。多线程在多个核上同时运行，程序员根本无法控制程序具体的运行过程，难以调试。而且线程的切换经常需要深入到内核，因此线程的切换代价还是比较大的。
 
协程coroutine拥有自己的栈和局部变量，相互之间共享全局变量。任何时候只有一个协程在真正运行，程序员能够控制协程的切换和运行，因此协程的程序相比多线程编程来说轻松很多。由于协程是用户级线程，因为协程的切换代价很小。
 
协程的挂起
 
程序员能够控制协程的切换，这句话需要认真理解下。程序员通过yield让协程在空闲（比如等待io，网络数据未到达）时放弃执行权，通过resume调度协程运行。协程一旦开始运行就不会结束，直到遇到yield交出执行权。Yield和resume这一对控制可以比较方便地实现程序之间的“等待”需求，即“异步逻辑”。总结起来，就是协程可以比较方便地实现用同步的方式编写异步的逻辑。
 
“生产者-消费者”
 
异步逻辑最常见的例子便是“生产者-消费者”案例，消费者consumer需要等待生产者producer，只有生产了数据才能消费，这便是一个“等待的异步需求”。
 
 
Lua中协程常用接口：
 
coroutine接口
说明:
coroutine.create(func)
创建一个协程
coroutine.resume(coroutine, [arg1, arg2..])
执行协程，第一次从头开始运行，之后每次从上次yield处开始运行，每次运行到遇到yield或者协程结束
coroutine.yield(…)
挂起当前协程，交出执行权
 
 
利用协程的yield和resume实现的生产者-消费者代码：
 
--生产者
    function producer()
        return coroutine.create(
            function()
                while true do
                    local a = io.read()
                    --挂起协程，交出执行权
                    coroutine.yield(a)
                end
            end
        )
    end

    --消费者
    function consumer(pro)
        while true do
    --执行生产者协程
            local s, v = coroutine.resume(pro)
            print ('s='..tostring(s)..', v='..v)
        end
    end
    p = producer()
    consumer(p)
 
 
coroutine实现server
 
接下来再看一个用协程处理客户端请求的服务器：server主线程接收client请求，接受连接上来后为每个client创建一个coroutine，这个coroutine监听client发来的数据如果有数据发来那么进行处理，如果没有数据那么yield挂起交出执行权。
 
    -- server.lua
    --listen connection from client, and make a coroutine for each connection
    --each coroutine recv data from client and send data back to client

    local socket = require("socket")
    local host = "127.0.0.1"
    local port = "8888"
    local connections = {}
    local threads = {}

    function receive_data(sock_id)
        local conn = connections[sock_id]
        if conn ~= nil then
            local recvt, t, status = socket.select({conn}, nil, 1)
            if #recvt > 0 then
                local receive, receive_status = conn:receive()

                if receive_status ~= "closed" then
                    if receive then
                        assert(conn:send(receive .. "\n"))
                        print("Receive Client " .. sock_id.. " : " ..receive)
                    end
                --disconnect
                else
                    print("Client " .. sock_id .. " disconnect!")
                    connections[sock_id].close()
                    connections[sock_id] = nil
                    threads[sock_id] = nil
                end
            end
            --yield, stop execution of this coroutine
            coroutine.yield()
        end
    end

    --handle data from client: send data back to client 
    function connection_handler(sock_id)
        while true do
            --print ('connection_handler.. id=' .. sock_id)
            local conn = connections[sock_id]
            if conn == nil then
                break
            end
            local data, status = receive_data(sock_id)
        end
    end

    --create coroutine to handle data from client
    function create_handler(sock_id)
        --print 'create_handler..'
        local handler = coroutine.create(function ()
            connection_handler(sock_id)
        end)
        return handler
    end

    function accept_connection(sock_id, conn)
        print("accepted new socket ,id = " .. sock_id)
        connections[sock_id] = conn
        threads[sock_id] = create_handler(sock_id)
    end

    --schedule all clients
    function dispatch()
        for _sock_id, _thread in ipairs(threads) do
            --print ('dispatch, _sock_id = '.. _sock_id)
            coroutine.resume(threads[_sock_id])
        end
    end

    function start_server()
        local server = assert(socket.bind(host, port, 1024))
        print("Server Start " .. host .. ":" .. port)
        server:settimeout(0)

        local conn_count = 0
        while true do
            --accept new connection
            local conn = server:accept()
            if conn then
                conn_count = conn_count + 1
                accept_connection(conn_count, conn)
            end
            --deal data from connection
            dispatch()
        end 
    end

    function main()
        start_server()
    end
    main()


    --client.lua
    -- send user input data to server and print data from server
    local socket = require("socket")
    local host = "127.0.0.1"
    local port = 8888
    local sock = assert(socket.connect(host, port))
    sock:settimeout(0)

    function main()
        print("Press enter after input something:")
        local input, recvt, sendt, status
        while true do
            input = io.read()
            if #input > 0 then
                assert(sock:send(input .. "\n"))
            end
            recvt, sendt, status = socket.select({sock}, nil, 1)
            while #recvt > 0 do
                local response, receive_status = sock:receive()
                if receive_status ~= "closed" then
                    if response then
                        print ('recv from server:'..response)
                        recvt, sendt, status = socket.select({sock}, nil, 1)
                    end
                else
                    break
                end
            end
        end
    end
    main()
 
coroutine_server 运行
 
首先启动server，然后启动两个client去连接并进行输入，server利用coroutine对client的输入进行了回写，执行情况如下图所示：
 
 
 
 
 
github源码
 
https://github.com/harryzeng/coroutine_server
 
参考
 
http://my.oschina.net/wangxuanyihaha/blog/186401 
 http://www.kuqin.com/system-analysis/20110910/264592.html

 
 
 
  
在PWM控制电路中，载波频率 fc 和调制信号频率 fr 之比成为载波比，根据载波信号和信号波信号是否同步分为同步调制和异步调制。
 
 

1 什么是异步调制？
 
载波信号和调制信号不保持同步的方式称为异步调制，如下图所示，异步调制的载波频率是不变的，但是调制波的频率是改变的。同时由载波比的定义可知，异步调制的载波比也是变化的；
 
 
异步调制还有一个重要的特点就是输出的脉冲波是不对成的，不仅1/4脉冲不对成，正负半周期的脉冲也不对称，这会导致电流输出的谐波较多。如下图所示：
 
 
2 什么是同步调制？
 
同步调制的载波比N等于常数，并在变频时使载波和调制波保持同步的方式称为同步调制。
 
其特点如下：
 
第一：载波比N为常数，每个周期内输出的脉冲数的固定。这是因为载波比固定，所以一个周期的调制波内的载波数目是一定的，从而一个周期内的脉冲个数也是固定的。
 
第二：脉冲相位固定。这是因为无论调制波的频率如何变化，载波个数不变。无论调制波的频率增大减小，反应到一个周期的过程中是没有变化的。
 
 
 
3 同步调制和异步调制区别总结
 
同步调制和异步调制在控制方式上其实是有很大区别的；
 
第一：实现方式不同。
 
异步调制只需要给定定频率的载波，调制波的频率也不需要特定控制，而同步调制则需要复杂的算法使得载波和调制波同频同相；举个例子，在双闭环的矢量控制系统中其实是默认为异步调制的，因为我们所用的大部分SVPWM模块的思路都是先通过计算空间矢量法得到调制波，然后再与三角载波比较得到所需要的PWM脉冲。但是想要在双闭环实现同步调制，就必须使得载波和调制波同步，在电机的速度上升过程中，调制波的频率是时刻改变，这个时候要随时都能实现载波和调制波的同频同相就需要复杂的控制算法，实现起来相对困难。
 
第二：谐波含量不同。
 
异步调制的谐波含量要远高于同步调制。但是由于我们默认认知的电机控制系统似乎很少涉及到谐波的处理，其实根本原因是这些不考虑谐波的电机系统都是基于很高载波比的情况。因为变频器输出的PWM波的谐波主要集中在开关频率整数倍附近。 也就是说，载波比越大，开关频率越高，谐波的频率越高。 而变频器的负载是电机，电机是感性负载，高频信号通过电感，电流谐波将被衰减，谐波频率越高，衰减幅度越大。正是由于高次谐波被电机的感性特性所抑制，所以这些谐波被近似忽略了。而同步调制，通过使得载波比为3的整数倍，消除了3及其3的倍数次的谐波；并且通过适合PWM波正负半周期对称（N载波比取奇数）消除偶次谐波，总体同步调制所含谐波只为6k±1次谐波（常见的5 7 11 13次谐波）等。
 
第三：应用场合的不同。
 
其实在小功率的电机控制系统中，所以就算使用的开关器件开关频率较高，开关损耗仍然较小，并不太需要取刻意的消除谐波。但是在大功率的场合，如果开关频率太高，就会导致开关损耗升高，使用异步调制的话会导致大量的高幅值的低次谐波，所以需要应用同步调制的策略来消除低频的谐波。