C# 线程同步

数据必须在线程之间共享。哪种同步方法最好

锁是更好的方法还是互斥

namespace ConsoleApplication8
{
    class Data
    {
        public int X
        {
            set;
            get;
        }

        public int Y
        {
            get;
            set;
        }

        public int result;
    }

    class Program
    {
        static int a;
        private static object aLock = new object();

        static void Main(string[] args)
        {
            ParameterizedThreadStart aStart = new ParameterizedThreadStart(Addition);
            Thread aThread = new Thread(aStart);
            Data aData = new Data();
            aData.X = 10;
            aData.Y = 20;

            Thread aThread2 = new Thread(aStart);
            aThread2.Start();


            aThread.Start(aData);
            aThread.Join();
            aThread2.Join();
            Console.WriteLine("End of the program");
        }

        static void Addition(object data)
        {
            var a = data as Data;
            var b = a.X + a.Y;
            a.result = b;

            Console.WriteLine(a.result);
            Thread.Sleep(1000);
            Console.WriteLine("End of thread");
            updateValue();
        }

        static void updateValue()
        {
            lock (aLock)
            {
                a++;
            }
        }
    }
}

---

您有两个“同步”线程的位置

您正在使用

线程。请加入
等待线程完成，然后再继续主线程。那很好

您还使用了一个锁来确保每次只有一个线程递增计数器变量
a
。这也很好，但可以改进。在
System.Threading
中有一个名为
Interlocked
的类，它可以以线程安全的方式为您执行增量

Interlocked.Increment(ref a);

您的代码在两个位置使用变量
a
——内部
添加
您有一个局部变量
a
，该局部变量将静态外部变量
a
隐藏起来。我想这只是巧合

另一个问题是，您的
加法
方法将
对象
作为参数。我理解为什么它不把
数据
作为参数，因为
ParameterizedThreadStart
需要一个对象。有一个更好的方法来解决这个问题

请尝试以下代码：

private static int __counter = 0;

public class Data
{
    public int X { set; get; }
    public int Y { set; get; }
    public int Result { set; get; }
}

private void Addition(Data data)
{
    data.Result = data.X + data.Y;
    Interlocked.Increment(ref __counter);

    Thread.Sleep(1000);

    Console.WriteLine(data.Result);
    Console.WriteLine("End of thread");
}

现在，
Main
可以写成：

void Main()
{
    ParameterizedThreadStart pts = o => Addition(o as Data);

    var t1 = new Thread(pts);
    var t2 = new Thread(pts);

    t1.Start(new Data { X = 10, Y = 20 });
    t2.Start(new Data { X = 13, Y = 42 });

    t1.Join();
    t2.Join();

    Console.WriteLine(__counter);
    Console.WriteLine("End of the program");
}

那应该更整洁一点

我看不到您在代码中共享的确切数据。也许你可以详细说明？
定义“更好”的标准。apple比orange好吗？或者你只是想知道锁和互斥的区别吗？看看同样的帖子：@erikH：如果我在同步共享数据时使用锁或互斥，我会得到什么好处？互斥可以用于进程间同步。lock语句更轻，并且依赖于监视器。