A not-terribly-idiomatic Erlang implementation I slapped together to test this theory, and also to practice on silly problem:

  -module(test).
  -export([run/0]).
  -import(timer).
  
  -define(SEATS, 3).
  -define(DAY, 8*60*60).
  -define(PERIOD, 20*60).
  -define(CUTTIME, 15*60).
  
  barber(Shop, Count) ->
      receive
          {customer, P, N} ->
              Shop ! accept,
              io:format("(B) Cutting hair of customer ~w~n", [N]),
              P ! haircut,
              timer:sleep(?CUTTIME),
              barber(Shop, Count+1);
          endtime ->
              io:format("(B) Closing the shop ~n"),
              Shop ! close,
              barber(Shop, Count);
          closed ->
              io:format("(B) Closed. ~n"),
              io:format("(B) Served ~w customers. ~n", Count)
      end.
  customer(N) ->
      receive
          haircut ->
              io:format("(B) Customer ~w got haircut ~n", [N]);
          leave ->
              io:format("(B) Customer ~w leaving ~n", [N])
    end.
  shop(Seated, Barber) ->
      receive
          accept when Seated == 0 ->
              io:format("Flagrant Error~n");
          accept ->
              shop(Seated-1,Barber);
          close ->
              Barber ! closed;
          endtime ->
              Barber ! endtime,
              shop(Seated, Barber);
          {customer, P, N} when Seated >= ?SEATS ->
              io:format("(S) Incoming customer ~w turned away ~n", [N]),
              P ! leave,
              shop(Seated,Barber);
          {customer, P, N} ->
              io:format("(S) Incoming customer ~w seated ~n", [N]),
              Barber ! {customer, P, N},
              shop(Seated+1,Barber)
      end.
  shop_helper() ->
      receive
          P ->
              shop(0, P)
      end.
  run() ->
      S = spawn(fun() -> shop_helper() end),
      B = spawn(fun() -> barber(S,0) end),
      S ! B,
      make_customers(S, 0, ?DAY).
  make_customers(Shop, _, Time) when Time<0 ->
      Shop ! endtime;
  make_customers(Shop, Id, Time) ->
      Shop ! {customer, spawn(fun() -> customer(Id) end), Id},
      timer:sleep(?PERIOD),
      make_customers(Shop, Id+1, Time-?PERIOD).

This implementation is 68 lines long: twice the Clojure, but still less than the Scala. A big portion of this difference is because the Clojure version cheats, modeling the system as straight-up producer/consumer with queue size constraints. The other two implementations spend about 20 lines dealing with Customer actors, which the Clojure completely punts. The Clojure still wins, but it's not as big a margin as it looks.

Actually 68 is about the same as scala. About 30 of the lines are stylistic: one closing bracket to a line and some blank lines for visual grouping. As well several bits of printed status that the clojure version elides.