java多线程之线程的安全性(一)_多线程的安全性包括()-优快云博客

本文介绍了多线程安全的核心概念及实现方法，包括无状态对象、使用线程安全对象管理状态、防止竞态条件出现、保护多个变量不变性条件及避免长时间持有锁等五个关键点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

对象的状态：对象的状态是指存储在状态变量（实例或静态域）中的数据。对象的状态还可能包括其他依赖对象的域。例如，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);
        }
    }
}