java的轻量锁,jvm第7节-锁(偏向锁,轻量锁，自旋锁)

在介绍锁之前我们先介绍一个线程不安全的例子，一个全局的list，开2个线程往里面插入数据，代码如下：

package com.jvm.day6.lock.demo;

import java.util.ArrayList;

import java.util.List;

/**

* 测试都线程共享一个变量带来的现象

* @Author:xuehan

* @Date:2016年3月20日下午3:35:29

*/

class NumberAdd implements Runnable{

public static List numberList =new ArrayList();

public static int startNum;

public NumberAdd(int startNum){

this.startNum = startNum;

}

@Override

public void run() {

int count = 0;

while(count < 1000000){

numberList.add(count ++ );

startNum = startNum + 2;

}

}

}

public class Test{

public static void main(String[] args) throws Exception {

Thread t1 = new Thread(new NumberAdd(1));

Thread t2 = new Thread(new NumberAdd(0));

t1.start();

t2.start();

while(t1.isAlive() || t2.isAlive()){Thread.sleep(2);}

System.out.println("集合大小" + NumberAdd.numberList.size() );

System.out.println( "最后一个值的大" + NumberAdd.numberList.get(NumberAdd.numberList.size() - 1));

for(int i = NumberAdd.numberList.size() - 10 ; i < NumberAdd.numberList.size() -1; i ++){

System.out.println(NumberAdd.numberList.get(i));

}

}

}

按照开始想的，集合里面应该有200万个数据了，结果却出现了数组越界的错误，为什么呢，这是因为ArrayList不是线程安全的，用来存放数据的elementData是共享的， 线程A往list里添加数据的时候刚验证大小通过，还没有插入，然后轮到线程B执行，线程B刚好插入了list该扩容的最后一个元素，然后list满了，线程A执行，A线程往集合里面插入元素，引起了数据越界。

jvm锁

每个对象都一个mark头，他的作用是：

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

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

指向锁记录的指针

指向monitor的指针

GC标记

偏向锁线程ID

偏向锁

jvm控制，可以设置jvm启动参数

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

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

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

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

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

-XX:+UseBiasedLocking -jdk6需要手动打开

默认启用

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

偏向锁是系统自带的设置参数开启，java代码如下：

package com.jvm.day6.lock;

import java.util.List;

import java.util.Vector;

/**

*使用 偏向锁-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0

* 不使用偏向锁-XX:-UseBiasedLocking

* 根据测试下面代码使用偏向锁可提高150毫秒执行时间 150/2300,提高效率6%

* @Author:xuehan

* @Date:2016年3月19日下午12:06:15

*/

public class DeflectionLock {

public static List numberList =new Vector();

public static void main(String[] args) throws InterruptedException {

System.out.println((int)'l');

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);

}

}  根据我的写实偏向锁可以提高性能6%

轻量级锁

BasicObjectLock，这个锁是嵌入到线程栈中的,他有两部组成

BasicLock和

ptr to obj hold the lock，

BasicLock里面存放着对象头，

ptr to obj hold the lock为指向持有对象锁的指针

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

如果对象没有被锁定

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

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

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

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

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

自旋锁

当竞争存在时，如果线程可以很快获得锁，那么可以不在OS层挂起线程，让线程做几个空操作(自旋)

JDK1.6中-XX:+UseSpinning开启

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

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

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

上面的一些锁不是Java语言层面的锁优化方法

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

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

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

以上都失败，尝试自旋锁

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

我们可以从以下方面对锁进行优化

减少锁的时间

没必须放在同步块的代码尽量不要放在代码块里

减少锁的粒度

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

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

实现的例子如ConcurrentHashMap

使用若干个Segment ：Segment[] segments

Segment中维护HashEntry

put操作时

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

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

锁分离

根据功能进行锁分离

ReadWriteLock

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

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

LinkedBlockingQueue

队列

链表

锁粗化

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

for(int i=0;i<1000;i++){

synchronized(lock){}

}

// 应该写成

synchronized(lock){

for(int i =0; i < 1000; i ++){}

}

这时候我们要增加锁的持有时间不要让请求和释放锁频繁的发生

锁消除

在java方法体里如果不是共享的变量不需要同步操作的，这时候jvm会自动的优化把锁去掉，如StingBuffer和Vector,使用锁消除

-server -XX:+DoEscapeAnalysis -XX:+EliminateLocks

关闭锁消除

-server -XX:+DoEscapeAnalysis -XX:-EliminateLocks

无锁

锁是悲观的操作

无锁是乐观的操作

无锁的一种实现方式

CAS(Compare And Swap)，CAS是原子的

非阻塞的同步

CAS(V,E,N)

在应用层面判断多线程的干扰，如果有干扰，则通知线程重试，一般这样做会让程序变的复杂，但性能更加好。