DEV Community: Toan Ha

Concurrent Programming với Elixir

Toan Ha — Sat, 21 Aug 2021 07:10:31 +0000

Mục đích bài viết này để

Giới thiệu về phương pháp lập trình bất đồng bộ với cách tiếp cận khác những ngôn ngữ như Java hoặc C#.
Những bước đầu tiên để viết 1 chương trình chạy bất đồng bộ bằng Elixir
Hi vọng sẽ lôi kéo được thêm người học Elixir :)

1. Concurrent Programming

Concurrent Programming hiểu đơn giản là việc lập trình cho phần mềm có thể chia nhỏ tác vụ và chạy đồng thời, độc lập với nhau. Elixir là ngôn ngữ lập trình được viết dựa trên nền tảng ngôn ngữ erlang - ngôn ngữ giải quyết bài toán concurrent trên rất tốt.

Nếu trong Java hay C# việc lập trình bất đồng bộ bạn sẽ sữ dụng những phương pháp như Locking, Thread pool, mutex hay là semaphore... thì ở Elixir sẽ cài đặt trên mô hình Actor model (1).

Actor là một đơn vị chính của mô hình Actor model và đảm nhận mọi thao tác tính toán trong mô hình này. Các đặc điểm chính của actors bao gồm:

message passing - các actor trao đổi với nhau bằng cách gửi message vào mailbox của nhau. Bạn muốn bảo một actor làm gì cho bạn: gửi message cho nó. Bạn muốn giết một actor: gửi message cho nó. Bạn muốn truy cập thông tin một actor: gửi message cho nó rồi check mailbox.
never share memory - mỗi actor có một state riêng mà không có actor nào có thể truy cập hay thay đổi được.
there are many actors - Actor là thứ sống theo bầy đàn. Trong mô hình này, tất cả đều là actor hoặc không có một actor nào cả. Đồng thời actor được định danh (giống như bạn được cha mẹ bạn cấp cho cái tên), tui sẽ nói rõ hơn về cái này trong phần tiếp theo.
asynchronous - mọi message đều là bất đồng bộ, tức là lúc bạn bấm gửi và lúc nào nó tới là hai chuyện khác nhau.

Khi nhận được một message, actor sẽ phải băn khoăn với 3 lựa chọn:

Xử lý thông tin và update state của nó.
Tạo thêm các actor khác.
Gửi message cho một actor khác.

Đoạn này là copy trên Blog Quần Cam vì ảnh giải thích khá dễ hiểu về mô hình này, đọc thêm tại đây

Có 1 tính chất trong elixir đó chính là Immutability mình xin tạm dịch là tính bất biến. Hãy cùng xem đoạn code dưới đây:

array = [1, 2, 3]
square(array)
print(array)

Giả sử hàm square sẽ bình phương giá trị từng phần tử trong mảng array. Bạn mong đợi kết quả trả về là [1, 4, 9]. Nhưng trong elixir kết quả sẽ trả về là [1, 2, 3] trừ khi bạn gán lại kết quả cho biến array như code dưới đây

array = [ 1, 2, 3 ]
array = square(array)
print(array)

Tính chất này giúp cho việc lập trình bất đồng bộ đơn giản hơn rất nhiều vì bạn không cần phải lo giá trị của 1 biến bị thay đổi bởi 1 process khác. Đây là 1 tính chất khá thú vị ở Elixir. Nhưng cái gì cũng sẽ có 2 mặt tốt và chưa tốt.
Bạn có thể tìm đọc thêm ở (2).

2. Làm quen với Concurrent Programming trong elixir

Nói 1 chút về process trong elixir. Process trong elixir khác với process chạy trên máy tính của bạn, nó chạy bên trong máy ảo erlang VM được quản lý trong ứng dụng của bạn. Trung bình 1 node trên chạy trên máy ảo erlang có thể tạo được 134 triệu processes con. Con số khá ấn tượng nhỉ :)

Việc khởi tạo 1 process trong elixir cũng rất đơn giản. Cùng xem ví dụ dưới đây:

# Đoạn code này định nghĩa 1 module trong elixir và code 1 hàm là greet in ra màn
# hình là "Hello"
defmodule SpawnBasic do
  def greet do
    IO.puts "Hello"
  end
end

# Đây là cách gọi hàm thông thường
SpawnBasic.greet
Hello
:ok

# Còn đây là cách để chạy hàm trên trong 1 process
spawn(SpawnBasic, :greet, [])
Hello
#PID<0.42.0>

Kết quả trả về của hàm spawn là 1 địa chỉ tới process vừa khởi tạo. Tiếp theo chúng ta sẽ đến phần giao tiếp giữa các process với nhau thế nào.

Trong elixir có 2 hàm là send dùng để gửi message tới 1 process và hàm receive để nhận 1 message từ 1 process khác gọi sang. Thay đổi 1 chút đoạn code trên.

defmodule Spawn do
  def greet do
    # Hàm này sẽ giúp nhận đối số từ bên ngoài
    receive do
      # sender là process gọi tới hàm này và msg là tin nhắn được gửi sang
      {sender, msg} ->
        # Dùng hàm send để gửi lại cho sender kết quả (*)
        send sender, { :ok, "Hello, #{msg}" }
    end
  end
end

# Khởi tạo process
pid = spawn(Spawn, :greet, [])
# Gửi tin nhắn tới process đó
send pid, {self, "World!"}
# Lắng nghe kết quả trả về
receive do
  # Chổ này sẽ match với giá trị trả về của hàm greet bên trên (*)
  {:ok, message} ->
    IO.puts message
end

Output:
> Hello, World!

Đoạn code trên nếu ta tiếp tục gọi thêm 1 message nữa

...
send pid, {self, "Ahihi!"}
receive do
  {:ok, message} ->
    IO.puts message
end

Output:
> Hello, World!
...stop...

Chương trình bị dừng thay vì tiếp tục trả về message là Hello, Ahihi!. Do sau khi hàm greet nhận được message thì đã gọi gửi trở lại cho main process và exit khỏi chương trình.

Giải thích chỗ này 1 chút đó là function trong elixir sẽ trả về kết quả ở dòng cuối cùng của thân hàm. Trong đoạn code trên hàm greet sẽ trả về pid là kết quả trả về của lời gọi hàm send

Vậy làm sao để nhận được kết quả mong muốn là Hello, Ahihi! ở lần send message thứ 2?

Chúng ta sẽ thay đổi hàm greet để trả về lời gọi hàm chính nó để khi send tiếp tục lắng nghe tin nhắn từ main process

def greet do
  receive do
    {sender, msg} ->
      send sender, { :ok, "Hello, #{msg}" }
      greet
  end
end

Output:
> Hello, World!
> Hello, Ahihi!

Đoạn code này trong giống đệ quy phải không?

Đúng rồi, đây là đệ quy trong elixir

Nếu trong những ngôn ngữ khác như Java thì khi gọi đệ quy tức là bạn push 1 frame vào stack và nếu bị gọi với số lượng lớn nó sẽ bị out of memory. Vấn đề này được giải quyết bằng kĩ thuật tail-call optimization có thể hiểu là nếu như hàm trả về chính nó thì chương trình chỉ đơn giản là nhảy về điểm bắt đầu của chương trình.

Đây là 1 bài toán tìm số factorial thứ n được viết bằng đệ quy

def factorial(0), do: 1
def factorial(n), do: n * factorial(n-1)

Với n = 3 chương trình sẽ chạy như sau
3 * factorial(3-1)
3 * 2 * factorial(2-1)
3 * 2 * 1 * factorial(1-1)
3 * 2 * 1 * 1
6

Nhưng đây không phải là tail-call optimization bởi vì kết quả trả về của hàm thứ 2 không trả về chính nó mà trả về kết quả của 1 phép nhân. Thay đổi 1 chút như bên dưới

def factorial(n), do: _fact(n, 1)
defp _fact(0, acc), do: acc
defp _fact(n, acc), do: _fact(n-1, acc*n)

Với n = 3
_fact(3-2, 1*3) => _fact(2, 3)
_fact(2-1, 3*2) => _fact(1, 6)
_fact(1-1, 6*1) => _fact(0, 6)
6

Chương trình này sẽ dùng biến acc để tracking lại giá trị của số trước nó, và chương trình sẽ chạy lùi từ n về 0. Nhưng như đã nói, mọi thứ đều có 2 mặt tốt và chưa tốt. Để hiểu thêm bạn có thể tham khảo ở (3)

Nhưng nếu mình muốn mọi thứ đồng bộ nhưng vẫn chạy thành nhiều process có được không?

Được, cùng xem ví dụ dưới đây

defmodule Demo1 do
  def say do
    receive do
      n ->
        IO.inspect(n)
    end
  end
end

nums = 1..10

Enum.each(nums, fn i ->
  pid = spawn(Demo1, :say, [])
  send(pid, i)
end)

defmodule Demo2 do
  def say(pid) do
    receive do
      n ->
        send(pid, n)
    end
  end
end

Enum.each(nums, fn i ->
  pid = spawn(Demo2, :say, [self])
  send(pid, i)

  receive do
    n ->
      IO.inspect(n)
  end
end)

Output:
# Demo1 cách này sẽ giúp bạn khởi tạo và chạy các process mà không quan tâm giá trị trả về có đúng thứ tự không
1
3
2
7
4
10
8
6
5
9

# Demo2 sẽ đảm bảo kết quả trả về đúng thứ tự
1
2
3
4
5
6
7
8
9
10

Trong elixir có 1 hàm giúp ta link được 2 process với nhau đó là hàm spawn_link

defmodule Demo do
  import :timer, only: [sleep: 1]

  def die_soon do
    sleep(500)
    exit(:dead)
  end

  def run do
    # Process.flag(:trap_exit, true)
    spawn_link(Demo, :die_soon, [])

    receive do
      msg ->
        IO.puts("Message: #{inspect(msg)}")
    after
      1000 ->
        IO.puts("I'm still alive")
    end
  end
end

Demo.run()

Output:
** (EXIT from #PID<0.73.0>) :dead

Chương trình trên bị dừng khi process con bị chết, nó sẽ ảnh hưởng tới thằng cha làm chết theo. Để process cha không chết ta bỏ comment chỗ Process.flag(:trap_exit, true) lúc này chương trình không bị dừng mà output ra là

Message: {:EXIT, #PID<0.78.0>, :dead}

3. Kết

Hi vọng các bạn có một góc nhìn khác, một hướng tiếp cận khác về lập trình đa luồng và quan trọng nhất là sẽ có bạn tìm hiểu thử về Elixir sau khi đọc xong bài viết này. Nếu bạn có bất cứ thắc mắc hay câu hỏi nào thì vui lòng comment vào bên dưới bài viết. Mình sẽ cố gắng trả lời các câu hỏi nếu trong phạm vi hiểu biết :)

Đọc thêm:

Ref: Elixir book

Phân biệt các từ khóa use, alias, require và import

Toan Ha — Sat, 21 Aug 2021 07:09:53 +0000

Khi mới tiếp cận với Elixir các bạn có thể sẽ phân vân điểm khác nhau giữa các từ khoá trên. Bài viết này so sánh các từ khoá đó thông qua cách sử dụng

1. import

Hiểu đơn giản nó sẽ bê toàn bộ functions và macros của module B vô module A để sử dụng. Mình có thể gọi tắt 1 function trong B mà không cần bắt đầu bằng tên module.

defmodule A do
  def say_world() do
    IO.puts("world")
  end

  defmacro if_unless(expr, opts) do
    quote do
      if !unquote(expr), unquote(opts)
    end
  end
end

defmodule B do
  import A

  def say_hello do
    IO.puts("Hello ")
    if_unless false do
      say_world()
    end
  end
end

Có thể sử dụng thêm 2 từ khóa only nếu chỉ muốn lấy 1 số hàm, marco hoặc từ khóa except nếu muốn loại từ hàm hay macro nào đó

import List, only: [flatten: 1]
import String, except: [split: 2]

Import có thể sử dụng bên trong function và có scope chỉ ở trong function đó.

defmodule Math do
    def some_function do
        # 1) Disable "if/2" from Kernel
        import Kernel, except: [if: 2]

        # 2) Require the new "if/2" macro from MyMacros
        import MyMacros

        # 3) Use the new macro
        if do_something, it_works
    end
end

Lưu ý: Các hàm bắt đầu bằng _ sẽ không được import. Ví dụ: (__build__, ...)

2. require

Khi muốn sử dụng marco của 1 module nào đó, bắt buộc phải require module đó trước khi gọi marco

defmodule A do
  def say_world() do
    IO.puts("world")
  end

  defmacro if_unless(expr, opts) do
    quote do
      if !unquote(expr), unquote(opts)
    end
  end
end

defmodule B do
  require A

  def say_hello do
    IO.puts("Hello ")

    A.if_unless false do
      A.say_world()
    end
  end
end

3. alias

Dùng để setup 1 alias name cho 1 module. Mặc định thì alias sẽ lấy phần cuối cùng trong tên module làm tên alias.

defmodule A do
    alias Foo.Bar.Baz

    def funcA do
        Baz.some_func()
    end
end

Có thể sử dụng key as để định nghĩa 1 tên khác.

defmodule A do
    alias Foo.Bar.Baz, as: FBar

    def funcA do
        FBar.some_func()
    end
end

Mình có thể định nghĩa nhiều alias có module tương tự nhau trong cùng 1 hàng

alias Foo.Bar
alias Foo.Baz
alias Foo.Biz

> alias Foo.{Bar, Baz, Biz}

Chú ý: import/2, require/2 và alias/2 có thế định nghĩa trong từng function khác nhau không nhất thiết phải để ngay sau defmodule và nó không ảnh hưởng scope lẫn nhau.

4. use

Thường xài kiểu như abstract, Khi module B use module A, nó sẽ invoke marco __using__ trong module A

defmodule A do
  defmacro __using__(opts) do
    quote do
      IO.puts("Hello ")
    end
  end
end

defmodule B do
  use A, key1: "abc"

  def say_hello do
    IO.puts("World")
  end
end

đoạn code trên tương đương với

defmodule B do
  B.__using__([key1: "abc"])

  def say_hello do
    IO.puts("World")
  end
end

use thường được dùng khi muốn định nghĩa 1 behavior cho 1 module. Ví dụ trong Phoenix Framework. Controller được định nghĩa

defmodule ApiWeb do
...
    def controller do
        quote do
            use Phoenix.Controller, namespace: ApiWeb
            import Plug.Conn
            import ApiWeb.Router.Helpers
            import ApiWeb.Gettext
            require Logger
        end
    end
...
end

defmodule ApiWeb.PageController do
    use ApiWeb, :controller
    ...
end

Lưu ý: Không nên định nghĩa hàm ở trong __using__/1

Kết

Các bạn có thể tham gia vào channel #elixir ở cộng đồng Ruby Việt Nam để thảo luận thêm về các vấn đề khi lập trình với elixir :)