万字详解 Java 线程安全,面试必备!(java线程安全什么意思)

  本篇文章为你整理了万字详解 Java 线程安全,面试必备!(java线程安全什么意思)的详细内容,包含有java的线程安全 java线程安全什么意思 java 线程安全问题 java什么叫线程安全 万字详解 Java 线程安全,面试必备!,希望能帮助你了解 万字详解 Java 线程安全,面试必备!。

  分享Java技术,高并发编程,分布式技术,架构设计,Java面试题,算法,行业动态,程序人生等。

  
Java线程安全:狭义地认为是多线程之间共享数据的访问。

  Java语言中各种操作共享的数据有5种类型:不可变、绝对线程安全、相对线程安全、线程兼容、线程独立

  ① 不可变

  不可变(Immutable) 的对象一定是线程安全的,不需要再采取任何的线程安全保障措施。

  只要能正确构建一个不可变对象,该对象永远不会在多个线程之间出现不一致的状态。

  多线程环境下,应当尽量使对象成为不可变,来满足线程安全。

  如何实现不可变?

  如果共享数据是基本数据类型,使用final关键字对其进行修饰,就可以保证它是不可变的。

  如果共享数据是一个对象,要保证对象的行为不会对其状态产生任何影响。

  String是不可变的,对其进行substring()、replace()、concat()等操作,返回的是新的String对象,原始的String对象的值不受影响。而如果对StringBuffer或者StringBuilder对象进行substring()、replace()、append()等操作,直接对原对象的值进行改变。

  要构建不可变对象,需要将内部状态变量定义为final类型。如java.lang.Integer类中将value定义为final类型。

  Java 面试题最全整理:https://www.javastack.cn/mst/

  

private final int value;

 

  

 

  常见的不可变的类型:

  final关键字修饰的基本数据类型

  枚举类型、String类型

  常见的包装类型:Short、Integer、Long、Float、Double、Byte、Character等

  大数据类型:BigInteger、BigDecimal

  
对于集合类型,可以使用 Collections.unmodifiableXXX() 方法来获取一个不可变的集合。

  通过Collections.unmodifiableMap(map)获的一个不可变的Map类型。

  Collections.unmodifiableXXX() 先对原始的集合进行拷贝,需要对集合进行修改的方法都直接抛出异常。

  例如,如果获得的不可变map对象进行put()、remove()、clear()操作,则会抛出UnsupportedOperationException异常。

  ② 绝对线程安全

  绝对线程安全的实现,通常需要付出很大的、甚至不切实际的代价。

  Java API中提供的线程安全,大多数都不是绝对线程安全。

  例如,对于数组集合Vector的操作,如get()、add()、remove()都是有synchronized关键字修饰。有时调用时也需要手动添加同步手段,保证多线程的安全。

  下面的代码看似不需要同步,实际运行过程中会报错。

  

import java.util.Vector;

 

   * @Author: lucy

   * @Version 1.0

  public class VectorTest {

   public static void main(String[] args) {

   Vector Integer vector = new Vector ();

   while(true){

   for (int i = 0; i i++) {

   vector.add(i);

   new Thread(new Runnable() {

   @Override

   public void run() {

   for (int i = 0; i vector.size(); i++) {

   System.out.println("获取vector的第" + i + "个元素: " + vector.get(i));

   }).start();

   new Thread(new Runnable() {

   @Override

   public void run() {

   for (int i=0;i vector.size();i++){

   System.out.println("删除vector中的第" + i+"个元素");

   vector.remove(i);

   }).start();

   while (Thread.activeCount() 20)

   return;

  

 

  出现ArrayIndexOutOfBoundsException异常,原因:某个线程恰好删除了元素i,使得当前线程无法访问元素i。

  

Exception in thread "Thread-1109" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 1

 

   at java.util.Vector.remove(Vector.java:831)

   at VectorTest$2.run(VectorTest.java:28)

   at java.lang.Thread.run(Thread.java:745)

  

 

  需要将对元素的get和remove构造成同步代码块:

  

synchronized (vector){

 

   for (int i = 0; i vector.size(); i++) {

   System.out.println("获取vector的第" + i + "个元素: " + vector.get(i));

  synchronized (vector){

   for (int i=0;i vector.size();i++){

   System.out.println("删除vector中的第" + i+"个元素");

   vector.remove(i);

  

 

  ③ 相对线程安全

  相对线程安全需要保证对该对象的单个操作是线程安全的,在必要的时候可以使用同步措施实现线程安全。

  大部分的线程安全类都属于相对线程安全,如Java容器中的Vector、HashTable、通过Collections.synchronizedXXX()方法包装的集合。

  ④ 线程兼容

  Java中大部分的类都是线程兼容的,通过添加同步措施,可以保证在多线程环境中安全使用这些类的对象。

  如常见的ArrayList、HashTableMap都是线程兼容的。

  ⑤ 线程对立

  线程对立是指:无法通过添加同步措施,实现多线程中的安全使用。

  线程对立的常见操作有:Thread类的suspend()和resume()(已经被JDK声明废除),System.setIn()和System.setOut()等。

  2. Java的枚举类型

  通过enum关键字修饰的数据类型,叫枚举类型。

  枚举类型的每个元素都有自己的序号,通常从0开始编号。

  可以通过values()方法遍历枚举类型,通过name()或者toString()获取枚举类型的名称

  通过ordinal()方法获取枚举类型中元素的序号

  

public class EnumData {

 

   public static void main(String[] args) {

   for (Family family : Family.values()) {

   System.out.println(family.name() + ":" + family.ordinal());

  enum Family {

   GRADMOTHER, GRANDFATHER, MOTHER, FATHER, DAUGHTER, SON;

  

 

  可以将枚举类型看做普通的class,在里面定义final类型的成员变量,便可以为枚举类型中的元素赋初值。

  要想获取枚举类型中元素实际值,需要为成员变量添加getter方法。

  虽然枚举类型的元素有了自己的实际值,但是通过ordinal()方法获取的元素序号不会发生改变。

  

public class EnumData {

 

   public static void main(String[] args) {

   for (Family family : Family.values()) {

   System.out.println(family.name() + ":实际值" + family.getValue() +

   ", 实际序号" + family.ordinal());

  enum Family {

   GRADMOTHER(3), GRANDFATHER(4), MOTHER(1), FATHER(2), DAUGHTER(5), SON(6);

   private final int value;

   Family(int value) {

   this.value = value;

   public int getValue() {

   return value;

  

 

  3. Java线程安全的实现

  ① 互斥同步

  互斥同步(Mutex Exclusion Synchronization)是一种常见的并发正确性保障手段。

  同步:多个线程并发访问共享数据,保证共享数据同一时刻只被一个(或者一些,使用信号量)线程使用。

  互斥:互斥是实现同步的一种手段,主要的互斥实现方式:临界区(Critical Section)、互斥量(Mutex)、信号量(Semaphore)。

  同步与互斥的关系:

  互斥是原因,同步是结果。

  同步是目的,互斥是方法。

  Java中,最基本的实现互斥同步的手段是synchronized关键字,其次是JUC包中的ReentrantLock。

  关于synchronized关键字:

  编译后的同步块,开始处会添加monitorenter指令,结束处或异常处会添加monitorexit指令。

  monitorenter和monitorexit指令中都包含一个引用类型的参数,分别指向加锁或解锁的对象。如果是同步代码块,则为synchronized括号中明确指定的对象;如果为普通方法,则为当前实例对象;如果为静态方法,则为类对应的class对象。

  JVM执行monitorenter指令时,要先尝试获取锁:如果对象没被锁定或者当前线程已经拥有该对象的锁,则锁计数器加1;否则获取锁失败,进入阻塞状态,等待持有锁的线程释放锁。

  JVM执行monitorexit指令时,锁计数器减1,直到计数器的值为0,锁被释放。(synchronized是支持重进入的)

  由于阻塞或者唤醒线程都需要从用户态(User Mode)切换到核心态(Kernel Mode),有时锁只会被持有很短的时间,没有必要进行状态转换。可以让线程在阻塞之前先自旋等待一段时间,超时未获取到锁才进入阻塞状态,这样可以避免频繁的切入到核心态。其实,就是后面自旋锁的思想。

  关于ReentrantLock:

  与synchronized关键字相比,它是API层面的互斥锁(lock()、unlock()、try...finally)。

  与synchronized关键字相比,具有可中断、支持公平与非公平性、可绑定多个Condition对象的高级功能。

  由于synchronized关键字被优化,二者的性能差异并不是很大,如果不是想使用ReentrantLock的高级功能,优先考虑使用synchronized关键字。

  ② 非阻塞同步

  (1)CAS概述

  互斥同步最大的性能问题是线程的阻塞和唤醒,因此又叫阻塞同步。

  互斥同步采用悲观并发策略:

  多线程并发访问共享数据时,总是认为只要不加正确的同步措施,肯定会出现问题。

  无论共享数据是否存在竞争,都会执行加锁、用户态和心态的切换、维护锁计数器、检查是否有被阻塞的线程需要唤醒等操作。

  随着硬件指令集的发展,我们可以采用基于冲突检测的乐观并发策略:

  先进行操作,如果不存在冲突(即没有其他线程争用共享数据),则操作成功。

  如果有其他线程争用共享数据,产生了冲突,使用其他的补偿措施。

  常见的补偿措施:不断尝试,直到成功为止,比如循环的CAS操作。

  乐观并发策略的许多实现都不需要将线程阻塞,这种同步操作叫做非阻塞同步。

  非阻塞同步依靠的硬件指令集:前三条是比较久远的指令,后两条是现代处理器新增的。

  测试和设置(Test and Set)

  获取并增加(Fetch and Increment)

  交换(Swap)

  比较并交换(Compare and Swap,即CAS)

  加载链接/条件存储(Load Linked/ Store Conditional,即LL/SC)

  什么是CAS?

  CAS,即Compare and Swap,需要借助处理器的cmpxchg指令完成。

  CAS指令需要三个操作数:内存位置V(Java中可以简单的理解为变量的内存地址)、旧的期待值A、新值B。

  CAS指令执行时,当且仅当V符合旧的预期值A,处理器才用新值B更新V的值;否则,不执行更新。

  不管是否更新V的值,都返回V的旧值,整个处理过程是一个原子操作。

  原子操作:所谓的原子操作是指一个或一系列不可被中断的操作。

  Java中的CAS操作:

  Java中的CAS操作由sun.misc.Unsafe中的compareAndSwapInt()、compareAndSwapLong()等几个方法包装提供。实际无法调用这些方法,需要采用反射机制才能使用。

  在实际的开发过程中,一般通过其他的Java API调用它们,如JUC包原子类中的compareAndSet(expect, update) 、getAndIncrement()等方法。这些方法内部都使用了Unsafe类的CAS操作。

  Unsafe类的CAS操作,通过JVM的即时编译器编译后,是一条与平台相关的CAS指令。

  除了偏向锁,Java中其他锁的实现方式都是用了循环的CAS操作。

  (2)通过循环的CAS实现原子操作

  通过++i或者i++可以实现计数器的自增,在多线程环境下,这样使用是非线程安全的。

  

public class UnsafeCount {

 

   private int i = 0;

   private static final int THREADS_COUNT = 200;

   public static void main(String[] args) {

   Thread[] threads = new Thread[THREADS_COUNT];

   UnsafeCount counter = new UnsafeCount();

   for (int i = 0; i THREADS_COUNT; i++) {

   threads[i] = new Thread(new Runnable() {

   @Override

   public void run() {

   for (int j = 0; j 10000; j++) {

   counter.count();

   threads[i].start();

   while (Thread.activeCount() 1) {

   Thread.yield();

   System.out.println("多线程调用计数器i,运行后的值为: " + counter.i);

   public void count() {

   i++;

  

 

  运行以上的代码发现:当线程数量增加,每个线程调用计数器的次数变大时,每次运行的结果是错误且不固定的。

  为了实现实在一个多线程环境下、线程安全的计数器,需要使用AtomicInteger的原子自增运算。

  

import java.util.concurrent.atomic.AtomicInteger;

 

  public class SafeCount {

   private AtomicInteger atomic = new AtomicInteger(0);

   private static final int THREAD_COUNT = 200;

   public static void main(String[] args) {

   SafeCount counter = new SafeCount();

   Thread[] threads = new Thread[THREAD_COUNT];

   for (int i = 0; i THREAD_COUNT; i++) {

   threads[i] = new Thread(new Runnable() {

   @Override

   public void run() {

   for (int j=0;j 10000;j++){

   counter.count();

   threads[i].start();

   while (Thread.activeCount() 1){

   Thread.yield();

   System.out.println("多线程调用线程安全的计数器atomic:"+counter.atomic);

   public void count() {

   // 调用compareAnSet方法,使用循环的CAS操作实现计数器的原子自增

   for (; ; ) {

   int expect = atomic.get();

   int curVal = expect + 1;

   if (atomic.compareAndSet(expect, curVal)) {

   break;

  

 

  与非线程安全的计数器相比,线程安全的计数器有以下特点:

  将int类型的计数器变量i,更换成具有CAS操作的AtomicInteger类型的计数器变量atomic。

  进行自增运算时,通过循环的CAS操作实现atomic的原子自增。

  先通过atomic.get()获取expect的值,将expect加一得到新值,然后通过atomic.compareAndSet(expect, curVal)这一方法实现CAS操作。

  其中compareAndSet()返回的true或者false,表示此次CAS操作是否成功。如果返回false,则不停地重复执行CAS操作,直到操作成功。

  上面的count方法实现的AtomicInteger原子自增,可以只需要调用incrementAndGet()一个方法就能实现。

  

public void count() {

 

   // 调用incrementAndGet方法,实现AtomicInteger的原子自增

   atomic.incrementAndGet();

  

 

  因为incrementAndGet()方法,封装了通过循环的CAS操作实现AtomicInteger原子自增的代码。

  

public final int incrementAndGet() {

 

   return unsafe.getAndAddInt(this, valueOffset, 1) + 1;

  public final int getAndAddInt(Object var1, long var2, int var4) {

   int var5;

   do {

   var5 = this.getIntVolatile(var1, var2);

   } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

   return var5;

  

 

  (3)CAS操作存在的问题

  1. ABA问题

  在执行CAS操作更新共享变量的值时,如果一个值原来是A,被其他线程改成了B,然后又改回成了A。对于该CAS操作来说,它完全感受不到共享变量值的变化。这种操作漏洞称为CAS操作的ABA问题。

  解决该问题的思路是,为变量添加版本号,每次更新时版本号递增。这种场景下就成了1A -- 2B -- 3A。CAS操作就能检测到共享变量的ABA问题了。

  JUC包中,也提供了相应的带标记的原子引用类AtomicStampedReference来解决ABA问题。

  AtomicStampedReference的compareAndSet()方法会首先比较期待的引用是否等于当前引用,然后检查期待的标记是否等于当前标记。如果全部相等,则以原子操作的方式将新的引用和新的标记更新到当前值中。

  但是AtomicStampedReference目前比较鸡肋,如果想解决AB问题,可以使用锁。

  2. 循环时间过长,开销大

  循环的CAS操作如果长时间不成功,会给CPU带来非常大的执行开销。

  3. 只能保证一个共享变量的原子操作

  只对一个共享变量执行操作时,可以通过循环的CAS操作实现。如果是多个共享变量,循环的CAS操作无法保证操作的原子性。

  取巧的操作:将多个共享变量合为一个变量进行CAS操作。JDK1.5开始,提供了AtomicReference类保证引用对象之间的原子性,可以将多个变量放在一个对象中进行CAS操作。

  ③ 无同步方案

  同步只是保证共享数据争用时正确性的一种手段,如果不存在共享数据,自然无须任何同步措施。

  (1)栈封闭

  多个线程访问同一个方法的局部变量时,不会出现线程安全问题。

  因为方法中的局部变量不会逃出该方法而被其他线程访问,因此可以看做JVM栈中数据,属于线程私有。

  (2)可重入代码(Reentrant Code)

  可重入代码又叫纯代码(Pure Code),可在代码执行的任何时候中断他它,转去执行另外一段代码(包括递归调用它本身),控制权返回后,原来的程序不会出现任何错误。

  所有可重入的代码都是线程安全,并非所有线程安全的代码都是可重入的。

  可重入代码的共同特征:

  不依赖存储在堆上的数据和公用的系统资源

  用到的状态量都由参数中传入

  不调用非可重用的方法

  如何判断代码是否具备可重入性?如果一个方法,它的返回结果是可预测的。只要输入了相同的数据,就都能返回相同的结果,那它就满足可重入性,当然也就是线程安全的。

  (3)线程本地存储(TLS)

  线程本地存储(Thread Local Storage):

  如果一段代码中所需要的数据必须与其他代码共享,那就看看这些共享数据的代码是否能保证在同一个线程中执行。

  如果能保证,我们就可以把共享数据的可见范围限制在同一个线程内。

  这样,无须同步也能保证线程之间不出现数据争用的问题。

  TLS的重要应用实例:经典的Web交互模型中,一个请求对应一个服务器线程,使得Web服务器应用可以使用。

  Java中没有关键字可以将一个变量定义为线程所独享,但是Java中创建了java.lang.ThreadLocal类提供线程本地存储功能。

  每一个线程内部都包含一个ThreadLocalMap对象,该对象将ThreadLocal对象的hashCode值作为key,即ThreadLocal.threadLocalHashCode,将本地线程变量作为value,构成键值对。

  ThreadLocal对象是当前线程ThreadLocalMap对象的访问入口,通过threadLocal.set()为本地线程添加独享变量;通过threadLocal.get()获取本地线程独享变量的值。

  ThreadLocal、ThreadLocalMap、Thread的关系:Thread对象中包含ThreadLocalMap对象,ThreadLocalMap对象中包含多个键值对,每个键值对的key是ThreadLocal对象的hashCode,value是本地线程变量。

  ThreadLocal的编程实例:

  想为某个线程添加本地线程变量,必须通过ThreadLocal对象在该线程中进行添加,构造出的键值对自动存入该线程的map中;

  想要获取某个线程的本地线程变量,必须在该线程中获取,会自动查询该线程的map,获得ThreadLocal对象对应的value。

  通过ThreadLocal对象重复为某个线程添加键值对,会覆盖之前的value。

  

public class TLS {

 

   public static void main(String[] args) {

   ThreadLocal String threadLocal1 = new ThreadLocal ();

   ThreadLocal Integer threadLocal2 = new ThreadLocal ();

   Thread thread1 = new Thread(new Runnable() {

   @Override

   public void run() {

   // 设置当前线程的本地线程变量

   threadLocal1.set("thread1");

   threadLocal2.set(1);

   System.out.println(threadLocal1.get() + ": " + threadLocal2.get());

   // 使用完毕后要删除,避免内存泄露

   threadLocal1.remove();

   threadLocal2.remove();

   Thread thread2 = new Thread(new Runnable() {

   @Override

   public void run() {

   threadLocal1.set("thread2");

   threadLocal2.set(2);

   System.out.println(threadLocal1.get() + ": " + threadLocal2.get());

   threadLocal1.remove();

   threadLocal2.remove();

   thread1.start();

   thread2.start();

   // 没有通过ThreadLocal为主线程添加过本地线程变量,获取到的内容都是null

   System.out.println(threadLocal1.get()+": "+threadLocal2.get());

  

 

  对ThreadLocal的正确理解:

  ThreadLocal适用于线程需要有自己的实例变量,该实例变量可以在多个方法中被使用,但是不能被其他线程共享的场景。

  由于不存在数据共享,何谈同步?因此ThreadLocal 从理论上讲,不是用来解决多线程并发问题的。

  ThreadLocal的实现:

  最原始的想法:ThreadLocal维护线程与实例的映射。既然通过ThreadLocal对象为线程添加本地线程变量,那就将ThreadLocalMap放在ThreadLocal中。

  原始想法存在的缺陷:多线程并发访问ThreadLocal中的Map,需要添加锁。这是, JDK 未采用该方案的一个原因。

  优化后的方法:Thread维护ThreadLocal与实例的映射。Map是每个线程所私有,只能在当前线程通过ThreadLocal对象访问自身的Map。不存在多线程并发访问同一个Map的情况,也就不需要锁。

  优化后存在内存泄露的情况:JDK1.8中,ThreadLocalMap每个Entry对ThreadLocal对象是弱引用,对每个实例是强引用。当ThreadLocal对象被回收后,该Entry的键变成null,但Entry无法被移除。使得实例被Entry引用无法回收,造成内存泄露。

  近期热文推荐:

  1.1,000+ 道 Java面试题及答案整理(2022最新版)

  2.劲爆!Java 协程要来了。。。

  3.Spring Boot 2.x 教程,太全了!

  4.别再写满屏的爆爆爆炸类了,试试装饰器模式,这才是优雅的方式!!

  5.《Java开发手册(嵩山版)》最新发布,速速下载!

  觉得不错,别忘了随手点赞+转发哦!

  以上就是万字详解 Java 线程安全,面试必备!(java线程安全什么意思)的详细内容,想要了解更多 万字详解 Java 线程安全,面试必备!的内容,请持续关注盛行IT软件开发工作室。

郑重声明:本文由网友发布,不代表盛行IT的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。

留言与评论(共有 条评论)
   
验证码: