java多线程之线程的安全性(一)

对象的状态：对象的状态是指存储在状态变量（实例或静态域）中的数据。对象的状态还可能包括其他依赖对象的域。例如，HashMap的状态不仅储存在对象本身，还储存在Map.Entry对象中。

多线程安全的概念：当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，那么这个类就是线程安全的。

多线程安全的核心：编写线程安全的代码，核心在于要对状态访问操作进行管理，特别是对共享的（Shared）和可变的（Mutable）状态的访问。

 

1.无状态对象线程安全

如例子中的因式分解Servlet：

public class StatelessFactorizer implement Servlet{    public void service(ServletRequest req,ServletResponse resp){        BigInteger i = extractFromRequest(req);        BingInteger []factorys = factor(i);        encodeingIntoResponse(req,factorys);    }}

它既不包含任何域，也不包含其他类中域的引用，所以他是无状态的。因此每个线程执行的结果不会影响到其他线程。

 

2.尽可能使用现有的线程安全对象管理状态

下面是访问一次count+1的例子:

public class UnsafeCountingFactorizer implement Servlet{    private long count = 0;    public long getCount(){        return count;    }    public void service(ServletRequest req,ServletResponse resp){        count++;        BigInteger i = extractFromRequest(req);        BingInteger []factorys = factor(i);        encodeingIntoResponse(req,factorys);    }}

count++的操作是 读取count的值 count+1 写入count 三步，如果线程1执行到第二步还没写入count的时候，线程2开始执行了第一步，那么线程2读取的count是线程1还没赋值的count，于是就出现的线程安全问题。
下面是解决方法：

public class SafeCountingFactorizer implement Servlet{    private final AtomicLong count = new AtomicLong(0);     public long getCount(){        return count.get(0);    }    public void service(ServletRequest req,ServletResponse resp){        count.incrementAndGet();        BigInteger i = extractFromRequest(req);        BingInteger []factorys = factor(i);        encodeingIntoResponse(req,factorys);    }}

通过用AtomicLong来代替long类型的计数器，能够确保所有对计数器状态的访问操作都是原子的。由于Servlet的状态只有一个，也就是计数器的状态，所以这个Servlet是线程安全的。

3.防止竞态条件的出现

竞态条件：由于不恰当的执行时序而出现不正确的结果。常见的情况是延迟初始化。

public class LazyInitRace{    private ExpensiveObject instance = null;    public ExpensiveObject getInstance(){        if(instance == null){            instance = new ExpensiveObject();        }        return instance;    }}

上面的竞态条件很容易出现线程安全问题，如果线程1和2同时进入if语句，那么这个单例模式不能达到它想要的效果。
下面是解决方法：

public class LazyInitRace{    private static final Object obj = new Object();     private ExpensiveObject instance = null;    public ExpensiveObject getInstance(){        if(instance == null){            Synchronized(obj){                if(instance == null){                    instance = new ExpensiveObject();                    }            }        }        return instance;    }}

这叫双重锁，他能保证new只会执行一次，保证了执行顺序，所以竞态条件就不存在了。而且我们要保证这个锁是同一个锁。

4.对于多个变量的不变性条件，涉及的所有变量需要同一个锁保护。

下面的例子是缓存因式分解结果，如果传入值相同，返回缓存值。

public class UnSafeCountingFactorizer implement Servlet{    //最后一次传入的值    private final AtomicReferece<BigInteger> lastNumber = new AtomicReference<Integer>();    //最后一次传入的缓存    private final AtomicReferece<BigInteger[]> lastFactors = new AtomicReference<Integer[]>();    public void service(ServletRequest req,ServletResponse resp){        BigInteger i = extractFromRequest(req);        if(i.equals(lastNumber)){            encodeingIntoResponse(req,factorys);        }else{            BingInteger []factorys = factor(i);            lastFactors.set(factors);            lastNumber.set(i);            encodeingIntoResponse(req,factorys);        }    }}

上面的例子，两个状态都是能保证原子性的，但是不变性条件同时包含两个状态，也就是只修改其中一个变量，那么在两次修改操作之间，其他线程将发现不变性条件被破坏了。
解决方法：

public class UnSafeCountingFactorizer implement Servlet{    //最后一次传入的值    private final AtomicReferece<BigInteger> lastNumber = new AtomicReference<Integer>();    //最后一次传入的缓存    private final AtomicReferece<BigInteger[]> lastFactors = new AtomicReference<Integer[]>();    public void service(ServletRequest req,ServletResponse resp){        BigInteger i = extractFromRequest(req);        BigInteger []factors = null;        Synchronized(this){            if(i.equals(lastNumber)){                factors = lastFactors.clone();            }        }        if(factors == null){            factors = factor(i);            Synchronized(this){                lastNumber = i;                lastFactorys = factors.chone();            }        }        encodeingIntoResponse(req,factorys);        }    }}

重新构造了这个类之后，实现了简单性和并发性的平衡，把同步代码全部方法放在一个Synchronized可能会影响效率，而将同步代码块分解太小会影响简单行和可读性。

5.占资源太多的操作不要持有锁

例如，当一个程序执行时间太长或者占有cpu资源太大，很可能会受到其他因素的影响，导致长时间持有锁，导致其他进程长时间发生阻塞。