如何编写一个没有可变状态的多客户端服务器？

Question

我正在研究函数式编程，并在解决一个问题。在没有可变状态的情况下，我该如何执行以下操作？

想象一下我有一个服务器..并且客户端尝试连接..每个客户端给服务器一个数字并被告知当前总数。

现在，如果没有可变状态，服务器就无法保留总数...所以我认为每个客户端实际上是在创建一个包含新总数的新服务器...或者一个保存条目并引用旧服务器的新服务器，以便总数可以是计算出来的。

但是..客户端如何找到服务器？有人必须保留当前的服务器实例..因此他们有一个可变变量“服务器”。

无论我做什么..我总是会得到一个更高范围的可变变量。

想法？

Answer 1

您描述的场景可以这样实现（伪代码）：

let keepTrackOfTotal(total) =
    let conn = waitForConnection()
    let x = readIntFrom(conn)
    let newTotal = total + x
    writeIntTo(conn, newTotal)
    keepTrackOfTotal(newTotal)

let main() = keepTrackOfTotal(0)

这里我们使用递归来获得一个无限循环来跟踪总数，而无需可变变量。

Answer 2

至少在 Erlang 中，它的完成方式是进程本身有一个名称。

因此，虽然服务器循环不断启动自身的新版本（通过在调用结束时调用相同的函数，如 sepp2k 的优秀伪代码）并将总和作为参数提供，但所有客户端都通过名称联系该进程，所以他们仍然可以找到它。

Answer 3

像这样（在 C++ 上）。
我们有静态指针服务器，服务器对象的每个实例都是不可变的，

#include <pthread.h>
#include <iostream>
#include <stdlib.h>
#include <memory>

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;

class Server
{
public:
    Server(int n) : m_n(n){}
    static void Add(int n)
    {        
        pthread_mutex_lock( &mutex1 );
        std::auto_ptr<const Server> srv(getInstance());
        server = new Server(srv->m_n + n);
        pthread_mutex_unlock( &mutex1 );
    }
    static int GetTotal()
    {
        std::auto_ptr<const Server> srv(getInstance());
        return srv->m_n;
    }

private:

    static const Server* getInstance()
    {
        if (server == NULL)
            server = new Server(0);

        return new Server(server->m_n);
    }
    static volatile const Server* server;
    int const m_n;
};
volatile const Server* Server::server = NULL;

每次调用 getInstance() 都会返回不可变的服务器对象。
当另一个线程在 Add 方法中工作时，您可以调用 GetTotal() 方法。