第四章 锁的优化及注意事项
1、锁性能的几点建议
减小锁持有时间：
- 系统持有锁时间越长锁竞争程度就越激烈，只对需要同步的方法加锁，可以减小锁持有时间进而提高锁性能。
- 减少锁的持有时间有助于降低锁冲突的可能性，进而提高锁的并发能力。
减小锁粒度：
- 减小锁粒度就是指缩小锁定对象的范围，从而减小锁冲突的可能性，进而提高并发能力。
读写分离锁代替独占锁（锁分离）：
- 使用读写锁可以减少操作之间相互等待，可以有效的提高性能。ConcurrentLinkedQueue中take和put方法分别使用了两个锁避免了锁竞争，提高了性能。
锁粗化：
- 如果一个锁不停的被进行请求、同步和释放，其本身也会消耗系统宝贵的资源，反而不利于性能优化。
- 虚拟机在遇到一连串连续的对同一锁不断进行请求和释放的操作时，便会把所有的操作整合成对锁的一次请求，从而减少锁的请求同步次数，这个操作叫锁粗化
2、Java虚拟机对锁优化所做的努力
锁偏向：
- 如果一个线程获得了锁，那么锁就进入了偏向模式。当这个线程再次请求锁时，无需再做任何同步操作。
- 使用Java虚拟机参数-XX:USerBiasedLocking可以开启偏向锁。
轻量级锁：
- 如果偏向锁失败，虚拟机并不会立即挂起线程，而是使用轻量级锁进行操作。
- 轻量级锁他只是简单的将对象头部作为指针，指向持有锁的线程堆栈的内部，来判断一个线程是否持有对象锁。
- 如果线程获得轻量级锁成功，则可以顺利进入临界区。如果轻量级锁加锁失败，则表示其他线程抢先夺到锁，那么当前线程的轻量级锁就会膨胀为重量级锁。
自旋锁：
- 无法获得锁，不知道什么时候可以获得锁，不会把线程挂起而是让当前线程做几个空循环（这也就是自旋锁的意义）。
- 若经过几个空循环可以获取到锁则进入临界区，如果还是获取不到则系统会真正的挂起线程。
锁消除
- 去除不可能存在共享资源竞争的锁，通过锁消除可以节省毫无意义的请求锁时间。如在不可能存在并发的场合使用vector。
3、ThreadLocal
ThreadLocal的使用：
- ThreadLocal是线程的局部变量，只有当前线程才可以访问，因此是线程安全的。
- ThreadLocal只是起到容器的作用，为每一个线程分配不同对象需要应用层面保证。
package com.ecut.threadlocal; import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; public class ThreadLocalTest {
private static ThreadLocal<SimpleDateFormat> threadLocal = new ThreadLocal<SimpleDateFormat>(); public static class ParseDate implements Runnable {
int i = 0; public ParseDate(int i) {
this.i = i;
} @Override
public void run() {
try {
if (threadLocal.get() == null) {
threadLocal.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
}
Date d = threadLocal.get().parse("2019-03-03 19:36:15");
System.out.println(i + "、" + Thread.currentThread() + ":" + d);
} catch (ParseException e) {
e.printStackTrace();
} // sdf.format(System.currentTimeMillis());
}
} public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);
ParseDate parseDate = new ParseDate(1);
for (int i = 0; i < 10; i++) {
executorService.submit(new ParseDate(i));
}
}
}
ThreadLocal的实现原理：
- 在set时，首先通过getMap()获得当前线程的ThreadLocalMap，并将值设入到这个ThreadLocalMap中，当前线程做为key，需要的值为value。
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
} - 在get时，获得ThreadLocalMap的对象，然后通过将自己做为key 取得相应的数据。
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
} - ThreadLocalMap维护的变量是在Thread内部的，线程不退出对象的引用就会一直存在。使用线程池时线程未必会退出，可能会造成内存泄漏(对象无法回收)，因此最好要使用ThreadLocal的remove方法。
4、无锁
无锁的好处：
- 由于非阻塞性，对死锁天生免疫
- 没有锁竞争带来的系统开销
- 没有锁调度带来的系统开销
CAS算法：
- 包含三个参数CAS(V,E,N)，V表示要被修改的变量，E表示期望值，N表示要设置的值。
- 如果V的值和期望值相等则将V的值设置为N，如果不相等表示V的值已经被其他线程修改了，当前线程不做任何操作。
- 当有多个线程访问的时候只有一个线程成功，其他线程会被告知失败，其他线程可以选择再次执行或者是放弃。
无锁线程安全的整数：
- AtomicInteger相比，它是可变的并且线程安全的。
package com.ecut.atomic; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger; public class AtomicIntegerTest { static AtomicInteger i = new AtomicInteger(); public static class AtomicIntegerThread implements Runnable {
@Override
public void run() {
for (int k = 0; k < 10000; k++) {
i.incrementAndGet();
}
}
} public static void main(String[] args) throws InterruptedException {
AtomicIntegerThread atomicIntegerThread = new AtomicIntegerThread();
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int k = 0 ; k < 10 ; k++){
executorService.submit(atomicIntegerThread);
}
Thread.sleep(500);
/* Thread[] thread = new Thread[10];
for (int k = 0 ; k < 10 ; k++){
thread[k] = new Thread(new AtomicIntegerThread());
}
for (int k = 0 ; k < 10 ; k++){
thread[k].start();
}
for (int k = 0 ; k < 10 ; k++){
thread[k].join();
}*/
System.out.println(i);
}
}increateAndGet的内部使用CAS将新值写入，并且设置失败会不断重试知道成功。
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); return var5;
}
Java中的指针Unsafe类：
- 指针是不安全的，因此Java中去除了指针，但是通过Unsafe类封装了一些不安全操作。我们无法使用这个类。
无锁对象的引用：
- AtomicReference是作用是对”对象”进行原子操作，但是会丢失状态信息
- 如果需要保存状态信息则可以使用AtomicStampedReference，AtomicStampedReference还维护了一个时间戳，当被修改时需要更新数据本身和时间戳。
- AtomicIntegerArray是线程安全的数组
package com.ecut.atomic; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicIntegerArray; public class AtomicIntegerArrayTest {
static AtomicIntegerArray array = new AtomicIntegerArray(10); public static class AtomicIntegerThread implements Runnable {
@Override
public void run() {
for (int k = 0; k < 10000; k++) {
array.getAndIncrement(k % array.length());
}
}
} public static void main(String[] args) throws InterruptedException {
AtomicIntegerThread thread = new AtomicIntegerThread();
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int k = 0; k < 10; k++) {
executorService.submit(thread);
}
Thread.sleep(5000);
System.out.println(array);
}
}运行结果如下：
[10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]
原子操作工具类:
- AtomicIntegerFiedUpdater它可以让你在不改动原有代码的基础上，让普通的变量也享受CAS操作带来的线程安全性。
package com.ecut.atomic; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater; public class AtomicIntegerFieldUpdaterTest { public static AtomicInteger allScore = new AtomicInteger(); public final static AtomicIntegerFieldUpdater<Candidate> socoreUpdater =
AtomicIntegerFieldUpdater.newUpdater(Candidate.class, "score"); public static class Candidate {
int id;
volatile int score;
} public static class Vote implements Runnable { Candidate candidate; public Vote(Candidate candidate) {
this.candidate = candidate;
} @Override
public void run() {
if (Math.random() > 0.4) {
socoreUpdater.incrementAndGet(candidate);
allScore.incrementAndGet();
}
}
} public static void main(String[] args) throws InterruptedException {
Candidate candidate = new Candidate();
Vote vote = new Vote(candidate);
ExecutorService executorService = Executors.newFixedThreadPool(10);
for(int i = 0 ; i < 10000 ; i++){
executorService.execute(vote);
}
Thread.sleep(5000);
System.out.println(allScore+":"+candidate.score);
}
}运行结果如下：
6093:6093
Candidate.score总是和allScore绝对相等，说AtomicIntegerFieldUpdater很好的保证了Candidate.score的线程安全。
- 注意事项：
1、Updater只能修改范围可见的变量，因为Update是通过反射来获取到这个变量的‘’
2、为了确保变量被正确的读取，它必须是volatile类型的。
3、由于CAS是通过对象实例中的偏移量直接进行赋值的，因此不支持statcic字段,Unsafe.objectFieldOffset() 不支持静态变量。
源码地址：
https://github.com/SaberZheng/concurrent-test
转载请于明显处标明出处: