Khái niệm xử lý đồng thời

Xử lý đồng thời (Concurrency) là khả năng của hệ thống trong việc xử lý nhiều tác vụ cùng một khoảng thời gian. Các tác vụ này có thể thực thi luân phiên (trong trường hợp CPU đơn lõi) hoặc thực thi song song (khi sử dụng nhiều lõi CPU). Khái niệm này không nhấn mạnh vào việc "thực thi cùng lúc tuyệt đối" mà tập trung vào sự chồng chéo về mặt logic giữa các tác vụ và cạnh tranh tài nguyên.

Các khái niệm cốt lõi‌

Tính chồng chéo của tác vụ‌
Nhiều tác vụ tiến triển xen kẽ hoặc đồng thời trong khoảng thời gian, chẳng hạn như:

Máy chủ Web‌ xử lý đồng thời nhiều yêu cầu từ người dùng.
Cơ sở dữ liệu‌ xử lý nhiều truy vấn và giao dịch cùng lúc.
Ứng dụng di động‌ vừa tải file vừa cập nhật giao diện người dùng.

Cạnh tranh tài nguyên‌
Nhiều tác vụ chia sẻ tài nguyên (CPU, bộ nhớ, file, bản ghi cơ sở dữ liệu...) và cần được điều phối truy cập để tránh xung đột.

Phân biệt với xử lý song song‌

Xử lý đồng thời (Concurrency)‌: các tác vụ được xử lý trong khoảng thời gian chồng chéo (có thể thực thi luân phiên trên đơn lõi).
Xử lý song song (Parallelism)‌: các tác vụ thực sự được thực thi cùng lúc (phụ thuộc vào đa lõi hoặc đa máy).
Ví dụ: CPU đơn lõi xử lý 100 yêu cầu bằng cách chuyển đổi giữa các luồng → đồng thời; CPU 10 lõi xử lý 10 yêu cầu cùng lúc → song song.
Tại sao cần xử lý đồng thời?‌

Nâng cao hiệu suất‌

Tận dụng tối đa khả năng đa lõi của CPU (như render video, tính toán khoa học).
Tránh tài nguyên nhàn rỗi (ví dụ: trong khi chờ I/O thì thực hiện tác vụ khác).

Cải thiện phản hồi‌

Cho phép hệ thống xử lý đồng thời nhiều thao tác của người dùng (như giao diện không bị đơ).

Đáp ứng tải cao‌

Hỗ trợ khối lượng lớn yêu cầu (như flash sale thương mại điện tử, sự kiện hot trên mạng xã hội).
Thách thức khi sử dụng xử lý đồng thời‌

Điều kiện tranh chấp (Race Condition)‌
Thứ tự thao tác trên tài nguyên chia sẻ của nhiều tác vụ không xác định, dẫn đến kết quả sai lệch.
Ví dụ: hai luồng cùng sửa số dư tài khoản, có thể mất cập nhật.

Deadlock (Kẹt deadlock)‌
Các tác vụ chờ nhau giải phóng tài nguyên, gây ra tắc nghẽn vĩnh viễn.
Ví dụ: luồng A giữ khóa X chờ khóa Y, luồng B giữ khóa Y chờ khóa X.

Resource Starvation (Thiếu hụt tài nguyên)‌
Một số tác vụ không thể giành được tài nguyên trong thời gian dài (như luồng ưu tiên thấp không bao giờ được CPU).

Dữ liệu không nhất quán‌
Một số tác vụ đọc được dữ liệu ở trạng thái trung gian không hợp lệ.

Các cách triển khai xử lý đồng thời‌
1. ‌Đa luồng (Multi-threading)‌
Tạo nhiều luồng trong một tiến trình, chia sẻ khônggian bộ nhớ.
Phù hợp: tác vụ tính toán nặng (như xử lý ảnh).
Công cụ: Thread, ThreadPool, Parallel.For trong C#.
2. ‌Đa tiến trình (Multi-processing)‌
Nhiều tiến trình độc lập phối hợp qua IPC (giao tiếp giữa các tiến trình).
Phù hợp: tác vụ cần cách ly (như nhiều tab trình duyệt).
Công cụ: Lớp Process trong .NET.
3. ‌Lập trình bất đồng bộ (Async/Await)‌
Trong một luồng đơn, xử lý nhiều yêu cầu đồng thời qua I/O không chặn.
Phù hợp: tác vụ I/O nặng (như yêu cầu Web API).
Công cụ: async/await, Task trong C#.
4. ‌Hệ thống phân tán‌
Nhiều máy phối hợp xử lý tác vụ (như kiến trúc microservices).
Thách thức: độ trễ mạng, nhất quán dữ liệu.
Công cụ: gRPC, hàng đợi tin nhắn (RabbitMQ, Kafka).
Kỹ thuật kiểm soát đồng thời‌

Khóa (Lock)‌

Ép buộc truy cập độc quyền tài nguyên (như từ khóa lock, Mutex).
Nhược điểm: có thể gây deadlock hoặc giảm hiệu suất.

Thao tác nguyên tử (Atomic Operations)‌

Đảm bảo thao tác không thể chia nhỏ (như Interlocked.Increment).
Phù hợp: tăng giảm giá trị đơn giản.

Semaphore (Semaphore)‌

Kiểm soát số lượng tác vụ truy cập tài nguyên đồng thời (như giới hạn tải).
Công cụ: SemaphoreSlim.

Lập trình không khóa (Lock-Free)‌

Thông qua CAS (Compare-And-Swap) để đạt hiệu suất cao.
Phù hợp: bộ đếm tần suất cao, hàng đợi.

Giao dịch (Transaction)‌

Nhóm nhiều thao tác thành đơn vị nguyên tử trong cơ sở dữ liệu (đặc tính ACID).
Công cụ: SaveChanges của EF Core + mức cách ly giao dịch.
Ví dụ tình huống thực tế‌
Flash sale thương mại điện tử
Vấn đề‌: 10.000 người dùng đồng thời cạnh tranh 100 sản phẩm.
Kiểm soát đồng thời‌:
Sử dụng khóa phân tán Redis để giảm库存.
Xử lý đơn hàng qua hàng đợi tin nhắn.
Giới hạn tải phía client (như trang chờ).
Hệ thống chat thời gian thực
Vấn đề‌: Nhiều người dùng gửi tin nhắn đồng thời.
Kiểm soát đồng thời‌:
Xử lý bất đồng bộ việc đẩy tin nhắn (như thư viện SignalR).
Sử dụng collection an toàn luồng (ConcurrentDictionary) quản lý người dùng online.
Tóm tắt‌

Xử lý đồng thời là công nghệ cốt lõi để ‌sử dụng hiệu quả tài nguyên‌ và ‌xử lý logic phức tạp‌, nhưng cần thận trọng với các thách thức nó mang lại. Nguyên tắc quan trọng:

Giảm trạng thái chia sẻ‌ → tránh điều kiện tranh chấp.
Chọn mức độ khóa hợp lý‌ → cân bằng hiệu suất và an toàn.
Ưu tiên sử dụng abstraction cấp cao‌ → như ConcurrentBag, Channel, async/await.
Sử dụng công cụ giám sát‌ → dùng profiler phát hiện deadlock hoặc rò rỉ tài nguyên.

Lập trình không khóa trong .NET Core

Trong .NET Core, ‌lập trình không khóa (Lock-Free Programming)‌ là phương thức kiểm soát đồng thời an toàn luồng thông qua các kỹ thuật như thao tác nguyên tử và rào chắn bộ nhớ, ‌tránh tải trọng của khóa tường minh‌ (như lock, Mutex), phù hợp với tình huống tần suất cao, độ trễ thấp. Dưới đây là các cách triển khai chính và ví dụ thực hành:

I. Nguyên tắc cốt lõi của lập trình không khóa‌
Tính nguyên tử (Atomicity)‌
Đảm bảo thao tác không thể chia nhỏ (như các phương thức của lớp Interlocked).
Tính hiển thị (Visibility)‌
Thông qua rào chắn bộ nhớ (như lớp Volatile) đảm bảo thay đổi dữ liệu được các luồng khác nhìn thấy ngay lập tức.
Tính thứ tự (Ordering)‌
Tránh lỗi logic do sắp xếp lại lệnh (được đảm bảo ngầm bởi thao tác nguyên tử).
II. Công cụ không khóa trong .NET Core‌
1. ‌Lớp Interlocked‌

Cung cấp thao tác nguyên tử (như tăng/giảm, so sánh hoán đổi), phù hợp với cập nhật giá trị đơn giản.

csharp
Copy Code
// Bộ đếm an toàn luồng
private long _counter = 0;

public void TangGiaTri()
{
    Interlocked.Increment(ref _counter);  // Tăng nguyên tử +1
}

public long DocGiaTri()
{
    return Volatile.Read(ref _counter);   // Đảm bảo đọc giá trị mới nhất
}

2. ‌Lớp Volatile‌

Đảm bảo trường được đọc/ghi không bị compiler hoặc CPU sắp xếp lại.

csharp
Copy Code
private bool _coSan = false;
private int _duLieu;

// Luồng A
void NhaSanXuat()
{
    _duLieu = 42;
    Volatile.Write(ref _coSan, true);  // Ghi _coSan sau khi _duLieu đã được cập nhật
}

// Luồng B
void NguoiTieuThu()
{
    if (Volatile.Read(ref _coSan))     // Đọc giá trị _coSan mới nhất
    {
        Console.WriteLine(_duLieu);    // Đảm bảo thấy _duLieu=42
    }
}

3. ‌System.Threading.Channels‌

Hàng đợi producer-consumer không khóa hiệu suất cao (dựa trên ConcurrentQueue được tối ưu).

csharp
Copy Code
var kenh = Channel.CreateUnbounded<int>();

// Producer
async Task SanXuatAsync()
{
    for (int i = 0; i < 100; i++)
    {
        await kenh.Writer.WriteAsync(i);  // Ghi không khóa
    }
    kenh.Writer.Complete();
}

// Consumer
async Task TieuThuAsync()
{
    await foreach (var item in kenh.Reader.ReadAllAsync())
    {
        Console.WriteLine(item);  // Đọc không khóa
    }
}

4. ‌Các lớp Collection trong Concurrent‌

Collection an toàn luồng (bên trong sử dụng không khóa hoặc khóa mịn).

csharp
Copy Code
var hangDoi = new ConcurrentQueue<int>();

// Nhiều luồng đồng thời thêm vào hàng đợi
Parallel.For(0, 1000, i =>
{
    hangDoi.Enqueue(i);  // Không khóa hoặc cạnh tranh khóa thấp
});

5. ‌Các lớp Collection bất biến (Immutable)‌

Thông qua tính bất biến để đạt được đọc không khóa, thao tác ghi tạo bản sao mới.

csharp
Copy Code
var danhSachBatBien = ImmutableList<int>.Empty;

// Đọc an toàn luồng
if (danhSachBatBien.Count > 0)
{
    Console.WriteLine(danhSachBatBien);
}

// Thao tác ghi tạo instance mới (tham chiếu cũ vẫn dùng được)
var danhSachMoi = danhSachBatBien.Add(42);

III. Tình huống sử dụng lập trình không khóa‌
Tình huống    Chọn kỹ thuật    Lợi thế
Bộ đếm tần suất cao    Interlocked    Không cạnh tranh khóa, độ trễ cực thấp
Hàng đợi producer-consumer    System.Threading.Channels    Buffer không khóa, throughput cao
Đọc cấu hình/chia sẻ trạng thái    ImmutableDictionary    Đọc không khóa, thao tác ghi không ảnh hưởng đọc
Điều phối tác vụ    ConcurrentQueue + SpinWait    Giảm tắc nghẽn luồng
IV. Lưu ý khi lập trình không khóa‌
1. ‌Vấn đề ABA‌
Hiện tượng‌: Luồng đọc giá trị A → luồng khác sửa thành B rồi quay lại A → luồng hiện tại cho rằng không thay đổi.
Giải pháp‌: Sử dụng thao tác nguyên tử có số phiên bản (như Interlocked.CombineExchange kết hợp số phiên bản).
csharp
Copy Code
private (int GiaTri, int PhienBan) _duLieu;

public void CapNhat(int giaTriMoi)
{
    int phienBanCu;
    int giaTriCu;
    do
    {
        giaTriCu = Volatile.Read(ref _duLieu.GiaTri);
        phienBanCu = Volatile.Read(ref _duLieu.PhienBan);
    } while (Interlocked.CompareExchange(
        ref _duLieu, 
        (giaTriMoi, phienBanCu + 1), 
        (giaTriCu, phienBanCu)) != (giaTriCu, phienBanCu));
}

2. ‌Chờ quay (SpinWait)‌

Thay thế blocking trong thời gian chờ cực ngắn, giảm tải chuyển đổi context.

csharp
Copy Code
private int _coTheVao = 0;

public void VaoKhuVuc()
{
    var doiCho = new SpinWait();
    while (Interlocked.CompareExchange(ref _coTheVao, 1, 0) != 0)
    {
        doiCho.SpinOnce();  // Chờ quay, nhường CPU hợp lý
    }
}

public void ThoatKhuVuc()
{
    Volatile.Write(ref _coTheVao, 0);  // Đảm bảo giải phóng ngay lập tức
}

3. ‌Rào chắn bộ nhớ (Memory Barrier)‌

Kiểm soát rõ ràng thứ tự lệnh, tránh lỗi logic do thực thi không đúng thứ tự.

csharp
Copy Code
private int _duLieu;
private bool _sanSang;

// Luồng A
void KhoiTao()
{
    _duLieu = 42;
    Thread.MemoryBarrier();  // Đảm bảo _duLieu được ghi trước _sanSang
    _sanSang = true;
}

// Luồng B
void InRa()
{
    if (_sanSang)
    {
        Thread.MemoryBarrier();  // Đảm bảo đọc _duLieu mới nhất
        Console.WriteLine(_duLieu);
    }
}

V. So sánh hiệu suất (khóa vs không khóa)‌

Lấy ví dụ bộ đếm, kiểm tra 10 triệu thao tác tăng:

Phương pháp    Thời gian (ms)    Sử dụng CPU    Phù hợp
lock    1200    Cao    Thao tác phức tạp, tần suất thấp
Interlocked    85    Thấp    Thao tác đơn giản, tần suất cao
ConcurrentQueue    200    Trung bình    Mô hình producer-consumer
VI. Tóm tắt‌
Ưu tiên chọn không khóa cho: bộ đếm tần suất cao, dữ liệu chia sẻ chỉ đọc, buffer hàng đợi.
Tránh lạm dụng không khóa: logic phức tạp nên dùng lock hoặc Monitor để đảm bảo đúng đắn.
Công cụ chính‌:
Thao tác nguyên tử đơn giản → Interlocked
Hàng đợi/buffer → System.Threading.Channels
Dữ liệu chia sẻ chỉ đọc → Collection Immutable
Chờ quay → SpinWait

Thông qua việc chọn công nghệ không khóa phù hợp, có thể cải thiện đáng kể hiệu suất và throughput trong tình huống đồng thời cao.

Vấn đề đồng thời là khi trong cùng một phạm vi mã xuất hiện thao tác Truy vấn → Sửa đổi với nhiều luồng gọi đồng thời, cuối cùng dẫn đến tình trạng dữ liệu không nhất quán, đúng không?

Đúng như vậy. Vấn đề đồng thời có thể xảy ra trong thao tác "truy vấn→sửa đổi" trong phạm vi mã, cụ thể biểu hiện là: ‌nhiều luồng đọc cùng một dữ liệu, sửa đổi dựa trên giá trị cũ rồi gửi, dẫn đến dữ liệu cuối cùng không nhất quán hoặc bị ghi đè‌. Phân tích chi tiết và ví dụ dưới đây:

I. Nguyên nhân cốt lõi của vấn đề đồng thời
1. ‌Thao tác không nguyên tử‌
Quy trình "truy vấn→sửa đổi→lưu" trong mã nếu không khóa hoặc đồng bộ toàn bộ, sẽ bị luồng khác gián đoạn, tạo thành thao tác không nguyên tử.
Ví dụ:
LuồngA truy vấn Score=80 → sửa thành 85 → ‌chưa gửi‌, luồngB truy vấn Score=80 → sửa thành 90 → luồngB gửi → luồngA gửi.
Kết quả cuối cùng bị ghi đè thành 85 hoặc 90 (tùy thứ tự gửi), thay vì giá trị cộng dồn mong đợi.
2. ‌Tài nguyên chia sẻ không được bảo vệ‌
Bản ghi cơ sở dữ liệu là tài nguyên chia sẻ, không được cách ly truy cập đồng thời qua khóa, số phiên bản...
II. Tình huống điển hình và biểu hiện không nhất quán dữ liệu
Tình huống    Hiện tượng vấn đề    Nguyên nhân gốc
Giảm库存    Bán quá số lượng (giảm库存thành giá trị âm)    Nhiều luồng dựa vào giá trị cũ để giảm
Cập nhật số dư tài khoản    Số dư không cộng đúng (như trừ thiếu tiền)    Cùng đọc số dư cũ rồi sửa đổi riêng
Tăng bộ đếm    Số đếm cuối cùng nhỏ hơn số lần gọi thực tế    count++ không phải thao tác nguyên tử
III. Giải pháp
1. ‌Khóa lạc quan (Cơ chế số phiên bản)‌
Cách triển khai‌:
Thêm trường Version trong bảng cơ sở dữ liệu, khi cập nhật kiểm tra số phiên bản có thay đổi không.
csharp
Copy Code
// Lớp entity
public class HocSinh {
    public int Id { get; set; }
    public int Diem { get; set; }
    [ConcurrencyCheck]
    public byte[] PhienBan { get; set; }
}

csharp
Copy Code
// Khi cập nhật tự động kiểm tra phiên bản
var hocSinh = context.HocSinh.Find(1);
hocSinh.Diem += 10;
try {
    context.SaveChanges(); // Nếu phiên bản không khớp, ném ngoại lệ DbUpdateConcurrencyException
} catch (DbUpdateConcurrencyException) {
    // Xử lý xung đột (như thử lại hoặc thông báo người dùng)
}

Ưu điểm‌: Không cạnh tranh khóa, phù hợp với tình huống đọc tần suất cao.
2. ‌Thao tác nguyên tử (Tránh truy vấn rồi cập nhật)‌
Cập nhật trực tiếp qua SQL‌, loại bỏ cửa sổ đồng thời:
csharp
Copy Code
context.HocSinh
    .Where(h => h.Id == 1)
    .ExecuteUpdate(h => h.SetProperty(x => x.Diem, x => x.Diem + 10));

Phù hợp: tăng giảm giá trị đơn giản, cập nhật trạng thái.
3. ‌Khóa bi quan (Ép tuần tự hóa)‌
Khóa dòng cơ sở dữ liệu (như UPDLOCK của SQL Server):
csharp
Copy Code
using (var giaoDich = context.Database.BeginTransaction()) {
    var hocSinh = context.HocSinh
        .FromSqlRaw("SELECT * FROM HocSinh WITH (UPDLOCK) WHERE Id = 1")
        .First();
    hocSinh.Diem += 10;
    context.SaveChanges();
    giaoDich.Commit();
}

Nhược điểm‌: Hiệu suất thấp, có thể gây deadlock.
IV. Gợi ý chiến lược chọn lựa
Giải pháp    Phù hợp    Hiệu suất    Độ phức tạp triển khai
Khóa lạc quan    Đọc tần cao, cho phép thử lại (như thương mại điện tử)    Cao    Trung bình
Thao tác nguyên tử    Tăng giảm giá trị đơn giản (như giảm库存)    Rất cao    Thấp
Khóa bi quan    Yêu cầu nhất quán mạnh (như giao dịch tài chính)    Thấp    Cao
V. Tóm tắt‌
Bản chất vấn đề đồng thời‌: Nhiều luồng thao tác tài nguyên chia sẻ không được bảo vệ, dẫn đến trạng thái dữ liệu không kiểm soát được.
Phương thức phòng thủ quan trọng‌:
Giảm trạng thái chia sẻ‌: Ưu tiên dịch vụ không trạng thái hoặc biến cục bộ.
Thao tác nguyên tử hóa‌: Gộp "truy vấn→sửa đổi" thành một bước (như ExecuteUpdate).
Phát hiện và khôi phục xung đột‌: Xử lý ngoại lệ thông qua số phiên bản, chiến lược thử lại.