📌  相关文章
📜  Python 克里斯蒂安Cristian算法

📅  最后修改于: 2020-05-06 01:12:43             🧑  作者: Mango

Cristian算法是一种时钟同步算法，用于通过客户端进程将时间与时间服务器同步。该算法在往返时间比精度短的低延迟网络中很容易使用，而易于冗余的分布式系统/应用程序与该算法不兼容。这里的往返时间是指请求开始到相应响应结束之间的持续时间。
下面是一个模拟cristian算法的示意图：
Cristian's agorithm illustration
算法：
1)客户端计算机上的进程在时间T_0向时钟服务器发送获取时钟时间(服务器时间)的请求。 。
2)Clock Server侦听客户端进程发出的请求，并以Clock server time的形式返回响应。
3)客户端进程在时间T1处获取时钟服务器的响应，并使用以下公式计算同步的客户端时钟时间。

   \[ T_{CLIENT} = T_{SERVER} + (T_1 - T_0)/2 \]

其中，T_{CLIENT}是指同步时钟时间，
T_{SERVER}是指服务器返回的时钟时间，
T_0是指客户端进程发送请求
T_1的时间，是指客户端进程接收响应的时间

以上公式的工作/可靠性：
T_1 - T_0“网络延迟”是指网络将请求传输到服务器，处理请求并将响应返回给客户端进程所花费的总时间，假设网络等待时间T_0和T_1大约相等。
客户端时间与实际时间最多相差(T_1 - T_0)/2秒。使用以上语句，我们可以得出结论，同步错误最多为(T_1 - T_0)/2秒。
因此:

  \[ error\, \epsilon\, [-(T_1 - T_0)/2, \, (T_1 - T_0)/2] \]

 

下面的Python代码说明了Cristian算法的工作原理：
下面的代码用于在本地计算机上初始化时钟服务器的原型：

# 模仿时钟服务器的Python3程序
import socket
import datetime
# 用于启动时钟服务器的函数
def initiateClockServer():
    s = socket.socket()
    print("套接字创建成功")
    # 服务器端口
    port = 8000
    s.bind(('', port))
    # 开始听请求
    s.listen(5)
    print("套接字正在监听...")
    # 时钟服务器永远运行
    while True:
       # 与客户建立联系
       connection, address = s.accept()
       print('Server connected to', address)
       # 用服务器时钟时间响应客户端
       connection.send(str(
                    datetime.datetime.now()).encode())
       # 关闭与客户端进程的连接
       connection.close()
# 测试函数
if __name__ == '__main__':
    # 触发时钟服务器
    initiateClockServer()

输出：

套接字创建成功
套接字正在监听...

以下代码用于在本地计算机上启动客户端进程的原型：

# 模仿客户端进程的Python3程序
import socket
import datetime
from dateutil import parser
from timeit import default_timer as timer
# 用于同步客户端处理时间的功能
def synchronizeTime():
    s = socket.socket()
    # 服务器端口
    port = 8000
    # 连接到本地计算机上的时钟服务器
    s.connect(('127.0.0.1', port))
    request_time = timer()
    # 从服务器接收数据
    server_time = parser.parse(s.recv(1024).decode())
    response_time = timer()
    actual_time = datetime.datetime.now()
    print("Time returned by server: " + str(server_time))
    process_delay_latency = response_time - request_time
    print("Process Delay latency: " \
          + str(process_delay_latency) \
          + " seconds")
    print("Actual clock time at client side: " \
          + str(actual_time))
    # 同步进程客户端时钟时间
    client_time = server_time \
                      + datetime.timedelta(seconds = \
                               (process_delay_latency) / 2)
    print("Synchronized process client time: " \
                                        + str(client_time))
    # 计算同步误差
    error = actual_time - client_time
    print("Synchronization error : "
                 + str(error.total_seconds()) + " seconds")
    s.close()
# 测试函数
if __name__ == '__main__':
    # synchronize time using clock server
    synchronizeTime()

输出：

Time returned by server: 2018-11-07 17:56:43.302379
Process Delay latency: 0.0005150819997652434 seconds
Actual clock time at client side: 2018-11-07 17:56:43.302756
Synchronized process client time: 2018-11-07 17:56:43.302637
Synchronization error : 0.000119 seconds

时钟同步的即兴性：
使用网络上的迭代测试，我们可以定义一个最小传输时间，以此可以制定一个改进的同步时钟时间(减少同步误差)。
在这里，通过高度自信地定义最小传输时间，我们可以说服务器时间将
始终在T_0 + T_{min}之后生成，而T_{SERVER}将始终在T_1 - T_{min}之前生成，其中T_{min}，最小传输时间是几次迭代T_{REQUEST}中的最小值，。同步错误可以表述为：

  \[ error\, \epsilon\, [-((T_1 - T_0)/2 - T_{min}), \, ((T_1 - T_0)/2 - T_{min})] \]

同样，如果T_{REQUEST}和T_{RESPONSE}相差很大的时间，我们可以用T_{min}减去T_{min1}和T_{min2}，其中T_{min1}是最小观察到的请求时间，T_{min2}是指网络上观察到的最小响应时间。

在这种情况下，同步时钟时间可以计算为：

   \[ T_{CLIENT} = T_{SERVER} + (T_1 - T_0)/2 + (T_{min2} - T_{min1})/2 \]

因此，通过仅将响应时间和请求时间引入为单独的时间延迟，我们可以改善时钟时间的同步性，从而降低总体同步误差。要运行的迭代测试的数量取决于观察到的整体时钟漂移。