Java高并发--线程安全策略

时间:2023-01-05 18:03:35

Java高并发--线程安全策略

主要是学习慕课网实战视频《Java并发编程入门与高并发面试》的笔记

不可变对象

发布不可变对象可保证线程安全。

实现不可变对象有哪些要注意的地方?比如JDK中的String类。

  • 不提供setter方法(包括修改字段、字段引用到的的对象等方法)
  • 将所有字段设置为final、private
  • 将类修饰为final,不允许子类继承、重写方法。可以将构造函数设为private,通过工厂方法创建。
  • 如果类的字段是对可变对象的引用,不允许修改被引用对象。 1)不提供修改可变对象的方法;2)不共享对可变对象的引用。对于外部传入的可变对象,不保存该引用。如要保存可以保存其复制后的副本;对于内部可变对象,不要返回对象本身,而是返回其复制后的副本。

final关键字可以修饰在类、方法、变量:

  • 类:被修饰的类不能被继承
  • 方法:被修饰的方法不能被重写
  • 变量:被修饰的是一个基本类型,其值不能被修改;被修饰的是一个对象引用,这里的“不可变”指不允许其再指向其他对象,但是可以修改对象里面的值。

关于上一条中final修饰对象的引用。以ArrayList为例

final List<Integer> list= new ArrayList<>();
list.add(3);
list.add(4);
list = new ArrayList<>(); // 编译时报错,不能再指向其他对象
list.set(0, 2); // 但是可以修改list里面的值

假如我们就是要求诸如List、Map一类的数据结构也不能修改其中的元素呢?

JDK中Collections的一些静态方法提供了支持,如下,举一个List的例子

final List<Integer> list= new ArrayList<>();
list.add(3);
list.add(4);
List<Integer> unmodifiableList = Collections.unmodifiableList(list);
System.out.println(unmodifiableList);
unmodifiableList.add(5); // 运行时异常
unmodifiableList.set(0, 2); // 运行时异常

只需要将普通的list传给Collections.unmodifiableList()作为入参即可。

其实现原理也很简单,将普通list中的数据拷贝,然后对于所有添加、修改的操作,直接抛出异常即可,这样就保证了list不能修改其中的元素。

线程安全的问题就是出在多个线程同时修改共享变量,不可变对象的策略完全规避了对对象的修改,所以在多线程中使用也不会有任何问题。

线程封闭

  • 堆栈封闭:能使用局部变量的地方就不使用全局变量,多线程下访问同一个方法时,方法中的局部变量都会拷贝一份到线程的栈中,也就是说每一个线程中都有只属于本线程的私有变量,因此局部变量不会被多个线程共享。
  • ThreadLocal:特别好的线程封闭方法,其实现原理如下

对于共享变量,一般采取同步的方式保证线程安全。而ThreadLocal是为每一个线程都提供了一个线程内的局部变量,每个线程只能访问到属于它的副本。

下面是set和get的实现

// set方法
public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

// 上面的getMap方法
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

// get方法
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,这个map存储了该线程拥有的所有局部变量。

set时先通过Thread.currentThread()获取当前线程,进而获取到当前线程的ThreadLocalMap,然后以ThreadLocal自己为key,要存储的对象为值,存到当前线程的ThreadLocalMap中。

get时也是先获得当前线程的ThreadLocalMap,以ThreadLocal自己为key,取出和该线程的局部变量。

题话外,一个线程内可以设置多个ThreadLocal,这样该线程就拥有了多个局部变量。比如当前线程为t1,在t1内创建了两个ThreadLocal分别是tl1和tl2,那么t1的ThreadLocalMap就有两个键值对。

t1.threadLocals.set(tl1, obj1) // 等价于在t1线程中调用tl1.set(obj1)
t1.threadLocals.set(tl2, obj2) // 等价于在t1线程中调用tl2.set(obj1)

t1.threadLocals.getEntry(tl1) // 等价于在t1线程中调用tl1.get()获得obj1
t1.threadLocals.getEntry(tl2) // 等价于在t1线程中调用tl2.get()获得obj2

以一个角色验证的例子为例,为每一个请求(线程)保存了当前访问人的角色。比如有guest和admin。

public class CurrentUserHolder {
    private static final ThreadLocal<String> holder = new ThreadLocal<>();

    public static void setUserHolder(String user) {
        holder.set(user);
    }

    public static String getUserHolder() {
        return holder.get();
    }
}

在进行某些敏感操作前,需要对当前请求下的角色进行验证。游客是没有访问权限的,只有管理员可以。

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;


@Component
public class AuthService {
    public void checkAccess() {
        // 通过ThreadLocal取得当前线程(请求)中的角色
        String user = CurrentUserHolder.getUserHolder();
        if (!"admin".equals(user)) {
            throw new RuntimeException("操作不被允许!");
        }
    }
}

操作前的验证使用AOP过滤

import com.shy.aopdemo.security.AuthService;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class AuthAspect {
    @Autowired
    private AuthService authService;
    @Pointcut("execution(* com.shy.aopdemo.service.ProductService.*(..))")
    public void adminOnly() {}

    @Before("adminOnly()")
    public void checkAccess() {
        authService.checkAccess();
    }
}

测试一下,如果当前请求的角色是guest

import com.shy.aopdemo.security.CurrentUserHolder;
import com.shy.aopdemo.service.ProductService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class AopdemoApplicationTests {
    @Autowired
    private ProductService productService;
    @Test
    public void checkDeleteTest() {
        // 当前请求的角色是guest
        CurrentUserHolder.setUserHolder("guest");
        // AOP,在delete之前会先调用authService.checkAccess();结果验证不通过
        productService.delete(1L);
    }
}

总结

安全共享对象的策略

  • 线程限制:一个被线程限制的对象,由线程独占;只能由它的线程来修改,例如使用线程内的局部变量、ThreadLocal等
  • 共享只读:只读对象在没有额外同步的情况下,可以被多个线程并发访问,但是任何线程都无法修改它。例如,使用不可变对象(final关键字修饰)
  • 线程安全的对象:一个线程按安全的对象或容器,通过内部的同步机制来保证线程安全。比如StringBuffer、ConcurrentHashMap、AtomicInteger等线程安全对象。