How to implement in erlang - erlang

Question

I was thinking of using a list to store elements(files)
How do i change the code below so that it would lock one process(user) from accessing one file(element in list), while allowing another process(user) to access the file.
-module(bank).
-export([account/1, start/0, stop/0, deposit/1, get_bal/0, set_bal/1]).
account(Balance) ->
receive
{set, NewBalance} ->
account(NewBalance);
{get, From} ->
From ! {balance, Balance},
account(Balance);
stop -> ok
end.
start() ->
Account_PID = spawn(bank, account, [0]),
register(account_process, Account_PID).
stop() ->
account_process ! stop,
unregister(account_process).
set_bal(B) ->
account_process ! {set, B}.
get_bal() ->
account_process ! {get, self()},
receive
{balance, B} -> B
end.
deposit(Amount) ->
OldBalance = get_bal(),
NewBalance = OldBalance + Amount,
set_bal(NewBalance).
and
-module(banktest).
-export([start/0, client/1]).
start() ->
bank:start(),
mutex:start(),
register(tester_process, self()),
loop(10, 20, 100),
unregister(tester_process),
mutex:stop(),
bank:stop().
loop(_, _, 0) ->
true;
loop(Amount1, Amount2, N) ->
bank:set_bal(0),
spawn(banktest, client, [Amount1]),
spawn(banktest, client, [Amount2]),
receive
done -> true
end,
receive
done -> true
end,
io:format("Expected balance = ~B, actual balance = ~B~n~n",
[Amount1 + Amount2, bank:get_bal()]),
loop(Amount1, Amount2, N-1).
client(Amount) ->
bank:deposit(Amount),
tester_process ! done.

Answer 1

If you want to serialize write calls but allow read ones, you can change the code as follow:
account(Balance, WriteLocker) ->
receive
free_lock ->
account(Balance, undefined),
{set, NewBalance, Caller} when WriteLocker =:= undefined ->
Caller ! done,
account(NewBalance, Caller),
{get, From} ->
From ! {balance, Balance},
account(Balance, WriteLocker);
stop -> ok
end.
wait() ->
receive
{done, WriteLock} -> WriteLock ! free_lock.
end.
set_bal(B) ->
account_process ! {set, B, self()},
wait().
If you want to lock reader too, add the guard to {get, From} message too.

Answer 2

OK, still not quite understand the question but I will try to clarify and then propose a solution based on that:
You want to manage access to a set of files rather than a bank account
You want one user to have a write access to a file while other uses still have a read access to that file
If that's what you want then you can simply treat each file similarly to a bank account. It means that you should start one process (analogous to the code in the bank module) per file. In other words:
for 1 bank account you need 1 process
for 3 bank accounts you need 3 processes
for 10 files you need 10 processes
Implementation details would depend on how you plan to manage the files on the server, but in the simplistic scenario the process could work analogously to the existing code:
file(FileName) ->
receive
{write, From, Data} ->
ok = file:write_file(FileName, Data),
From ! ok,
file(FileName);
{read, From} ->
{ok, Data} = file:read_file(FileName),
From ! Data,
file(FileName);
stop -> ok
end.
start() ->
File_PID = spawn(file, file, ["somefile.txt"]),
register(file_process, File_PID).