什么是线程安全？
当多个线程访问某个类时，不管这些的线程的执行顺序如何，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。
哈哈书上的解释，还是翻译过来的，看了半天还是觉得有点奇怪。比如说 “类都能表现出正确的行为” 是毛线意思？在网上搜了一番 "线程安全就是说多线程访问同一代码，不会产生不确定的结果" 这样反而跟容易理解，果然读书要么读原版中文书要么读原版英文书，看英文的翻译版真的是蛋疼无比。说到这里，我以前貌似把多线程及线程安全一个根本性问题搞混淆了：所谓的多线程是指多个线程跑同一段代码，所以线程安全的概念是针对于这段代码而言的而不是针对线程。
一个无状态的Servlet
//程序清单2-1 一个无状态的Servelet
@ThreadSafe
public class StatelessFactorizer implements Servlet{
public void service(ServlerRequest req, ServletResponse resp){
BigInteger i = extractFromRequest(req);
BigInteger[] factors = factor(i);
encodeIntoResponse(resp, factors);
}
}
一个基于Servlet的因数分解服务，从请求中提取出数值进行因数分解，然后将结果封装到该Servlet的响应中。这里要理解的是什么是这本书上说道的 “无状态性” ？书上给的解释是： 它即不包含任何域，也不包含任何对其他类中域的引用，计算过程中的临时状态仅存在于线程栈上的局部变量中。这里的域是什么意思？全局变量？ 怎么来理解这句话呢？大概意思就是对于多线程而言，一个类会同时有多个线程来访问，使用里面的方法，那么这个类的全局变量对于这些线程来说实际上是同一个，只有一份来供这些线程操作，那么线程不安全的问题就因此来了呗。而对于局部变量，不同的线程执行同一个类中的方法时，这个方法中的局部变量对于不同的线程来说都是单独的一份，不存在数据共享的问题，所以无状态对象一定是线程安全的。、
原子性
这个简单，就是说一个操作是不可分割的，比如读操作和写操作，而对于下面的递增操作++count就不是原子操作，其操作序列是：读取-修改-写入。
//程序清单2-2 在吗没有同步的情况下统计已处理请求数量的Servlet
@NotThreadSafe
public class UnsafeCountingFactorizer implements Servlet{
private long count=0;
public long getCount(){return count;}
public void service(ServlerRequest req, ServletResponse resp){
BigInteger i=extractFromReqest(req);
BigInteger[] factors=factor(i);
++count;
encodeIntoResponse(resp,factors);
}
}
竞态条件
由于不恰当的执行时序而出现的不正确的结果。说得通俗一点，就是线程A 需要判断一个变量的状态，然后根据这个变量的状态来执行某个操作。在执行这个操作之前，这个变量的状态可能会被其他线程使用，修改。所以是 "竞争状态下的条件"
示例：延迟初始化中的竞态条件
目的是将对象初始化操作推迟到实际使用时才进行，同时要确保只被初始化一次。
//程序清单2-3 延迟初始化中的竞态条件
@NotThreadSafe
public class LazyInitRace{
private ExpensiveObject instace = null;
public ExpensiveObject getInstance(){
if (instace == null) //程序的执行需要判断这个状态，运行的结果的正确与否取决于这个状态的判断，即“先判断后执行”
instace = new ExpensiveObject();
return instance;
}
}
复合操作
要避免竞态条件问题，就必须在某个线程修改该变量时，通过某种方式防止其他线程使用这个变量，从而确保其他线程只能在修改操作完成之前或之后读取和修改状态，而不是在修改状态的过程中。为了实现这种思路，必须将对同一个状态的操作以原子的方式去执行，要么全部执行完，要么完全不执行。即将上面的 “先检查后执行” 和 “读取-修改-写入” 等复合操作变为原子操作。
//程序清单2-4 使用AtomicLong类型的变量来统计已处理请求的数量
@ThreadSafe
public class CountingFactorizer implements Servlet{
private final AtomicLong count = new AtomicLong(0); //初始化AtomicLong实例
public long getCount(){return count;}
public void service(ServletRequest req, ServletResponse resp){
BigInteger i = extractFromRequest(req);
BigInteger[] factors=factor(i);
count.incrementAndGet(); //注意这个方法的使用
encodeIntoResponse(resp, factors);
}
}
在java.util.concurrent.atomic包中包含了一些原子变量类，用于实现在数值和对象引用上的原子状态转换。通过用AtomicLong来代替long类型的计数器，能够确保所有对计数器状态的访问操作都是原子的。使用线程安全对象（如AtomicLong）来管理类的状态（这里类的状态好像指的就是类的全局变量啊，即在多线程操作时能被这些线程共同使用的变量叫做类的状态变量？）
加锁机制
单个状态变量可以通过线程安全对象来管理Servlet的状态以维护Servlet的线程安全性。但如果Servlet中有多个状态变量，那么是否只需添加更多的线程安全状态变量就足够了？答案肯定是否定的了。
public class UnsafeCachingFactorizer implements Servlet{
private final AtomicReference<BigInteger> lastNumber
= new AtomicReference<BigInteger>();
private final AtomicReference<BigInteger> lastFacotrs
= new AtomicReference<BigInteger[]>();
/**
* 将最近的计算结果缓存起来，当两个连续的请求对相同的数值进行因数分解时，可以直接使用上一次
* 的计算结果。需要保存两个状态： 最近执行因数分解的数值以及分解结果
*/
public void service(ServletRequest req, ServletResponse resp){
BigInteger i = extractFromRequest(req);
if(i.equals(lastNumber.get()))
encodeIntoResponse(resp, factors);
else{
BigInteger[] factors = factor(i);
lastNumber.set(i);
lastFactors.set(factors);
encodeIntoResponse(resp, factors);
}
}
}
关于AtomicReference和AtomicLong可以学习下这几篇博文：Java多线程系列--“JUC原子类”04之 AtomicReference原子类 Java多线程系列--“JUC原子类”02之 AtomicLong原子类
上面的方法是不正确的，原因很好理解，原子状态变量变量只能确保对这个状态的操作是原子的，当有多个状态变量时，无法保证对多个状态的变量的操作是原子的。要保持状态的一致性，就需要在单个原子操作中更新所有相关的状态变量。
内置锁
java提供的内置锁机制是同步代码块，包括两部分：一个作为锁的对象的引用，一个作为有这个锁保护的代码块。以关键子synchronized来修饰的方法是一种横跨整个方法体的同步代码块，其中该同步代码块的锁就是方法调用所在的对象。静态的synchronized方法以Class对象作为锁。
现在让我们来改进下之前的因数分解Servlet
//程序清单2-6 这个Servlet能正确地缓存最新的计算结果，但并发性却非常糟糕
@ThreadSafe
public class UnsafeCachingFactorizer implements Servlet{
@GuardedBy("this") private BigInteger lastNumber;
@GuardedBy("this") private BigInteger lastFactors;
public synchronized void service(ServletRequest req, ServletResponse resp){
BigInteger i = extractFromRequest(req);
if(i.equals(lastNumber.get()))
encodeIntoResponse(resp, lastFactors);
else{
BigInteger[] factors = factor(i);
lastNumber = i;
lastFactors = factors;
encodeIntoResponse(resp, factors);
}
}
}
重入
内置锁是可重入的，意思就是如果某个线程试图获得一个已经由它自己持有的锁，那么这个请求就会成功而不会阻塞。重入的一种实现方法是：为每个锁关联一个获取计数值和一个所有者线程。当计数值为0时就认为这个锁没有被任何线程持有。当线程请求一个未被持有的锁时，JVM将记下锁的持有者并且将获取计数值置为1。如果同一个线程再次获取这个锁，计数值将递增，而当线程退出同步代码块时，计数器会相应的递减。当计数值为0时，这个锁将被释放。
//程序清单2-7 如果内置锁不是可重入的， 那么这段代码将发生死锁
publlic class Widget{
public synchronized void doSomething(){
.....
}
}
/**
* 子类改写了父类的synchronized方法，然后调用父类的方法，子类和父类中的doSomething()方法在执行前
* 都会获取Widget上的锁，如果内置锁不可重入则会发生死锁
*/
public class LoggingWidget extends Widget{
public synchronized void doSomething(){
System.put.println(toString()+": calling doSomething";
super.doSomething();
}
}
用锁来保护状态
活跃性与性能
程序2-6的UnsafeCachingFactorizer的同步方式使得并发性十分糟糕。
可以通过缩小同步代码块的作用范围，来确保并发性和线程安全性。
//程序清单2-8 缓存最近执行因数分解的数值及其计算结果的Servlet
@ThreadSafe
publlic class CachedFactorizer implements Servlet{
@GuardedBy("this") private BigInteger lastNumber;
@GuardedBy("this") private BigInteger[] lastFactors;
/**
*引入“命中计数器”和“缓存命中计数器”
*/
@GuardedBy("this") private long hits;
@GuardedBy("this") private long cacheHits;
public synchronized long getHits(){return hits;}
public synchronized double getCacheHitRatio(){
return (double) cacheHits / (double) hits;
}
public void service(ServletRequest req, ServletResponse resp){
BigInteger i = extractFromRequest(req);
BigInteger[] = factors = null;
//下面这个同步代码块负责保护 “判断是否需要返回缓存结果” 这个 先检查后执行 操作
synchronized (this) { //将当前对象作为锁
++hits;
if(i.equals(lastNumber)){
++cacheHits;
factors = lastFactors.clone():
}
}
if(factors == null){
factors = factor(i);
//下面这个代码块负责对 缓存数值和因数分解结果 进行同步更新
synchronized(this){
lastNumber=i;
lastFactors=factors.clone();
}
}
encodeIntoResponse(resp, factors);
}
}
注：当执行时间较长的计算或操作时(如：网络， I/O 等)，一定不要持有锁
来源：https://www.cnblogs.com/f91og/p/6749057.html