线程锁定访问

‘壹’ 产生线程死锁的原因和处理方式

线程同步(就是加锁)会有一个问题，就是产生死锁
所谓死锁: 是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。

地上放着两个桶泡面，一个老坛酸菜，一个小鸡炖磨茹。有两个人： 一个产品 (线程1)， 一个测试 (线程2)，同时扑向 抢老坛酸菜 (锁A)和 小鸡炖磨茹 (锁B)，产品拿到老坛酸菜，测试拿到小鸡炖磨茹，同一时刻，产品伸要去拽测试怀里的小鸡炖磨茹，测试伸手去拽产品的老坛酸菜，互使剪刀脚两个僵持不下，就卡死在那了，叫这就死锁。如果没有 一个开发 将他们各打一顿解救出来(中断状态)，它们将无法推进下去。

死锁是因为多线程访问共享资源，由于访问的顺序不当所造成的，通常是一个线程锁定了一个资源A，而又想去锁定资源B；在另一个线程中，锁定了资源B，而又想去锁定资源A以完成自身的操作，两个线程都想得到对方的资源，而不愿释放自己的资源，造成两个线程都在等待，而无法执行的情况。

如果只使用一个锁就不会有死锁的问题，不过复杂场景下不太理实。
1.以确定的顺序获得锁

2.超时放弃
Lock接口提供了boolean tryLock(long time, TimeUnit unit) throws InterruptedException方法，该方法可以按照固定时长等待锁，因此线程可以在获取锁超时以后，主动释放之前已经获得的所有的锁。通过这种方式，也可以很有效地避免死锁。

死锁示列:

‘贰’ Python多线程之threading之Lock对象

要介绍Python的 threading 模块中的 Lock 对象前, 首先应该了解以下两个概念:

1.基本概念 : 指某个函数/函数库在多线程环境中被调用时, 能够正确地处理多个线程之间的 共享变量 , 使程序功能正常完成. 多个线程访问同一个对象时, 如果不用考虑这些线程在运行时环境下的调度和交替执行, 也不需要进行额外的同步, 或者在调用方进行任何其他操作,调用这个对象的行为都可以获得正确的结果, 那么这个对象就是线程安全的. 或者说: 一个类或者程序所提供的接口对于线程来说是 原子操作 或者多个线程之间的切换不会导致该接口的执行结果存在二义性, 也就是说我们不用考虑同步的问题.

2.示例 : 比如有间银行只有1000元, 而两个人同时提领1000元时,就有可能拿到总计2000元的金额. 为了避免这个问题, 该间银行提款时应该使用 互斥锁 , 即意味着对同一个资源处理时, 前一个提领交易完成后才处理下一笔交易.

3.线程安全意义 :

4.是否线程安全 :

5.资源竞争 : 即多个线程对同一个资源的改写时, 存在的一种竞争. 如果仅仅是读操作, 则不存在资源竞争的情况.

1.基本概念 : 因为存在上述所说的 线程安全与资源竞争 的情况, 所以引入了 线程锁 . 即通过锁来进行资源请求的限制, 以保证同步执行,避免资源被污染或预期结果不符. 线程锁存在两种状态: 锁定(locked)和非锁定(unlocked).

2.基本方法 :

3.使用示例 :

上述示例如果在不加锁的情况下, 将会出现打印顺序混乱的情况, 不过最终结果都是正确的, 因为即使线程交替执行, 但最终的结果都是一致.

‘叁’ 怎么处理java多线程死锁问题

有两种实现方法，分别是继承Thread类与实现Runnable
接口
用synchronized关键字修饰同步方法
反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么
其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用
suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定
的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个
锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该
活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个
notify()重新启动线程。

‘肆’ IOS多线程安全（线程锁）

线程的不安全是由于多线程访问和修改共享资源而引起的不可预测的结果。
ios多线程开发中为保证线程的安全常用到的几种锁： NSLock 、 dispatch_semaphore 、 NSCondition 、 NSRecursiveLock 、 @synchronized 。

WEAKSELF typeof(self) __weak weakSelf = self;

NSLock 是OC层封装底层线程操作来实现的一种锁，继承NSLocking协议。不能迭代加锁，如果发生两次lock，而未unlock过，则会产生死锁问题。
以车站购票为例，多个窗口同时售票（同步），每个窗口有人循环购票：

原子操作
原子操作是指不可打断的操作，也就是说线程在执行操作的过程中，不会被操作系统挂起，而是一定会执行完，
变量属性Property中的原子定义
一般我们定义一个变量@property (nonatomic ,strong)NSLock *lock;nonatomic：非原子性，不会为setter方法加锁，适合内存小的移动设备；atomic：原子性，默认为setter方法加锁（默认就是atomic），线程安全。
PS： 在iOS开发过程中，一般都将属性声明为nonatomic，尽量避免多线程抢夺同一资源，尽量将加锁等资源抢夺业务交给服务器。

NSCondition常用于生产者-消费者模式，它继承了NSLocking协议，同样有lock和unlock方法。条件变量有点像信号量，提供了线程阻塞和信号机制，因此可以用来阻塞某个线程，并等待数据就绪再唤醒程序。

信号量主要有3个函数，分别是：

注意： 正常的使用顺序是先降低然后提高，这两个函数通常都是成对出现。

本文主要参考了这篇文章( https://www.cnblogs.com/crash-wu/p/4806499.html
)，并对其中所能理解的部分进行一一验证，以前没怎么写过类似的，如果有什么做的不好的地方还请大家多多见谅！

‘伍’ java 如何判断一个对象被其它线程读或写锁定如果锁定则所在方法return

你需要一种非阻塞式的锁。java.util.cocurrent包中的ReentrantReadWriteLock就提供了可重入的读写锁机制。

=newReentrantReadWriteLock();//读写锁

publicbooleanread(){
//尝试获取读锁
if(rwl.readLock().tryLock()){
//读资源
returntrue;
}else{//获取读锁失败
returnfalse;//立即返回
}
}

publicbooleanwrite(){
//尝试获取写锁
if(rwl.writeLock().tryLock()){
//写资源
returntrue;
}else{//获取写锁失败
returnfalse;//立即返回
}
}

‘陆’ asp.net 中使用线程锁定lock(this)可能会出现于public访问属性冲突的问题，谁有解决方案，不吝赐教！

MSDN上有：
通常，应避免锁定 public 类型，否则实例将超出代码的控制范围。 常见的结构 lock (this)、lock (typeof (MyType)) 和 lock ("myLock") 违反此准则：
如果实例可以被公共访问，将出现 lock (this) 问题。
如果 MyType 可以被公共访问，将出现 lock (typeof (MyType)) 问题。
由于进程中使用同一字符串的任何其他代码都将共享同一个锁，所以出现 lock("myLock") 问题。
最佳做法是定义 private 对象来锁定, 或 private static 对象变量来保护所有实例所共有的数据。

‘柒’ java 一个线程被锁定了为什么其他线程可以对其进行修改

m2又没有锁，怎么会被锁？

‘捌’ 线程锁定

临界区可以解决。自己网络相关资料。
如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。

‘玖’ 线程锁的原理是什么

线程锁的原理:当对象获取锁时，它首先使自己的高速缓存无效，这样就可以保证直接从主内存中装入变量。

同样，在对象释放锁之前，它会刷新其高速缓存，强制使已做的任何更改都出现在主内存中。 这样，会保证在同一个锁上同步的两个线程看到在 synchronized 块内修改的变量的相同值。

一般来说，线程以某种不必让其他线程立即可以看到的方式（不管这些线程在寄存器中、在处理器特定的缓存中，还是通过指令重排或者其他编译器优化），不受缓存变量值的约束。

(9)线程锁定访问扩展阅读:

线程锁在run()函数中使用QMutex实现同步，当多个线程访问共享变量时，使用lock/trylock和unlock将共享变量包裹，以保证同步访问共享变量。

如果不加锁将会在2秒后同时修改num变量，将会导致线程不按照我们的想法执行，当前线程锁定后，其他线程如果遇到共享变量将会等待解锁；

使用QMutex上锁解锁时，当代码提前退出有可能并未执行unlock(),若其他线程采用lock上锁会一直被阻塞，导致内存溢出。

‘拾’ java线程锁 锁住的是什么意思

在Java语言中，引入对象互斥锁的概念，保证共享数据操作的完整性。
每个对象都对应于一个可称为"互斥锁"的标记，这个标记保证在任一时刻，只能有一个线程访问对象
用关键字synchronized给对象加互斥锁。
其实原理还是锁住资源,同一时刻保证一个线程能调用,这样的话有时候会导致死锁问题.
线程1锁住资源A等待资源B，线程2锁住资源B等待资源A，两个线程都在等待自己需要的资源，而这些资源被另外的线程锁住，这些线程你等我，我等你，谁也不愿意让出资源，这样死锁就产生了。