线程的学习

public class SynchronizedDemo {
static Integer count=0;
public static void incr(){
synchronized (count) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
count++;
}
}
public static void main(String[] args) throws IOException, InterruptedException {
for(int i=0;i<1000;i++){
new Thread(()->SynchronizedDemo.incr()).start();
}
Thread.sleep(5000);
System.out.println(“result:”+count);
}
}

上方的结果小于等于1000，因为使用Interger对象锁会存在一个问题，从javap的字节码中里可以看出使用的是这个方法java/lang/Integer.valueOf:(I)Ljava/lang/Integer，而在valueOf方法中是去通过判断，如果参数是在一定的范围中就去IntegerCache中去获取值，如果超出则new一个新的对象，这个范围在-128-127，所以得到的值为小于等于1000
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
2、synchronized在jdk1.6版本之前称呼为重量级锁，但是由于重量级锁需要进入blocked阻塞状态，对于性能的开销比较大，由此进行一系列的优化方案:
（1） 缩小锁的范围
（2） 不加锁的情况下保证线程安全
由此在jdk1.6版本进行了优化加入了无锁、偏向锁、轻量级锁、重量级锁

偏向锁：会将当前的线程ID存储到对象头中（Mark Word）进行偏向标记，通过cas比较进行替换

轻量级锁：通过栈帧（lock record）来存储对象头，通过自旋锁（自旋，CAS比较替换）进行实现

重量级锁：通过监视器monitor锁实现，线程竞争该锁，若失败则进行链表的阻塞队列中，进行等待锁的释放，释放之后会唤醒阻塞队列中的线程进行新的一轮竞争。

偏向锁：线程不存在竞争的时候会使用，会将当前的线程ID存储到对象头中（Mark Word）进行偏向标记，在线程进行访问同步代码块时会先判断对象头中是否存储当前线程的线程ID，如果存储了会进行CAS比较进行替换，将Mark Word 中的线程ID指向自己；
优点：当线程不存在竞争的时候，会减少性能的开销；
缺点：如果线程间存在锁竞争，会带来额外的锁撤销的消耗；
轻量级锁：线程在执行同步块前，JVM会先在当前线程的栈帧中会创建用于存储锁记录的空间，会有一个lock record用来存储对象头，然后线程会尝试使用CAS将对象头中的Mark word替换为指向锁记录的指针，如果成功，当前线程会获得锁，如果失败则进行竞争锁，会通过自旋CAS来获得锁（默认为自旋10次）在1.6之后引入了自行应通过判断上一次的自旋次数进行自适应，若自旋失败则膨胀升级为重量级锁
优点：线程的执行速度很快，通过自旋的方式获取锁比阻塞状态的性能开销更小，提高程序运行速度
缺点：如果始终得不到锁竞争的线程使用自旋会消耗CPU；
重量级锁：通过监视器monitor锁，在线程竞争时会去抢占monitor锁，如果成功则会持有该锁，如果没有成功会将有一个链表阻塞队列进行存储线程，当线程释放monitor锁之后，会唤醒在链表阻塞队列的线程，进行新的一轮竞争。
优点：线程竞争不使用自旋，不会消耗CPU
缺点：线程阻塞，响应时间缓慢