《java并发编程实战》读书笔记1--线程安全性,内置锁,重入,状态

Posted f91og

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了《java并发编程实战》读书笔记1--线程安全性,内置锁,重入,状态相关的知识,希望对你有一定的参考价值。

什么是线程安全?

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

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

一个无状态的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 等),一定不要持有锁

以上是关于《java并发编程实战》读书笔记1--线程安全性,内置锁,重入,状态的主要内容,如果未能解决你的问题,请参考以下文章

Java并发编程实战读书笔记

Java并发编程实战读书笔记

《Java并发编程实战》读书笔记

《Java并发编程实战》读书笔记

《Java并发编程实战》第四章 对象的组合 读书笔记

《java并发编程实战》读书笔记2--对象的共享,可见性,安全发布,线程封闭,不变性