在这两种方法中,我都坚持如何按给定的 id 或组集映射进程,然后将存储的结构映射到过滤数据。
%{group => [users]}
实施。
我意识到组将受到限制,与用户相反,因此我创建了一个使用组名称作为键的流程模块。
恐怕将来几个组中会有很多用户,所以我的问题是我如何拆分当前UserGroupServer
模块以保留许多由组名标识的分离进程?我想在按组列表的初始化进程中保留当前模块的功能,此外我不知道如何映射每个进程以按user_id获取组?
目前,我在凤凰城中只启动了一个进程,lib/myapp.ex
通过在子树列表中包含模块,因此我可以直接在频道中调用UserGroupServer
。
defmodule UserGroupServer do
use GenServer
## Client API
def start_link(opts \ []) do
GenServer.start_link(__MODULE__, :ok, opts)
end
def update_user_groups_state(server, data) do
{groups, user_id} = data
GenServer.call(server, {:clean_groups, user_id}, :infinity)
users = Enum.map(groups, fn(group) ->
GenServer.call(server, {:add_user_group, group, user_id}, :infinity)
end)
Enum.count(Enum.uniq(List.flatten(users)))
end
def get_user_groups(server, user_id) do
GenServer.call(server, {:get_user_groups, user_id})
end
def users_count_in_gorup(server, group) do
GenServer.call(server, {:users_count_in_gorup, group})
end
## Callbacks (Server API)
def init(_) do
{:ok, Map.new}
end
def handle_call({:clean_groups, user_id}, _from, user_group_dict) do
user_group_dict = user_group_dict
|> Enum.map(fn({gr, users}) -> {gr, List.delete(users, user_id)} end)
|> Enum.into(%{})
{:reply, user_group_dict, user_group_dict}
end
def handle_call({:add_user_group, group, user_id}, _from, user_group_dict) do
user_group_dict = if Map.has_key?(user_group_dict, group) do
Map.update!(user_group_dict, group, fn(users) -> [user_id | users] end)
else
Map.put(user_group_dict, group, [user_id])
end
{:reply, Map.fetch(user_group_dict, group), user_group_dict}
end
end
测试:
defmodule MyappUserGroupServerTest do
use ExUnit.Case, async: false
setup do
{:ok, server_pid} = UserGroupServer.start_link
{:ok, server_pid: server_pid}
end
test "add users", context do
c1 = UserGroupServer.update_user_groups_state(context[:server_pid], {[:a, :b, :c], 1})
assert(1 == c1)
c2 = UserGroupServer.update_user_groups_state(context[:server_pid], {[:c, :d], 2})
assert(2 == c2)
c3 = UserGroupServer.update_user_groups_state(context[:server_pid], {[:x], 2})
assert(1 == c3)
c4 = UserGroupServer.update_user_groups_state(context[:server_pid], {[:d], 1})
assert(1 == c4)
c5 = UserGroupServer.update_user_groups_state(context[:server_pid], {[:d, :c], 2})
assert(2 == c5)
end
end
旧方法%{user => [groups]}
监视分配给user_id的商店组列表。如何查找给定组中的用户?让我创建单独的进程来处理 m.。组和用户 ID 之间的关系?我应该更改什么才能获取每个用户组,然后映射它们?
服务器实现:
defmodule Myapp.Monitor do
use GenServer
def create(user_id) do
case GenServer.whereis(ref(user_id)) do
nil -> Myapp.Supervisor.start_child(user_id)
end
end
def start_link(user_id) do
GenServer.start_link(__MODULE__, [], name: ref(user_id))
end
def set_groups(user_pid, groups) do
try_call user_pid, {:set_groups, groups}
end
def handle_call({:set_groups, groups}, _from, state) do
{ :reply, groups, groups } # reset user groups on each set_group call.
end
defp ref(user_id) do
{:global, {:user, user_id}}
end
defp try_call(user_id, call_function) do
case GenServer.whereis(ref(user_id)) do
nil -> {:error, :invalid_user}
user_pid -> GenServer.call(user_pid, call_function)
end
end
end
主管:
defmodule Myapp.Supervisor do
use Supervisor
def start_link do
Supervisor.start_link(__MODULE__, :ok, name: __MODULE__)
end
def start_child(user_id) do
Supervisor.start_child(__MODULE__, [user_id])
end
def init(:ok) do
supervise([worker(Myapp.Monitor, [], restart: :temporary)], strategy: :simple_one_for_one)
end
end
例:
Monitor.create(5)
Monitor.set_groups(5, ['a', 'b', 'c'])
Monitor.create(6)
Monitor.set_groups(6, ['a', 'b'])
Monitor.set_groups(6, ['a', 'c'])
# Monitor.users_in_gorup('a') # -> 2
# Monitor.users_in_gorup('b') # -> 1
# Monitor.users_in_gorup('c') # -> 2
# or eventually more desired:
# Monitor.unique_users_in_groups(['a', 'b', 'c']) # -> 2
# or return in set_groups unique_users_in_groups result
在跳转到流程和gen_servers之前,您始终需要考虑数据结构。
您将如何添加数据?多久一次?你打算如何查询它?多久一次?
在您的示例中,您提到了三个操作:
- 为用户设置组(重置所有以前设置的组)
- 返回组中的所有用户
- 返回组集中的唯一用户
使用Elixir中最基本的类型(列表和地图),您可以通过两种方式排列数据:
- 映射,其中键是用户,值是组列表 (
%{user => [groups]}
) - 或相反(
%{group => [users]}
)
对于这两个实现,您可以评估操作的速度。对于%{user => [groups]}
:
- 为用户设置组
O(1)
(只需更新map中的键) - 返回组
O(n*m)
中的所有用户,其中n
是用户数,m
是组数(对于所有n
用户,您需要通过扫描可能m
组名称来检查它是否在组中) - 组中的唯一身份用户与上述相同 + 排序和重复数据删除
对于使用 %{group => [users]}
实现:
O(n*m)
为用户设置组(如果用户在那里,则需要扫描所有组,将其删除,然后仅为新组设置) 如果设置组仅将用户添加到新组而不先删除它,则只会按输入中的组数(不是所有组)成比例的时间添加用户)- 返回组
O(1)
中的所有用户 - 只需查询地图 - 与查询中的组数成正比 + 排序和重复数据删除
这表明,如果您的监视器快速更新并且查询频率较低,则首次实现会好得多。如果您更新频率较低,则第二个要好得多,但始终查询它。
在没有任何参与者或gen_server的情况下实现其中一个解决方案并且可以判断它有效后,您可能希望将 pid 视为映射键并重写算法。您也可以考虑仅使用一个进程来存储所有数据。这也取决于您的确切问题。祝你好运!