正文

C#线程间传递参数与同步技巧，轻松实现多线程高效协作

/0 浏览量
1028

在C#编程中，多线程是一种常见的技术，它允许程序同时执行多个任务，从而提高程序的性能和响应速度。然而，多线程编程也带来了一系列的挑战，尤其是在线程间传递参数和同步方面。本文将深入探讨C#线程间传递参数与同步的技巧，帮助您轻松实现多线程高效协作。

线程间传递参数

线程间传递参数是确保数据正确地在各个线程之间共享的关键。以下是一些常用的方法：

1. 使用共享变量

通过使用共享变量，例如volatile关键字修饰的变量，可以在线程间安全地传递数据。以下是一个简单的示例：

class Program
{
    static volatile int count = 0;

    static void Main(string[] args)
    {
        Thread t1 = new Thread(() =>
        {
            for (int i = 0; i < 1000; i++)
            {
                count++;
            }
        });

        Thread t2 = new Thread(() =>
        {
            for (int i = 0; i < 1000; i++)
            {
                count--;
            }
        });

        t1.Start();
        t2.Start();

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

        Console.WriteLine(count);
    }
}

2. 使用锁（Lock）

使用锁可以确保同一时间只有一个线程可以访问共享资源。以下是一个使用锁的示例：

class Program
{
    static int count = 0;
    static readonly object lockObj = new object();

    static void Main(string[] args)
    {
        Thread t1 = new Thread(() =>
        {
            for (int i = 0; i < 1000; i++)
            {
                lock (lockObj)
                {
                    count++;
                }
            }
        });

        Thread t2 = new Thread(() =>
        {
            for (int i = 0; i < 1000; i++)
            {
                lock (lockObj)
                {
                    count--;
                }
            }
        });

        t1.Start();
        t2.Start();

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

        Console.WriteLine(count);
    }
}

3. 使用线程安全的数据结构

C#提供了许多线程安全的数据结构，例如ConcurrentBag、ConcurrentDictionary等。以下是一个使用ConcurrentBag的示例：

using System.Collections.Concurrent;

class Program
{
    static ConcurrentBag<int> bag = new ConcurrentBag<int>();

    static void Main(string[] args)
    {
        Thread t1 = new Thread(() =>
        {
            for (int i = 0; i < 1000; i++)
            {
                bag.Add(i);
            }
        });

        Thread t2 = new Thread(() =>
        {
            for (int i = 0; i < 1000; i++)
            {
                bag.TryTake(out int value);
            }
        });

        t1.Start();
        t2.Start();

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

        Console.WriteLine(bag.Count);
    }
}

线程同步技巧

线程同步是确保线程按照预期的顺序执行的关键。以下是一些常用的同步技巧：

1. 使用ManualResetEvent或AutoResetEvent

ManualResetEvent和AutoResetEvent是用于线程同步的事件。以下是一个使用ManualResetEvent的示例：

using System.Threading;

class Program
{
    static ManualResetEvent doneEvent = new ManualResetEvent(false);

    static void Main(string[] args)
    {
        Thread t1 = new Thread(() =>
        {
            Console.WriteLine("Thread 1 is running.");
            Thread.Sleep(1000);
            doneEvent.Set();
        });

        Thread t2 = new Thread(() =>
        {
            Console.WriteLine("Thread 2 is waiting.");
            doneEvent.WaitOne();
            Console.WriteLine("Thread 2 has been signaled.");
        });

        t1.Start();
        t2.Start();

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

2. 使用Semaphore或SemaphoreSlim

Semaphore和SemaphoreSlim是用于限制线程数量的同步原语。以下是一个使用SemaphoreSlim的示例：

using System.Threading;

class Program
{
    static SemaphoreSlim semaphore = new SemaphoreSlim(2, 2);

    static void Main(string[] args)
    {
        for (int i = 0; i < 5; i++)
        {
            int id = i;
            Thread t = new Thread(() =>
            {
                Console.WriteLine($"Thread {id} is waiting to enter the critical section.");
                semaphore.Wait();
                Console.WriteLine($"Thread {id} is inside the critical section.");
                Thread.Sleep(1000);
                Console.WriteLine($"Thread {id} is leaving the critical section.");
                semaphore.Release();
            });
            t.Start();
        }
    }
}

3. 使用Monitor或Mutex

Monitor和Mutex是用于保护共享资源的同步原语。以下是一个使用Monitor的示例：

using System.Threading;

class Program
{
    static int count = 0;
    static readonly object lockObj = new object();

    static void Main(string[] args)
    {
        Thread t1 = new Thread(() =>
        {
            for (int i = 0; i < 1000; i++)
            {
                Monitor.Enter(lockObj);
                try
                {
                    count++;
                }
                finally
                {
                    Monitor.Exit(lockObj);
                }
            }
        });

        Thread t2 = new Thread(() =>
        {
            for (int i = 0; i < 1000; i++)
            {
                Monitor.Enter(lockObj);
                try
                {
                    count--;
                }
                finally
                {
                    Monitor.Exit(lockObj);
                }
            }
        });

        t1.Start();
        t2.Start();

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

        Console.WriteLine(count);
    }
}

总结

C#线程间传递参数与同步是确保多线程高效协作的关键。通过使用共享变量、锁、线程安全的数据结构以及同步原语，您可以轻松地实现线程间的数据共享和同步。在实际开发中，根据具体需求选择合适的同步技巧，可以让您的多线程程序更加健壮和高效。

-- 展开阅读全文 --