1、lock
internal class Program
{
static object lockObject=new object();
static void Main(string[] args)
{
Student student = new Student();
Thread thread1 = new Thread(new ThreadStart(Start1));
thread1.Start();
Thread thread2 = new Thread(Start2);
thread2.Start(student);
}
private static void Start2(object? obj)
{
var student = obj as Student;
lock (lockObject)
{
for (int i = 0; i < 30; i++)
{
Console.WriteLine(student!.Name + i);
}
}
}
private static void Start1()
{
lock (lockObject)
{
for (int i = 0; i < 30; i++)
{
Console.WriteLine(i);
}
}
}
}
lock锁用于同步线程对共享资源的访问，这里的共享资源是静态的Console.WriteLine，当多个线程共同使用它的时候，lock内部会有一个监听器，监听它有没有在其他地方使用，有的话，我这里先暂停，它的底层是一个互斥锁，是一个非的概念。
2、Monitor
internal class Program
{
static object lockObject = new object();
static void Main(string[] args)
{
Student student = new Student();
Thread thread1 = new Thread(new ThreadStart(Start1));
thread1.Start();
Thread thread2 = new Thread(Start2);
thread2.Start(student);
}
private static void Start2(object? obj)
{
var student = obj as Student;
Monitor.Enter(lockObject); //在指定对象获取排他锁
try
{
for (int i = 0; i < 30; i++)
{
Console.WriteLine("张三"+i);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message.ToString());
}
finally
{
Monitor.Exit(lockObject); //释放锁
}
}
private static void Start1()
{
for (int i = 0; i < 30; i++)
{
Console.WriteLine(i);
}
}
}
public class Student
{
public int Id { get; set; }
public string Name { get; set; }
public Student()
{
Name = "张三";
}
}
Monitor的底层实现同样依赖于操作系统的同步机制。在.NET中，Monitor是基于Windows操作系统的Win32 API中的WaitForSingleObject和ReleaseMutex函数实现的，或者在其他平台上使用相应的同步机制。
当调用Monitor.Enter时，如果对象的锁没有被其他线程持有，当前线程将获得锁并继续执行。如果锁已经被其他线程持有，当前线程将等待直到锁被释放。Monitor.Exit用于释放当前线程持有的锁，允许其他等待的线程尝试获取锁。
使用Monitor时，通常需要与try...finally结构一起使用，以确保即使在发生异常的情况下锁也能被正确释放。这是Monitor与lock语句的一个主要区别，因为lock语句会自动处理异常情况并释放锁。
3、Semaphore
internal class Program
{
static Semaphore _semaphore;
static int currentCount; //当前线程信号量
static RandomNumberGenerator randomNumber;
static Random r;
static void Main(string[] args)
{
r = new Random();
randomNumber = RandomNumberGenerator.Create();
byte[] buffer = new byte[1024];
randomNumber.GetBytes(buffer);
_semaphore =new Semaphore(1,3);
for (int i = 0; i < 5; i++)
{
ThreadPool.QueueUserWorkItem(Done,i+1);
}
Console.ReadKey(true);
}
private static void Done(object? state)
{
int id = (int)state;
PrintThreadStatus(id, "等待");
_semaphore.WaitOne();
PrintThreadStatus(id, "进入");
PrintCount(1);
Thread.Sleep(r.Next(1000));
PrintThreadStatus(id, "退出");
PrintCount(-1);
_semaphore.Release();
}
//输出线程状态
static void PrintThreadStatus(int id,string thread)
{
Console.WriteLine($"线程{id}:{thread}");
}
//修改并输出线程数量
static void PrintCount(int add)
{
Interlocked.Add(ref currentCount, add);
Console.WriteLine($"=> 信号量{Interlocked.Exchange(ref currentCount,currentCount)}");
}
}
锁住的对象：
在这个代码示例中，Semaphore并不是直接“锁住”某个对象，而是作为一种同步机制，用来控制同时访问某个资源（在这种情况下是临界区代码）的线程数量。Semaphore有两个重要的参数：当前信号量计数（currentCount）和最大信号量计数（maxCount）。在这个例子中，_semaphore被初始化为new Semaphore(1, 3)，这意味着初始时只有一个信号量可用，但最多可以有三个线程同时持有信号量。
当一个线程调用_semaphore.WaitOne();时，如果信号量计数大于0，它将减少计数并继续执行。如果计数为0，则线程将被阻塞，直到其他线程调用_semaphore.Release();来增加信号量计数。这确保了在任何时刻，只有指定数量的线程能够进入受保护的代码区域。
使用锁（在这个例子中是Semaphore）可以使多线程按顺序执行下去，因为Semaphore限制了同时执行临界区代码的线程数量。当一个线程进入临界区并执行完毕后，它通过调用_semaphore.Release();来释放信号量，允许其他等待的线程进入。
锁的底层实现：
Semaphore的底层实现依赖于操作系统的同步机制。在.NET中，Semaphore是基于Windows API中的同步对象，如CreateSemaphore和ReleaseSemaphore，来实现的。这些API提供了一种机制，用于跨多个线程或进程同步对共享资源的访问。
当调用WaitOne方法时，如果信号量计数大于0，它会减少计数并允许线程继续执行。如果计数为0，线程将等待，直到其他线程调用Release方法来增加信号量计数。这个过程涉及到操作系统内核的调度和同步原语，如互斥锁（mutexes）、信号量（semaphores）或事件（events）。
Semaphore的实现细节可能会因操作系统而异，但其核心概念是一致的：控制对共享资源的访问，以避免竞争条件和确保数据一致性。
Semaphore用于控制对临界区的访问，确保最多只有三个线程可以同时执行Done方法中的代码。通过这种方式，Semaphore帮助维护了线程间的同步，并防止了潜在的竞态条件。
4、Mutext既然是跨进程基元同步