什么是线程安全？

Posted 2023-05-16

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了什么是线程安全？相关的知识，希望对你有一定的参考价值。

线程安全是多线程编程时的计算机程序代码中的一个概念。在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。

当对一个复杂对象进行某种操作时，从操作开始到操作结束，被操作的对象往往会经历若干非法的中间状态。调用一个函数（假设该函数是正确的）操作某对象常常会使该对象暂时陷入不可用的状态（通常称为不稳定状态），等到操作完全结束，该对象才会重新回到完全可用的状态。

如果其他线程企图访问一个处于不可用状态的对象，该对象将不能正确响应从而产生无法预料的结果，如何避免这种情况发生是线程安全性的核心问题。

扩展资料：

简单类比

线程安全性问题跟外科医生做手术有点象，尽管手术的目的是改善患者的健康，但医生把手术过程分成了几个步骤，每个步骤如果不是完全结束的话，都会严重损害患者的健康。

想想看，如果一个医生切开患者的胸腔后要休三周假会怎么样？然而单线程的程序中是不存在这种问题的，因为在一个线程更新某对象的时候不会有其他线程也去操作同一个对象。

（除非其中有异常，异常是可能导致上述问题的。当一个正在更新某对象的线程因异常而中断更新过程后，再去访问没有完全更新的对象，会出现同样的问题）

参考技术A 线程安全是指如果在进程中有多个线程同时运营，而这些线程同时运行一段代码，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不使得每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的。参考技术B “线程安全是多线程编程时的计算机程序代码中的一个概念。在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。” 参考技术C 线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。
线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据
线程安全就是说多线程访问同一代码，不会产生不确定的结果。编写线程安全的代码是低依靠线程同步。
在接口方式中，线程有一个共享的数据成员，即：
private int count =10;
而在继承方式中，线程之间没有共享的成员，而是各线程各自有一个私有成员，即： private
int count
=10;
在多线程环境中，当各线程不共享数据的时候，那么一定是线程安全的。问题是这种情况并不多见，在多数情况下需要共享数据，这时就需要进行适当的同步控制了。
线程安全一般都涉及到synchronized就是一段代码同时只能有一个线程来操作，不然中间过程可能会产生不可预制的结果。

什么是线程安全性？

定义：当多个线程访问某个类时，这个类始终都能表现出正确的行为，那么久称这个类时线程安全的。

解释：当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，

并且在主调代码中不需要任何额外的同步或者协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。

在线程安全类中封装了必要的同步机制，因此客户端无需进一步采取同步措施。

实例：一个无状态的Servlet

@ThreadSafe
public class SafeThreadTest implements Servlet{
    public void service(ServletRequest req,ServletResponse resp){
        BigInteger i=extractFromRequest(req);
        BigInteger[] factors=factor(i);
        encodeIntoRespose(resp,factors);      
    }
}

这个Servlet将请求参数经过提取数值，然后转换后再封装到Servlet的响应中。

这个Servlet与大多数的Servlet相同，SafeThreadTest是无状态的，它不包含包域，也不包含对其他类的域的引用。

计算的过程中的局部变量只存在执行的线程的栈上，访问SafeThreadTest不会影响同一访问该Servlet的另一个线程

的计算结果。所以无状态的对象一定是线程安全的。

实例：一个有状态的Servlet

@NotThreadSafe
public class UnsafeThreadTest implements Servlet{
    private long count=0;

    public long getCount(){return count;}

    public void service(ServletRequest req,ServletResponse resp){
        BigInteger i=extractFromRequest(req);
        BigInteger[] factors=factor(i);
        count++;
        encodeIntoRespose(resp,factors);      
    }
}

我们增加一个统计请求数量，给这个Servlet增加了一个状态，UnsafeThreadTest并非是一个线程安全的，尽管它在单线程中能正确运行。

这个类很可能丢失一些更新操作，看上去这是一个操作，但是这个操作丢失了原子性。实际上它包含了三个独立的操作：读取count，将值+1，

然后将结果写入count，这是一个“读取-->修改-->写入”的操作序列，并且其结果取决于之前的状态。

　　如果在某些情况下，多个线程同时读取到值为10，当都加1，写入11.这样数值将会偏差好多。在并发编程中，这种由于不恰当的执行时序而出现

不正确的结果是一种非常重要的情况，它有一个正式的名字：竞争条件（Race Codition）

竞争条件：当某个计算的正确性取决于多个线程的交替执行时序时，那么就会发生竞争条件（就是说正确的结果要取决于运气）。最常见的竞争类型就是

“先检查后执行（Check-Then-Act）操作”，即通过一个可能失效的观测的结果来决定于下一步动作。

实例：延迟初始化中的竞争条件

@NotThreadSafe
public class LazyInitRace{
  private ExprensiveObject instance =null;

  public   ExprensiveObject getInstance(){
    if(instance==null)
        instance=new ExprensiveObject();
        return instance;
    }

}

如果两个线程同时执行，都产生一个实例，这样实例完全不同了。与大多数并发错误一样，竞争条件并不是总是产生错误的，还需要某种不恰当的执行时序。

复合操作：以上的两个含有竞争条件的实例，都需要包含一组需要以原子方式执行（或者说不可分割）的操作。

原子性操作：操作A和B,如果从执行A的线程来看，当另一个线程执行B,要么将B完全执行完，要么完全不执行B,那么A和B对彼此来说是原子的。

我们使用AtomicLong类型变量来统计已经处理请求数量

@ThreadSafe
public class CountSafeThreadTest implements Servlet{
    private final AtomicLong count=new AtomicLong(0);

    public long getCount(){return count.get();}

    public void service(ServletRequest req,ServletResponse resp){
        BigInteger i=extractFromRequest(req);
        BigInteger[] factors=factor(i);
        count.incrementAndGet();
        encodeIntoRespose(resp,factors);      
    }
}