并发编程学习笔记（三）——锁的优化

版权声明：本文为博主原创，未经博主允许不得转载。 https://blog.csdn.net/weixin_36904568/article/details/90600570

一：编程优化

• 减少锁的持有时间：只在必要时进行synchronized同步部分方法，避免同步整个方法
• 减少锁的粒度：通过对数据结构分块处理，如果多个线程处理的数据在多个块，则可以并发执行（当系统需要取得全局锁时开销大）
• 读写分离锁：通过对系统功能点的分割，读写分离
• 锁分离：对于不存在竞争关系的方法，可以分离为多个锁
• 锁粗化：对于一连串请求释放锁的操作，整合成对锁的一次请求释放操作

二：虚拟机的优化

• 锁偏向：如果一个线程获得了锁，则当其再次申请锁时无需同步操作（适合没有锁竞争的场合）
• 轻量级锁：将对象头部作为指针，指向持有锁的线程堆栈内部，以此判断线程是否持有对象锁。如果线程获得轻量级锁，则进入临界区，如果没有获得锁，则请求转化为重量级锁
• 自旋锁：避免重量级锁太快挂起，让其做几个空循环，之后如果还无法获得锁，再挂起
• 锁消除：通过对运行上下文的扫描，进行逃逸分析（私有变量无需加锁），去除不可能存在共享资源的锁

三：ThreadLocal

1. 基本概念

线程独自拥有一个局部变量，需要在应用层上保证每一个线程有不同的对象，ThreadLocal起到了容器的作用

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class MyObject {
    String name;

    MyObject(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "MyObject{" + "name='" + name + '\'' + '}';
    }
}

public class ThreadLocalTest {

    static ThreadLocal<MyObject> object = new ThreadLocal<>();

    static class MyThread extends Thread {
        @Override
        public void run() {
            if (object.get() == null) {
                object.set(new MyObject("test"));
            }
            System.out.println(object.get());
        }
    }

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1000; i++) {
            service.submit(new MyThread());
        }
    }
}

2. 原理

（1）设置

将数据写入线程持有的ThreadLocalMap ，键-值=对象-当前值

	/**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

（2）获取值

获取线程的ThreadLocalMap，再将自己作为键，获取对应的值

	/**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
    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();
    }

（3）移除

将对象设置在ThreadLocal中，其实是设置在线程的ThreadLocalMap 中，如果对象没有及时得到清理，那么他将无法回收，造成内存泄露

/**
     * Removes the current thread's value for this thread-local
     * variable.  If this thread-local variable is subsequently
     * {@linkplain #get read} by the current thread, its value will be
     * reinitialized by invoking its {@link #initialValue} method,
     * unless its value is {@linkplain #set set} by the current thread
     * in the interim.  This may result in multiple invocations of the
     * {@code initialValue} method in the current thread.
     *
     * @since 1.5
     */
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

（4）移除全部

手动设置ThreadLocal=null，回收所有变量

static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

当ThreadLocal设为null时，键为空，则当系统对ThreadLocalMap 进行清理时，就会回收所有失效的（弱）键值对

四：无锁

是一种乐观策略，假设对资源的访问时没有冲突的，所有线程都不会被阻塞

1. 并发策略——CAS

（1）定义

CAS(V,E,N)

• V是更新的变量
• E是预期值
• N是新值

仅当V=E时，V的值才会设为N。如果V≠E，说明已经有其他线程修改了，可以再尝试修改。最后CAS返回V的真实值

（2）特点

• 程序复杂
• 避免了死锁，锁之间的影响小，也不会有线程频繁调度的开销

2. 安全包atomic

（1）组成

执行类中的指令时，不会被其他线程打断，直接使用CAS操作

• 基本类型的原子类：AtomicBoolean，AtomicInteger，AtomicLong
• 引用类型的原子类：AtomicReference
• 基本类型数组的原子类：AtomicIntegerArray，AtomicLongArray
• 引用类型数组的原子类：AtomicReferenceArray
• 各种变量的原子类：AtomicLongFieldUpdater，AtomicIntegerFieldUpdate，AtomicReferenceFieldUpdater
• 时间戳的原子类：AtomicStampedReference
• AtomicMarkableReference

（2）AtomicInteger

保证安全的整数操作

扫描二维码关注公众号，回复： 6455976 查看本文章

使用

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicTest {
    static AtomicInteger integer = new AtomicInteger();

    static class MyThread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                integer.incrementAndGet();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            MyThread thread = new MyThread();
            thread.start();
            thread.join();
        }
        System.out.println(integer);
    }
}

原理

//当前实际值
private volatile int value;
//实际值的偏移量
private static final long valueOffset;

//委托给非安全的指针操作
public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

//CAS操作+本地方法
//不断重试，直到对象的当前值var5和偏移量var2相同，CAS操作成功，将结果赋值给var2
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;
    }

（3）AtomicReference

保证修改对象引用的安全性，但是不能确保对象引用不被修改

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

public class AtomicTest {
    static AtomicInteger integer = new AtomicInteger();
    static AtomicReference<Integer> reference = new AtomicReference<>();
    static class MyThread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
//                integer.incrementAndGet();
                Integer m = reference.get();
                reference.compareAndSet(m,m+1);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        reference.set(0);
        for (int i = 0; i < 10; i++) {
            MyThread thread = new MyThread();
            thread.start();
            thread.join();
        }
//        System.out.println(integer);
        System.out.println(reference.get());
    }
}

（4）AtomicStampedReference

带有时间戳的对象引用，在内部不仅维护了对象值，也维护了对象的状态值。当对象被修改时，需要同时修改数据和时间戳。当要修改对象时，需要数据和时间戳都满足期望值

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

public class AtomicTest {
//    static AtomicInteger integer = new AtomicInteger();
//    static AtomicReference<Integer> reference = new AtomicReference<>();
    static AtomicStampedReference<Integer> reference = new AtomicStampedReference<>(0,0);
    static class MyThread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
//                integer.incrementAndGet();
                Integer m = reference.getReference();
                final int stamp = reference.getStamp();
                reference.compareAndSet(m,m+1,stamp,stamp+1);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
//        reference.set(0);
        reference.set(0,0);
        for (int i = 0; i < 10; i++) {
            MyThread thread = new MyThread();
            thread.start();
            thread.join();
        }
//        System.out.println(integer);
        System.out.println(reference.getReference()+" "+reference.getStamp());
    }
}

（5）AtomicIntegerArray

通过CAS方式，控制数组的安全性

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

public class AtomicTest {
//    static AtomicInteger integer = new AtomicInteger();
//    static AtomicReference<Integer> reference = new AtomicReference<>();
    static AtomicIntegerArray array = new AtomicIntegerArray(10);
//    static AtomicStampedReference<Integer> reference = new AtomicStampedReference<>(0,0);
    static class MyThread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
//                integer.incrementAndGet();
//                Integer m = reference.getReference();
//                final int stamp = reference.getStamp();
//                reference.compareAndSet(m,m+1,stamp,stamp+1);
                array.getAndIncrement(i);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
//        reference.set(0);
//        reference.set(0,0);
        for (int i = 0; i < 10; i++) {
            MyThread thread = new MyThread();
            thread.start();
            thread.join();
        }
//        System.out.println(integer);
//        System.out.println(reference.getReference()+" "+reference.getStamp());
        System.out.println(array);
    }
}

（6）AtomicIntegerFieldUpdater

普通变量也可以进行CAS操作，只能修改可见的、volatile类型的变量，不支持static类型

import java.util.concurrent.atomic.*;

public class AtomicTest {
//    static AtomicInteger integer = new AtomicInteger();
//    static AtomicReference<Integer> reference = new AtomicReference<>();
//    static AtomicIntegerArray array = new AtomicIntegerArray(10);
//    static AtomicStampedReference<Integer> reference = new AtomicStampedReference<>(0,0);
    static class MyField {
        volatile int data;
    }
    static AtomicIntegerFieldUpdater<MyField> updater = AtomicIntegerFieldUpdater.newUpdater(MyField.class,"data");
    static class MyThread extends Thread{
        private MyField field;

        public MyThread(MyField field) {
            this.field = field;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
//                integer.incrementAndGet();
//                Integer m = reference.getReference();
//                final int stamp = reference.getStamp();
//                reference.compareAndSet(m,m+1,stamp,stamp+1);
//                array.getAndIncrement(i);
                updater.incrementAndGet(field);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
//        reference.set(0);
//        reference.set(0,0);
        MyField field = new MyField();
        for (int i = 0; i < 10; i++) {
//            MyThread thread = new MyThread();
            MyThread thread = new MyThread(field);
            thread.start();
            thread.join();
        }
//        System.out.println(integer);
//        System.out.println(reference.getReference()+" "+reference.getStamp());
//        System.out.println(array);
        System.out.println(field.data);
    }
}