java并发编程-线程安全

概述

并发编程，即多条线程在同一时间段内“同时”运行。

在多处理器系统已经普及的今天，多线程能发挥出其优势，如：一个8核cpu的服务器，如果只使用单线程的话，将有7个处理器被闲置，只能发挥出服务器八分之一的能力（忽略其它资源占用情况）。
同时，使用多线程，可以简化我们对复杂任务的处理逻辑，降低业务模型的复杂程度。

因此并发编程对于提高服务器的资源利用率、提高系统吞吐量、降低编码难度等方面起着至关重要的作用。

以上是并发编程的优点，但是它同样引入了一个很重要的问题：线程安全。

什么是线程安全问题

线程在并发执行时，因为cpu的调度等原因，线程会交替执行。如下图例子所示

[Java] 纯文本查看 复制代码

public class SelfIncremental {
    private static int count;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                count++;
                System.out.println(count);

            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                count++;
                System.out.println(count);

            }
        });

        thread1.start();
        thread2.start();
    }
}

执行完毕后count的值并不是每次都能等于20000，会出现小于20000的情况，原因是thread1和thread2可能会交替执行。

如图所示：

• t1时刻: thread1 读取到count=100
• t2时刻: thread2 读取到count=100
• t3时刻: thread1 对count+1
• t4时刻: thread2 对count+1
• t5时刻: thread1 将101写入count
• t5时刻: thread2 将101写入count
  

因为count++ 不是一个原子操作，实际上会执行三步：

• 1、获取count的值
• 2、将count加1
• 3、将计算结果写入count
  

因此在并发执行时，两个线程同时读，可能会读取到相同的值，对相同的值加一，导致结果不符合预期，这种情况就是线程不安全。

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

引发原因

引发线程安全性问题的原因主要是共享内存可以被多个线程读写，因为读取和修改时机存在不确定性，导致有线程读到了过期数据，并在脏数据的基础上处理后写回共享内存，产生了错误的结果。

竟态条件

在并发编程中，因为不恰当的执行时序而出现不正确的结果的情况被称为竟态条件。

常见的静态条件类型：

• 先检查后执行：首先观察到某个条件为真。根据这个观察结果采用相应的动作，但实际上在你观察到这个结果和采用相应动作之间，观察的结果可能发生改变变得无效，导致后续的所有操作都变得不可预期。（比如延迟初始化）
• 读取-修改-写入：基于对象之前的状态来定义对象状态的转换。但在读取到结果和修改之间，对象可能已被更改。这样就会基于错误的数据修改得出错误的结果并被写入。（比如递增操作）
  

发布与逸出

发布：使对象能够在当前作用域之外的代码中使用。如将该对象的引用保存到其它代码可以访问的地方、在一个非私有的方法中返回该引用，将引用传递到其它类的方法中。如：

[Java] 纯文本查看 复制代码

public static Student student；

public void init() { 
    student = new Student;
}

这里 student对象就被发布了。

逸出：当不该被发布的对象被发布了，就称为逸出。如

[Java] 纯文本查看 复制代码

private String name = "xxx";

public String getString() {
    return name;
}

这里name原为private类型但是却被getString方法发布了，就可以被视为逸出。

如何避免线程封闭

线程封闭的对象只能由一个线程拥有，对象被封闭在该线程中，并且只有这个对象能修改。

线程封闭即不共享数据，仅在单线程内访问数据，这是实现线程安全最简单的方式之一。
实现线程封闭可以通过：

• Ad-hoc线程封闭：即维护线程封闭性的职责完全由成熟实现承担。
• 栈封闭：通过局部变量才能访问对象，该局部变量被保存在执行线程的栈中，其他线程无法访问。
• ThreadLocal类：将共享的全局变量转换为ThreadLocal对象，当线程终止后，这些值会被垃圾回收。
  

只读共享

在没有额外同步的情况下，共享的对象可以由多个线程并发访问，但是任何线程都不能修改。共享的对象包括不可变对象和事实不可变对象。

不可变对象：如果某个对象在被创建后就不能修改，那么这个对象就是不可变对象。不可变对象一定是线程安全的。

线程安全共享

线程安全的对象在其内部实现同步，因此多线程可以通过对象的公有接口来进行访问而不需要自己做同步。

保护对象

被保护的对象只能通过持有特定的锁来访问。即通过加锁机制，确保对象的可见性及原子性。

• 内置锁：即通过synchronized关键字同步代码块。线程在进入同步代码块之前会自动获得锁，并在退出同步代码块时自动释放锁。内置锁是一种互斥锁。
• 重入锁：当线程视图获取一个已经持有的锁时，就会给锁的计数器加一，释放锁时计数器会减一。当计数器为0时，释放锁
• volatile：访问volatile变量时，不会加锁，也不会阻塞线程执行。他只确保变量的可见性，是一种比synchronized更轻量级的同步机制。
  

java并发编程-线程安全

概述

并发编程，即多条线程在同一时间段内“同时”运行。

在多处理器系统已经普及的今天，多线程能发挥出其优势，如：一个8核cpu的服务器，如果只使用单线程的话，将有7个处理器被闲置，只能发挥出服务器八分之一的能力（忽略其它资源占用情况）。
同时，使用多线程，可以简化我们对复杂任务的处理逻辑，降低业务模型的复杂程度。

因此并发编程对于提高服务器的资源利用率、提高系统吞吐量、降低编码难度等方面起着至关重要的作用。

以上是并发编程的优点，但是它同样引入了一个很重要的问题：线程安全。

什么是线程安全问题

线程在并发执行时，因为cpu的调度等原因，线程会交替执行。如下图例子所示

[Java] 纯文本查看 复制代码

public class SelfIncremental {
    private static int count;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                count++;
                System.out.println(count);

            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                count++;
                System.out.println(count);

            }
        });

        thread1.start();
        thread2.start();
    }
}

执行完毕后count的值并不是每次都能等于20000，会出现小于20000的情况，原因是thread1和thread2可能会交替执行。

如图所示：

• t1时刻: thread1 读取到count=100
• t2时刻: thread2 读取到count=100
• t3时刻: thread1 对count+1
• t4时刻: thread2 对count+1
• t5时刻: thread1 将101写入count
• t5时刻: thread2 将101写入count
  

因为count++ 不是一个原子操作，实际上会执行三步：

• 1、获取count的值
• 2、将count加1
• 3、将计算结果写入count
  

因此在并发执行时，两个线程同时读，可能会读取到相同的值，对相同的值加一，导致结果不符合预期，这种情况就是线程不安全。

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

引发原因

引发线程安全性问题的原因主要是共享内存可以被多个线程读写，因为读取和修改时机存在不确定性，导致有线程读到了过期数据，并在脏数据的基础上处理后写回共享内存，产生了错误的结果。

竟态条件

在并发编程中，因为不恰当的执行时序而出现不正确的结果的情况被称为竟态条件。

常见的静态条件类型：

• 先检查后执行：首先观察到某个条件为真。根据这个观察结果采用相应的动作，但实际上在你观察到这个结果和采用相应动作之间，观察的结果可能发生改变变得无效，导致后续的所有操作都变得不可预期。（比如延迟初始化）
• 读取-修改-写入：基于对象之前的状态来定义对象状态的转换。但在读取到结果和修改之间，对象可能已被更改。这样就会基于错误的数据修改得出错误的结果并被写入。（比如递增操作）
  

发布与逸出

发布：使对象能够在当前作用域之外的代码中使用。如将该对象的引用保存到其它代码可以访问的地方、在一个非私有的方法中返回该引用，将引用传递到其它类的方法中。如：

[Java] 纯文本查看 复制代码

public static Student student；

public void init() { 
    student = new Student;
}

这里 student对象就被发布了。

逸出：当不该被发布的对象被发布了，就称为逸出。如

[Java] 纯文本查看 复制代码

private String name = "xxx";

public String getString() {
    return name;
}

这里name原为private类型但是却被getString方法发布了，就可以被视为逸出。

如何避免线程封闭

线程封闭的对象只能由一个线程拥有，对象被封闭在该线程中，并且只有这个对象能修改。

线程封闭即不共享数据，仅在单线程内访问数据，这是实现线程安全最简单的方式之一。
实现线程封闭可以通过：

• Ad-hoc线程封闭：即维护线程封闭性的职责完全由成熟实现承担。
• 栈封闭：通过局部变量才能访问对象，该局部变量被保存在执行线程的栈中，其他线程无法访问。
• ThreadLocal类：将共享的全局变量转换为ThreadLocal对象，当线程终止后，这些值会被垃圾回收。
  

只读共享

在没有额外同步的情况下，共享的对象可以由多个线程并发访问，但是任何线程都不能修改。共享的对象包括不可变对象和事实不可变对象。

不可变对象：如果某个对象在被创建后就不能修改，那么这个对象就是不可变对象。不可变对象一定是线程安全的。

线程安全共享

线程安全的对象在其内部实现同步，因此多线程可以通过对象的公有接口来进行访问而不需要自己做同步。

保护对象

被保护的对象只能通过持有特定的锁来访问。即通过加锁机制，确保对象的可见性及原子性。

• 内置锁：即通过synchronized关键字同步代码块。线程在进入同步代码块之前会自动获得锁，并在退出同步代码块时自动释放锁。内置锁是一种互斥锁。
• 重入锁：当线程视图获取一个已经持有的锁时，就会给锁的计数器加一，释放锁时计数器会减一。当计数器为0时，释放锁
• volatile：访问volatile变量时，不会加锁，也不会阻塞线程执行。他只确保变量的可见性，是一种比synchronized更轻量级的同步机制。