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等线程安全对象。
