在c#语言中,多个线程同时访问一组变量怎么加线程锁?

嗯...C...多线程...问题...
要管理多个线程同时访问变量...必须使用同步方法...否则数据将被损坏。
等等...
同步对象...必须是引用类型...比如字符串...或者自定义类...
lock(MyObject) { ... }...这个锁...myObject...里面写的代码...一次只能运行一个线程...
互斥...有点复杂...可以在...多个进程之间使用...比如在Windows系统中更...残酷...线程不做任何其他事情...只是在循环等待...等待锁被释放释放...然后登录...CPU浪费...
非阻塞结构...如内存块...VolatileRead...这不是锁...告诉CPU...所以不要假设易失性...当你看到我时就按照我做的那样...
但是...同步的设计问题很高...亲。
对象...最好是私有的...别人不知道...我保护自己...
它可以是一个实例字段...例如每个对象都有一个锁...也可以是一个静态字段...所有对象共享一个锁...
事实上...lambda表达式持有的局部变量...也可以用作锁...但是要小心...
锁定时间...像我，V，非常重要。
很多线程同时改变...会出现问题...你必须加锁...
加锁保证相互隔离...别人在...我必须离开...我抓不到...
原子论...指令是不可分割的...比如读一个值...加1 ...重写...如果分两步...可以用另一种方式中断...可以用另一种方式中断。
这叫方法…所有的锁都用它…顺序必须一致…
但是要小心…嵌套锁…不要乱用…容易出问题…
禁用…最坏的情况…就是互相看…等待B的锁…B锁…出不来…
要防止锁…就得立个例子，防止Conte的锁。
切换...可能需要微秒...慢...
互斥...交叉处理...强大...但慢...比锁慢得多...
简而言之...C...多线程...同步...复杂...
小心...选择正确的方法...慢慢来...

JVM是怎么实现线程锁的

老实说，说到Java线程状态转换，我总是想知道如何在这些状态之间进行切换，尤其是在sleep和wait之间，这真的很容易让人困惑。
让我告诉你我知道后的想法。

看看线程如何从“新”更改为“正在进行”？这很简单。
在new Thread()之后，调用t.start()。
这就像给线程一个“起床”命令。
线程立即从“新”变为“可执行”。
但“可执行”并不意味着可以立即执行。
这取决于JVM调度程序的心情。
我在一个多线程项目中卡了很长一段时间，只是忘记了调度器并不是按优先级排序的。
有时，高优先级线程在后面等待，而低优先级线程在前面运行。

说到“运行”状态：最有趣的是yield()。
上次修改一个无限循环计算任务时，我使用yield让线程主动让出CPU。
结果，性能明显更好。
该方法特别适合计算量不大的任务，例如查询数据库状态。
但是，请注意，yield 仅向 CPU 提出建议：“为什么不是我的同事先呢？”不保证一定会轮到你。
这一切都取决于CPU的表现。

阻塞状态是最复杂的。
我遇到过由于休眠而导致线程挂起的情况。
例如，某个计划任务休眠时间太长，导致整个系统卡住。
后来我切换到 Thread.sleep(long millis, int nanos) 精确计时并添加了异常处理并修复了它。
但等待是完全不同的事情。
这不仅使线程进入睡眠状态，而且释放了锁。
我之前遇到过一个高并发场景，两个线程拥有相同的锁。
与wait/notifyAll解耦后，系统吞吐量立即翻倍。

还有一个细节我一直没弄清楚：启用了哪个线程通知？我测试发现，当同一个对象调用notify时，有时优先级较高的对象会被唤醒，有时会先进入睡眠状态。
所以我想知道JVM是否使用了随机算法，但是官方文档没有详细介绍。
因此，在编写代码时，不能指望notify会激活特定的线程。
您宁愿用notifyAll 唤醒每个人。

使用wait和notify有一个危险：它们必须位于同步代码块中。
当我第一次学习它时，我认为在 if 条件中写“wait”是很自然的，但是编译器在我身上崩溃了。
这让我想起Java设计者可能会认为，如果没有获得锁，就不应该做梦。
使用 wait 之前必须遵守规则。

最后说一下我陷入的一个陷阱。
Sleep需要捕获InterruptedException，但wait/notifyAll不需要。
我有一个线程池代码，忘记处理睡眠中断。
结果线程突然终止，任务没有完成。
进入休眠并添加InterruptedException会直接提高系统稳定性。

我个人没有遇到过锁争用的场景，但是notifyAll唤醒后，线程直观地再次抢到了锁，所以性能比notify要好。
在但在实际使用中，notifyAll会唤醒所有线程，会消耗大量的系统资源。
选择取决于具体情况。

Java中常见的几种锁

Java 锁有 7 种类型。

1 . 自旋锁。
线程没有被阻塞，并且尝试了循环。
比如死锁、CPU干等等。
例子：低并发时，锁争用不激烈的时候。

2 重量级锁。
线程直接阻塞。
内核管。
就像等公交车一样，人少，速度也快。
示例：高并发、锁竞争激烈。

3 偏置锁。
仅单线程。
首先使用它，始终使用它。
这就像一个预留的座位，但后来人们抢到了。
升级：多线程抓取时间变得轻量级。

4 .轻量化锁。
CAS 操作。
旋转等等。
就像争夺停车位一样，人少的时候速度更快。
升级：争夺多个随时间变化的权重。

5 公平锁。
排队。
就像银行的呼叫号码一样。
吞吐量低。
示例：队列等顺序操作。

6 不公平的锁。
插队去拿。
比如超市打折。
高吞吐量。
例子：多读少写，比如缓存。

7 悲观锁。
先锁紧，再干燥。
比如安检。
最好多写一点。
示例：数据库写操作。

8 乐观锁。
先做，然后再测试。
就像自助餐一样。
最好多读书。
示例：缓存读取操作。

自己掂量一下。

如何解决：Java并发错误：线程死锁

解决Java线程死锁的三种方法：1 .避免循环等待，2 .统一加锁顺序，3 .引入锁超时。
示例：线程 1 需要 A→B，线程 2 需要 B→A。
实施统一命令可以化解僵局。
工具：FindBugs、tryLock() 或 Timeout()。
提示：减少块粒度并避免嵌套块。
工具类：jstack、JConsole。
重点：强制顺序、超时控制、场景选择策略。