。

在并发环境中#xff0c;每个线程在获取锁时会先查看此锁维护的队列#xff0c;如果为空#xff0c;或者当前线程是等待队列的第一个#xff0c;就占有锁#xff0c;否则就会…​

公平锁

是指多个线程按照申请锁的顺序来获取锁有点先来后到的意思。

在并发环境中每个线程在获取锁时会先查看此锁维护的队列如果为空或者当前线程是等待队列的第一个就占有锁否则就会加入到等待队列中以后会按照

FIFO

指多个线程获取锁的顺序并不是按照申请锁的顺序上来就尝试占有锁如果尝试失败就再采用类似公平锁的方式获取锁。

有可能后申请的线程比先申请的线程优先获取锁在高并发的情况下有可能会造成优先级反转或者饥饿现象。

ReentrantLock并发包中ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或非公平锁默认是false非公平锁。

非公平的优点在于吞吐量比公平锁大。

对于Synchronized锁也是一种非公平锁。

指同一线程外层函数获得锁之后内层递归函数仍然能获取该锁的代码。

也就是说线程可以进入任何一个它已经拥有的锁所同步的代码块。

synchronized和unlock都是可重入锁。

public

method1(){System.out.println(方法1

}public

method2(){System.out.printf(方法2

synchronized);

是指尝试获取锁的线程不会立即阻塞而是采用循环的方式尝试获取锁这样的好处是减少了上下文切换的消耗确定是循环会消耗CPU。

循环比较直到成功为止。

public

var5;do{//根据对象和地址偏移量获取内存中的值var5

var5

var5相等则修改var5值并返回否则重新进入循环。

}while(!this.compareAndSwapInt(var1,

var2,

思想就是通过while中的循环条件来充当锁当条件成立时表示未获得锁进行死循环直到while条件不成立也就是获得锁。

就退出死循环执行业务逻辑。

具体查看如下代码

public

{e.printStackTrace();}test.unLock();},AA).start();TimeUnit.SECONDS.sleep(1);new

catch

{e.printStackTrace();}test.unLock();},BB).start();}//对线程保证原子性AtomicReferenceThread

atomicReference

AtomicReference();//获取锁其实质将锁看做一个条件判断只要这个判断能够保证线程安全即可。

//如下我们将线程是否为空作为条件如果是空的就没锁自己可以对其加锁将其值设为自己。

//如果使用完使用unlock

将线程设置为

null其他线程通过判断来获得锁其实就像一种约定而已。

public

void

Thread.currentThread();System.out.println(thread.getName()

myLock);while

(!atomicReference.compareAndSet(null,thread)){}}//释放锁public

void

Thread.currentThread();atomicReference.compareAndSet(thread,null);System.out.println(thread.getName()

unLock);}

【1】减少线程阻塞对于锁竞争不激烈且锁占用时间短暂的情况自旋锁能够显著提高性能因为它减少了线程因阻塞而产生的上下文切换开销。

【2】避免内核态切换与非自旋锁相比自旋锁在尝试获取锁失败时会继续执行循环而不立即陷入内核态这样可以避免线程在用户态和内核态之间的频繁切换这在一定程度上提高了系统的整体性能。

然而自旋锁也存在一些缺点

【1】高负载下效率低下如果锁竞争激烈或持有锁的线程需要长时间执行同步块自旋锁会因为不断重复无效的旋转操作而导致性能下降。

在这种情况下自旋锁的消耗可能会超过线程阻塞后的恢复成本因此应该关闭自旋锁以避免不必要的性能损失。

1234

【2】可能存在不公平性某些自旋锁实现如Java中的不是完全公平的这意味着它们可能无法为等待时间最长线程提供优先权这可能导致所谓的“线程饥饿”问题。

【3】单核处理器上的限制在单核处理器上自旋锁实际上没有真正的并行性因为即使当前线程不阻塞其他线程锁仍然不会被释放导致资源的浪费。

此外如果处理器数量少于线程数量自旋锁也可能造成不必要的资源浪费。

4

【4】不适合计算密集型任务如果任务主要是计算密集型的使用自旋锁可能会导致性能下降因为自旋锁会占用CPU资源而在计算密集型任务中减少锁的使用可能是更优的选择。

综上所述自旋锁适用于锁竞争不太激烈且锁占用时间较短的场景但在竞争激烈或锁占用时间较长的情况下其性能优势不明显甚至可能导致性能下降。

【独占锁】写锁

指该锁只能被一个线程所持有。

对ReentrantLock和Synchronized而言都是独占锁。

【共享锁】读锁

【1】不加读写锁时代码及出现的问题如下创建5个线程进行写入5个线程进行读取。

public

v){System.out.println(Thread.currentThread().getName()

开始写入k

{TimeUnit.MICROSECONDS.sleep(30);}catch

(Exception

e){e.printStackTrace();}map.put(k,v);System.out.println(Thread.currentThread().getName()

写入完成);}//读方法public

k){System.out.println(Thread.currentThread().getName()

读数据开始k

{TimeUnit.MICROSECONDS.sleep(10);}catch

(Exception

map.get(k);System.out.println(Thread.currentThread().getName()

读数据完场完成v);}public

Thread(()-{readWriteLock.put(tempInt,tempInt);},String.valueOf(i)).start();}//读取数据for(int

i1;i6;i){final

Thread(()-{readWriteLock.get(tempInt);},String.valueOf(i)).start();}}

}【2】上述代码输出如下第一个线程未写入完成时其他线程就进入了该方法进行了写操作。

不符合多线程安全特性。

【3】加入读写锁ReentrantReadWriteLock读写锁位于JUC包下

public

ReentrantReadWriteLock();//写入方法public

void

v){rwLock.writeLock().lock();try

{System.out.println(Thread.currentThread().getName()

开始写入k

{TimeUnit.MICROSECONDS.sleep(30);}catch

(Exception

e){e.printStackTrace();}map.put(k,v);System.out.println(Thread.currentThread().getName()

写入完成);}catch

e){e.printStackTrace();}finally

{rwLock.writeLock().unlock();}}//读方法public

void

k){rwLock.readLock().lock();try

{System.out.println(Thread.currentThread().getName()

读数据开始k

{TimeUnit.MICROSECONDS.sleep(10);}catch

(Exception

map.get(k);System.out.println(Thread.currentThread().getName()

读数据完场完成v);}

{rwLock.readLock().unlock();}}public

static

Thread(()-{readWriteLock.put(tempInt,tempInt);},String.valueOf(i)).start();}//读取数据for(int

i1;i6;i){final

Thread(()-{readWriteLock.get(tempInt);},String.valueOf(i)).start();}}

}【4】加入读写锁后输出如下