atomiclong 初始化_《java并发编程实战》读书笔记1--线程安全性，内置锁，重入，状态,Java多线程系列--“JUC原子类”04之 AtomicReference原子类,Java多线程系...

什么是线程安全？

当多个线程访问某个类时，不管这些的线程的执行顺序如何，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。

哈哈书上的解释，还是翻译过来的，看了半天还是觉得有点奇怪。比如说 “类都能表现出正确的行为” 是毛线意思？在网上搜了一番 “线程安全就是说多线程访问同一代码，不会产生不确定的结果” 这样反而跟容易理解，果然读书要么读原版中文书要么读原版英文书，看英文的翻译版真的是蛋疼无比。说到这里，我以前貌似把多线程及线程安全一个根本性问题搞混淆了：所谓的多线程是指多个线程跑同一段代码，所以线程安全的概念是针对于这段代码而言的而不是针对线程。

一个无状态的Servlet

//程序清单2-1 一个无状态的Servelet

@ThreadSafepublic class StatelessFactorizer implementsServlet{public voidservice(ServlerRequest req, ServletResponse resp){ BigInteger i=extractFromRequest(req); BigInteger[] factors=factor(i); encodeIntoResponse(resp, factors); } }

一个基于Servlet的因数分解服务，从请求中提取出数值进行因数分解，然后将结果封装到该Servlet的响应中。这里要理解的是什么是这本书上说道的 “无状态性”？书上给的解释是： 它即不包含任何域，也不包含任何对其他类中域的引用，计算过程中的临时状态仅存在于线程栈上的局部变量中。这里的域是什么意思？全局变量？ 怎么来理解这句话呢？大概意思就是对于多线程而言，一个类会同时有多个线程来访问，使用里面的方法，那么这个类的全局变量对于这些线程来说实际上是同一个，只有一份来供这些线程操作，那么线程不安全的问题就因此来了呗。而对于局部变量，不同的线程执行同一个类中的方法时，这个方法中的局部变量对于不同的线程来说都是单独的一份，不存在数据共享的问题，所以无状态对象一定是线程安全的。、

原子性

这个简单，就是说一个操作是不可分割的，比如读操作和写操作，而对于下面的递增操作++count就不是原子操作，其操作序列是：读取-修改-写入。

//程序清单2-2 在吗没有同步的情况下统计已处理请求数量的Servlet

@NotThreadSafepublic class UnsafeCountingFactorizer implementsServlet{private long count=0;public long getCount(){returncount;}public voidservice(ServlerRequest req, ServletResponse resp){ BigInteger i=extractFromReqest(req); BigInteger[] factors=factor(i);++count; encodeIntoResponse(resp,factors); } }

竞态条件

由于不恰当的执行时序而出现的不正确的结果。说得通俗一点，就是线程A 需要判断一个变量的状态，然后根据这个变量的状态来执行某个操作。在执行这个操作之前，这个变量的状态可能会被其他线程使用，修改。所以是 “竞争状态下的条件”

示例：延迟初始化中的竞态条件

目的是将对象初始化操作推迟到实际使用时才进行，同时要确保只被初始化一次。

//程序清单2-3 延迟初始化中的竞态条件

@NotThreadSafepublic classLazyInitRace{private ExpensiveObject instace = null;publicExpensiveObject getInstance(){if (instace == null) //程序的执行需要判断这个状态，运行的结果的正确与否取决于这个状态的判断，即“先判断后执行”

instace = newExpensiveObject();returninstance; } }

复合操作

要避免竞态条件问题，就必须在某个线程修改该变量时，通过某种方式防止其他线程使用这个变量，从而确保其他线程只能在修改操作完成之前或之后读取和修改状态，而不是在修改状态的过程中。为了实现这种思路，必须将对同一个状态的操作以原子的方式去执行，要么全部执行完，要么完全不执行。即将上面的 “先检查后执行” 和 “读取-修改-写入” 等复合操作变为原子操作。

//程序清单2-4 使用AtomicLong类型的变量来统计已处理请求的数量

@ThreadSafepublic class CountingFactorizer implementsServlet{private final AtomicLong count = new AtomicLong(0); //初始化AtomicLong实例

public long getCount(){returncount;}public voidservice(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 implementsServlet{private final AtomicReferencelastNumber= new AtomicReference();private final AtomicReferencelastFacotrs= new AtomicReference();/*** 将最近的计算结果缓存起来，当两个连续的请求对相同的数值进行因数分解时，可以直接使用上一次 * 的计算结果。需要保存两个状态： 最近执行因数分解的数值以及分解结果*/

public voidservice(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); } } }

上面的方法是不正确的，原因很好理解，原子状态变量变量只能确保对这个状态的操作是原子的，当有多个状态变量时，无法保证对多个状态的变量的操作是原子的。要保持状态的一致性，就需要在单个原子操作中更新所有相关的状态变量。

内置锁

java提供的内置锁机制是同步代码块，包括两部分：一个作为锁的对象的引用，一个作为有这个锁保护的代码块。以关键子synchronized来修饰的方法是一种横跨整个方法体的同步代码块，其中该同步代码块的锁就是方法调用所在的对象。静态的synchronized方法以Class对象作为锁。

现在让我们来改进下之前的因数分解Servlet

//程序清单2-6 这个Servlet能正确地缓存最新的计算结果，但并发性却非常糟糕

@ThreadSafepublic class UnsafeCachingFactorizer implementsServlet{ @GuardedBy("this") privateBigInteger lastNumber; @GuardedBy("this") privateBigInteger lastFactors;public synchronized voidservice(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 classWidget{public synchronized voiddoSomething(){ ..... } }/*** 子类改写了父类的synchronized方法，然后调用父类的方法，子类和父类中的doSomething()方法在执行前 * 都会获取Widget上的锁，如果内置锁不可重入则会发生死锁*/

public class LoggingWidget extendsWidget{public synchronized voiddoSomething(){ System.put.println(toString()+": calling doSomething";super.doSomething(); } }

用锁来保护状态

活跃性与性能

程序2-6的UnsafeCachingFactorizer的同步方式使得并发性十分糟糕。

可以通过缩小同步代码块的作用范围，来确保并发性和线程安全性。

//程序清单2-8 缓存最近执行因数分解的数值及其计算结果的Servlet

@ThreadSafe publlicclass CachedFactorizer implementsServlet{ @GuardedBy("this") privateBigInteger lastNumber; @GuardedBy("this") privateBigInteger[] lastFactors;/***引入“命中计数器”和“缓存命中计数器”*/@GuardedBy("this") private longhits; @GuardedBy("this") private longcacheHits;public synchronized long getHits(){returnhits;}public synchronized doublegetCacheHitRatio(){return (double) cacheHits / (double) hits; }public voidservice(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 等)，一定不要持有锁