《实战Java高并发程序设计》读书笔记四

第四章锁的优化及注意事项

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

转载请于明显处标明出处:

https://www.cnblogs.com/AmyZheng/p/10471171.html

《实战Java高并发程序设计》读书笔记四

相关推荐