Tại sao Interlocked.CompareExchange <T> chỉ hỗ trợ các loại tham chiếu?

Question

Tuyên bố miễn trừ trách nhiệm: Bài đăng của tôi dường như luôn dài dòng. Nếu bạn biết câu trả lời cho câu hỏi tiêu đề, vui lòng chỉ trả lời câu hỏi mà không đọc thảo luận mở rộng của tôi bên dưới.

---

Lớp System.Threading.Interlocked cung cấp một số phương pháp rất hữu ích để hỗ trợ cho việc viết mã thread-safe. Một trong những phương pháp phức tạp hơn là CompareExchange, có thể được sử dụng để tính toán tổng số đang chạy có thể được cập nhật từ nhiều luồng.

Kể từ khi việc sử dụng các CompareExchange là một chút khó khăn, tôi nghĩ rằng nó là một ý tưởng khá phổ biến-tinh thần để cung cấp một số phương pháp helper cho nó:

// code mangled so as not to require horizontal scrolling 
// (on my monitor, anyway) 
public static double Aggregate 
(ref double value, Func<double, double> aggregator) { 
    double initial, aggregated; 

    do { 
     initial = value; 
     aggregated = aggregator(initial); 
    } while (
     initial != Interlocked.CompareExchange(ref value, aggregated, initial) 
    ); 

    return aggregated; 
} 

public static double Increase(ref double value, double amount) { 
    return Aggregate(ref value, delegate(double d) { return d + amount; }); 
} 

public static double Decrease(ref double value, double amount) { 
    return Aggregate(ref value, delegate(double d) { return d - amount; }); 
} 

Bây giờ, có lẽ tôi chỉ có tội là generic-hạnh phúc (Tôi sẽ thừa nhận, điều này thường đúng); nhưng nó cảm thấy ngớ ngẩn với tôi để hạn chế chức năng được cung cấp bởi các phương pháp trên chỉ với giá trị double (hoặc, chính xác hơn, đối với tôi phải viết các phiên bản quá tải của các phương pháp trên cho mọi loại tôi muốn hỗ trợ). Tại sao tôi không thể làm điều này?

// the code mangling continues... 
public static T Aggregate<T> 
(ref T value, Func<T, T> aggregator) where T : IEquatable<T> { 
    T initial, aggregated; 

    do { 
     initial = value; 
     aggregated = aggregator(initial); 
    } while (
     !initial.Equals(
      Interlocked.CompareExchange<T>(ref value, aggregated, initial) 
     ) 
    ); 
} 

tôi không thể làm điều này vì Interlocked.CompareExchange<T> dường như có một hạn chế where T : class, và Tôi không hiểu tại sao. Ý tôi là, có lẽ đó là do đã quá tải cho CompareExchange chấp nhận Int32, Int64, Double, v.v ...; nhưng điều đó hầu như không có lý do chính đáng. Trong trường hợp của tôi, ví dụ, nó sẽ khá tiện dụng để có thể sử dụng phương pháp Aggregate<T> để thực hiện một loạt các tính toán nguyên tử.

Answer 1

Interlocked.CompareExchange được thực hiện với các hướng dẫn nguyên tử gốc do bộ xử lý cung cấp trực tiếp. Nó là vô nghĩa để có một cái gì đó như thế sử dụng một lock nội bộ (nó được thiết kế cho các kịch bản không có khóa).

Bộ xử lý cung cấp hướng dẫn trao đổi so sánh nguyên tử tự nhiên hỗ trợ thao tác nhỏ, "kích thước đăng ký" (ví dụ: lệnh trao đổi so sánh lớn nhất trên bộ xử lý Intel x64 là cmpxchg16b hoạt động trên giá trị 128 bit).

Loại giá trị tùy ý có thể có khả năng lớn hơn và so sánh trao đổi nó có thể không thực hiện được với một lệnh duy nhất. So sánh trao đổi một loại tham chiếu thật dễ dàng. Bất kể tổng kích thước của nó trong bộ nhớ, bạn sẽ so sánh và sao chép một con trỏ nhỏ có kích thước đã biết. Điều này cũng đúng đối với các loại nguyên thủy như Int32 và Double — tất cả chúng đều nhỏ.

Answer 2

Tôi nghi ngờ rằng Interlocked.CompareExchange<T> chỉ thực hiện chuyển đổi con trỏ nguyên tử dưới mui xe.

Cố gắng thực hiện điều đó với một loại giá trị có thể sẽ không cung cấp kết quả bạn mong đợi.

Bạn có thể, tất nhiên, loại giá trị hộp lên trong một object trước khi sử dụng chúng.

Answer 3

Do quá tải đó được thiết kế để so sánh và trao đổi tham chiếu. Nó không thực hiện kiểm tra bình đẳng bằng phương thức Equals().Vì loại giá trị sẽ không bao giờ có tham chiếu bình đẳng với giá trị mà bạn so sánh với, nên tôi đoán là chúng đã hạn chế T thành lớp để tránh lạm dụng.