锁

最新推荐文章于 2025-12-28 23:02:17 发布

转载最新推荐文章于 2025-12-28 23:02:17 发布 · 84 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/Howard2016/blog/1594090

文章标签：

#java #python #操作系统

本文深入探讨Java中的锁机制，包括偏向锁、轻量级锁、自旋锁等JVM内置锁的特点与应用场景，并介绍了如何从Java语言层面提高锁的性能，如减少锁持有时间、减小锁粒度等。

2019独角兽企业重金招聘Python工程师标准>>>

一、引述

1、线程安全

线程安全：使用锁的原因，为了使各个线程更好地协同工作

> 多线程网站统计访问人数

使用锁，维护计数器的串行访问与安全性

> 多线程访问ArrayList

public static List<Integer> numberList =new ArrayList<Integer>();
public static class AddToList implements Runnable{
	int startnum=0;
	public AddToList(int startnumber){
		startnum=startnumber;
	}
	@Override
	public void run() {
		int count=0;
		while(count<1000000){
			numberList.add(startnum);
			startnum+=2;
			count++;
		}
	}
}

public static void main(String[] args) throws InterruptedException {
	Thread t1=new Thread(new AddToList(0));
	Thread t2=new Thread(new AddToList(1));
	t1.start();
	t2.start();
	while(t1.isAlive() || t2.isAlive()){
		Thread.sleep(1);
	}
	System.out.println(numberList.size());
}

注：

1、不加锁可能导致访问量比实际要小一些，加锁性能会有一些损耗

2、ArrayList不是线程安全的，当容量不足时会自动扩容，但是此时处于不可用状态，此时又没有多线程保护，当下一个元素要加入时会发生数组越界异常

3、锁的必要性！！！

2、对象头Mark

> Mark Word，对象头的标记，32位

> 描述对象的hash、锁信息，垃圾回收标记，年龄

指向锁记录的指针

指向monitor的指针

GC标记

偏向锁线程ID

二、JVM内置锁

1、偏向锁

> 大部分情况是没有竞争的，所以可以通过偏向来提高性能

> 所谓的偏向，就是偏心，即锁会偏向于当前已经占有锁的线程

> 将对象头Mark的标记设置为偏向，并将线程ID写入对象头Mark

> 只要没有竞争，获得偏向锁的线程，在将来进入同步块，不需要做同步

> 当其他线程请求相同的锁时，偏向模式结束

-XX:+UseBiasedLocking

默认启用(但会在JVM启动延迟一段时间后才开启)

> 在竞争激烈的场合，偏向锁会增加系统负担

public static List<Integer> numberList =new Vector<Integer>();
public static void main(String[] args) throws InterruptedException {
	long begin=System.currentTimeMillis();
	int count=0;
	int startnum=0;
	while(count<10000000){
		numberList.add(startnum);
		startnum+=2;
		count++;
	}
	long end=System.currentTimeMillis();
	System.out.println(end-begin);
}

-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0

-XX:-UseBiasedLocking

注：本例中，使用偏向锁，可以获得5%以上的性能提升

1、Vector是线程安全的，jdk内部add方法加了Synchronized 同步锁

2、jvm刚启用前几s是没有启动的，有一段时间延迟

2、轻量级锁

> BasicObjectLock

嵌入在线程栈中的对象

> 普通的锁处理性能不够理想，轻量级锁是一种快速的锁定方法。

> 如果对象没有被锁定

将对象头的Mark指针保存到锁对象中

将对象头设置为指向锁的指针（在线程栈空间中）

lock->set_displaced_header(mark);
 if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()->mark_addr(), mark)) {
      TEVENT (slow_enter: release stacklock) ;
      return ;
}

注：

1、lock位于线程栈中

2、线程是否持有某把锁：看对象锁指针是否指向该线程栈空间地址范围，若是，则持有

> 如果轻量级锁失败，表示存在竞争，升级为重量级锁（常规锁(Monitor)）

> 在没有锁竞争的前提下，减少传统锁使用OS互斥量产生的性能损耗

> 在竞争激烈时，轻量级锁会多做很多额外操作，导致性能下降

3、自旋锁

当竞争存在时，如果线程可以很快获得锁，那么可以不在OS层挂起线程，让线程做几个空操作（自旋） ,性能损耗会比较大，会导致频繁上下文切换

JDK1.6中-XX:+UseSpinning开启

JDK1.7中，去掉此参数，改为内置实现

如果同步块很长，自旋失败，会降低系统性能

如果同步块很短，自旋成功，节省线程挂起切换时间，提升系统性能

4、偏向锁，轻量级锁，自旋锁总结

> 不是Java语言层面的锁优化方法

> 内置于JVM中的获取锁的优化方法和获取锁的步骤

偏向锁可用会先尝试偏向锁

轻量级锁可用会先尝试轻量级锁

以上都失败，尝试自旋锁

再失败，尝试普通锁，使用OS互斥量在操作系统层挂起

三、从Java语言层面提高锁的性能

1、减少锁持有时间

public synchronized void syncMethod(){
	othercode1();
	mutextMethod();
	othercode2();
}



public void syncMethod2(){
	othercode1();
	synchronized(this){
		mutextMethod();
	}
	othercode2();
}

2、减小锁粒度

> 将大对象，拆成小对象，大大增加并行度，降低锁竞争

> 偏向锁，轻量级锁成功率提高

> ConcurrentHashMap

> HashMap的同步实现

Collections.synchronizedMap(Map<K,V> m)

返回SynchronizedMap对象

 public V get(Object key) {
            synchronized (mutex) {return m.get(key);}
        }
public V put(K key, V value) {
            synchronized (mutex) {return m.put(key, value);}
}

> ConcurrentHashMap

若干个Segment ：Segment<K,V>[] segments

Segment中维护HashEntry<K,V>

put操作时

先定位到Segment，锁定一个Segment，执行put

> 在减小锁粒度后， ConcurrentHashMap允许若干个线程同时进入

注：减小锁粒度：结构上进行的分离

3、锁分离

> 根据功能进行锁分离

> ReadWriteLock

> 读多写少的情况，可以提高性能

注：

1、锁分离：本质上也是减小锁粒度的一种，功能上进行的分离

2、读的时候，其它线程可以获取读锁；写的时候，不可以获取写锁/读锁，其它线程不可以读也不可以写，如ArrayList

> 读写分离思想可以延伸，只要操作互不影响，锁就可以分离

> LinkedBlockingQueue

队列

链表

4、锁粗化

通常情况下，为了保证多线程间的有效并发，会要求每个线程持有锁的时间尽量短，即在使用完公共资源后，应该立即释放锁。只有这样，等待在这个锁上的其他线程才能尽早的获得资源执行任务。但是，凡事都有一个度，如果对同一个锁不停的进行请求、同步和释放，其本身也会消耗系统宝贵的资源，反而不利于性能的优化(反减少锁持有时间其道而为之)

public void demoMethod(){
	synchronized(lock){
		//do sth.
	}
	//做其他不需要的同步的工作，但能很快执行完毕
	synchronized(lock){
		//do sth.
	}
}



public void demoMethod(){
		//整合成一次锁请求
	synchronized(lock){
		//do sth. 前提：
		//做其他不需要的同步的工作，但能很快执行完毕
	}
}

注：

前提：不需要的同步的工作，但能很快执行完毕

for(int i=0;i<CIRCLE;i++){
	synchronized(lock){
		
	}
}



synchronized(lock){
for(int i=0;i<CIRCLE;i++){
		
	}
}

5、锁消除

在即时编译器时，如果发现不可能被共享的对象，则可以消除这些对象的锁操作

public static void main(String args[]) throws InterruptedException {
	long start = System.currentTimeMillis();
	for (int i = 0; i < CIRCLE; i++) {
		craeteStringBuffer("JVM", "Diagnosis");
	}
	long bufferCost = System.currentTimeMillis() - start;
	System.out.println("craeteStringBuffer: " + bufferCost + " ms");
}

public static String craeteStringBuffer(String s1, String s2) {
	StringBuffer sb = new StringBuffer();
	sb.append(s1);//存在jdk中的同步操作
	sb.append(s2);//存在jdk中的同步操作
	return sb.toString();
}

注：

1、StringBuffer是线程安全的，append操作是同步操作(Asynchronized) 因此改用StringBuider数据结构，效率会更高，Vector也是如此。