java面试整理（02）2021-02-16（线程相关）

╰+攻爆jí腚メ 2022-10-30 01:24 167阅读 0赞

> 从网上收集整理了面试题，虽然整理了但是好多都记不住，需要每天巩固。

# **一、什么是线程安全** #

当多个线程访问某一个类（对象或方法）时，对象对应的公共数据区始终都能表现正确，那么这个类（对象或方法）就是线程安全的。

线程安全的代码是多个线程同时执行也能正常工作的代码

如果一段代码可以保证多个线程访问的时候正确操作共享数据，那么它是线程安全的。

# 二、创建线程的方式 #

继承Thread类创建线程  
实现Runnable接口创建线程  
使用Callable和Future创建线程  
使用线程池创建（使用java.util.concurrent.Executor接口）

1、继承Thread类创建线程类

（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。

（2）创建Thread子类的实例，即创建了线程对象。

（3）调用线程对象的start()方法来启动该线程。

2、通过实现Runnable接口创建线程类

（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

（2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

（3）调用线程对象的start()方法来启动该线程。

3、通过Callable和Future创建线程

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

4、使用线程池创建（使用java.util.concurrent.Executor接口）

# 三、Runnable和Callable的区别 #

*  Runnable没有返回值；Callable可以返回执行结果，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果
 *  Callable接口的call()方法允许抛出异常；Runnable的run()方法异常只能在内部消化，不能往上继续抛

**注**：Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

# 四、wait方法和sleep方法的区别 #

*  sleep是Thread类的方法，wait是Object类的方法。
 *   最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法(锁代码块和方法锁)。  
 *  wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用(使用范围)，  sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常  。
 *  sleep方法是Thread类的静态方法，调用此方法会让当前线程暂停指定的时间，将执行机会（CPU）让给其他线程，但是不会释放锁，因此休眠时间结束后自动恢复（程序回到就绪状态）。
 *  wait是Object类的方法，调用对象的wait方法导致线程放弃CPU的执行权，同时也放弃对象的锁（线程暂停执行），进入对象的等待池（wait pool），只有调用对象的notify或notifyAll方法才能唤醒等待池中的线程进入等锁池（lock pool），如果线程重新获得对象的锁就可以进入就绪状态。
 *  wait 可以指定时间也可以不指定，指定时间 wait(time) 在 time时间内 有别的线程 notifyAll() 是不会唤醒到它 。sleep 必须指定时间。

# 五、synchronized和ReentrantLock区别 #

1)Lock是一个接口，synchronized是Java中的关键字，synchronized是内置的语言实现；  
2)synchronized发生异常时，会自动释放线程占用的锁，故不会发生死锁现象。Lock发生异常，若没有主动释放，极有可能造成死锁，故需要在finally中调用unLock方法释放锁；  
3)Lock可以让等待锁的线程响应中断，使用synchronized只会让等待的线程一直等待下去，不能响应中断  
4)通过Lock可以知道有没有成功获取到锁，synchronized就不灵  
5)Lock可以提高多个线程进行读操作的效率。

ReentrantLock是Lock的实现类，是一个互斥的同步器，在多线程高竞争条件下，ReentrantLock比synchronized有更加优异的性能表现

**底层实现**上来说，synchronized 是**JVM**层面的锁，是**Java关键字**，通过monitor对象来完成（monitorenter与monitorexit），对象只有在同步块或同步方法中才能调用wait/notify方法，ReentrantLock 是从jdk1.5以来（java.util.concurrent.locks.Lock）提供的**API层面**的锁。

**是否可手动释放：**

synchronized 不需要用户去手动释放锁，synchronized 代码执行完后系统会自动让线程释放对锁的占用； ReentrantLock则需要用户去手动释放锁，如果没有手动释放锁，就可能导致死锁现象。一般通过lock()和unlock()方法配合try/finally语句块来完成，使用释放更加灵活。

**是否可中断**

synchronized是不可中断类型的锁，除非加锁的代码中出现异常或正常执行完成； ReentrantLock则可以中断，可通过trylock(long timeout,TimeUnit unit)设置超时方法或者将lockInterruptibly()放到代码块中，调用interrupt方法进行中断。

**是否公平锁**

synchronized为非公平锁 ReentrantLock则即可以选公平锁也可以选非公平锁，通过构造方法new ReentrantLock时传入boolean值进行选择，为空默认false非公平锁，true为公平锁。

**锁是否可绑定条件Condition**

synchronized不能绑定； ReentrantLock通过绑定Condition结合await()/singal()方法实现线程的精确唤醒，而不是像synchronized通过Object类的wait()/notify()/notifyAll()方法要么随机唤醒一个线程要么唤醒全部线程。

**锁的对象**

synchronzied锁的是对象，锁是保存在对象头里面的，根据对象头数据来标识是否有线程获得锁/争抢锁；ReentrantLock锁的是线程，根据进入的线程和int类型的state标识锁的获得/争抢。

两者的共同点：  
1. 都是用来协调多线程对共享对象、变量的访问  
2. 都是可重入锁，同一线程可以多次获得同一个锁  
3. 都保证了可见性和互斥性  
两者的不同点：  
1. ReentrantLock 显示的获得、释放锁，synchronized 隐式获得释放锁  
2. ReentrantLock 可响应中断、可轮回，synchronized 是不可以响应中断的，为处理锁的  
不可用性提供了更高的灵活性  
3. ReentrantLock 是 API 级别的，synchronized 是 JVM 级别的  
4. ReentrantLock 可以实现公平锁  
5. ReentrantLock 通过 Condition 可以绑定多个条件  
6. 底层实现不一样， synchronized 是同步阻塞，使用的是悲观并发策略，lock 是同步非阻  
塞，采用的是乐观并发策略  
7. Lock 是一个接口，而 synchronized 是 Java 中的关键字，synchronized 是内置的语言  
实现。  
8. synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；  
而 Lock 在发生异常时，如果没有主动通过 unLock()去释放锁，则很可能造成死锁现象，  
因此使用 Lock 时需要在 finally 块中释放锁。  
9. Lock 可以让等待锁的线程响应中断，而 synchronized 却不行，使用 synchronized 时，  
等待的线程会一直等待下去，不能够响应中断。  
10. 通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。  
11. Lock 可以提高多个线程进行读操作的效率，既就是实现读写锁等

# 六、CAS无锁技术(简单了解即可，参考[https://blog.csdn.net/ls5718/article/details/52563959][https_blog.csdn.net_ls5718_article_details_52563959]) #

# 七、volatile关键字的作用和原理（参考[https://blog.csdn.net/zezezuiaiya/article/details/81456060][https_blog.csdn.net_zezezuiaiya_article_details_81456060]） #

被volatile关键字修饰的变量，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。

在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制。当对非 volatile 变量进行读写的时候，每个线程先从内存拷贝变量到CPU缓存中。如果计算机有多个CPU，每个线程可能在不同的CPU上被处理，这意味着每个线程可以拷贝到不同的 CPU cache 中。而声明变量是 volatile 的，JVM 保证了每次读变量都从内存中读，跳过 CPU cache 这一步。

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。Java中的volatile关键字提供了一个功能，那就是被其修饰的变量在被修改后可以立即同步到主内存，被其修饰的变量在每次是用之前都从主内存刷新。因此，可以使用volatile来保证多线程操作时变量的可见性。

**volatile不具备原子性，但是拥有可见性，并且在一定程度上拥有有序性。**

# 八、ThreadLocal和ThreadPoolExectutor #

ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。

**使用场景**

1.  在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束。
2.  线程间数据隔离
3.  进行事务操作，用于存储线程事务信息。
4.  数据库连接，Session会话管理。

**ThreadPoolExectutor（需要完善）**

# 九、常见线程池 #

Java通过Executors提供四种线程池，分别为：  
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。  
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。  
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。  
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

# 十、分布式环境下如何保证线程安全 #

**避免并发**

在分布式环境中，如果存在并发问题，那么很难通过技术去解决，或者解决的代价很大，所以我们首先要想想是不是可以通过某些策略和业务设计来避免并发。比如通过合理的时间调度，避开共享资源的存取冲突。另外，在并行任务设计上可以通过适当的策略，保证任务与任务之间不存在共享资源，比如在以前博文中提到的例子，我们需要用多线程或分布式集群来计算一堆客户的相关统计值，由于客户的统计值是共享数据，因此会有并发潜在可能。但从业务上我们可以分析出客户与客户之间 数据是不共享的，因此可以设计一个规则来保证一个客户的计算工作和数据访问只会被一个线程或一台工作机完成，而不是把一个客户的计算工作分配给多个线程去 完成。这种规则很容易设计，例如可以采用hash算法。

**时间戳**

分布式环境中并发是没法保证时序的，无论是通过远程接口的同步调用或异步消息，因此很容易造成某些对时序性有要求的业务在高并发时产生错误。比如系统A需要把某个值的变更同步到系统B，由于通知的时序问题会导致一个过期的值覆盖了有效值。对于这个问题，常用的办法就是采用时间戳的方式，每次系统A发送变更给系统B的时候需要带上一个能标示时序的时间戳，系统B接到通知后会拿时间戳与存在的时间戳比较，只有当通知的时间戳大于存在的时间戳，才做更新。这种方式比较简单，但关键在于调用方一般要保证时间戳的时序有效性。

**串行化**

有的时候可以通过串行化可能产生并发问题操作，牺牲性能和扩展性，来满足对数据一致性的要求。比如分布式消息系统就没法保证消息的有序性，但可以通过变分布式消息系统为单一系统就可以保证消息的有序性了。另外，当接收方没法处理调用有序性，可以通过一个队列先把调用信息缓存起来，然后再串行地处理这些调用。

**数据库**

分布式环境中的共享资源不能通过Java里同步方法或加锁来保证线程安全，但数据库是分布式各服务器的共享点，可以通过数据库的高可靠一致性机制来满足需求。比如，可以通过唯一性索引来解决并发过程中重复数据的生产或重复任务的执行；另外有些更新计算操作也尽量通过sql来完成，因为在程序段计算好后再去更新就有可能发生脏复写问题，但通过一条sql来完成计算和更新就可以通过数据库的锁机制来保证update操作的一致性。

**行锁**

有的事务比较复杂，无法通过一条sql解决问题，并且有存在并发问题，这时就需要通过行锁来解决，一般行锁可以通过以下方式来实现：  
对于Oracle数据库，可以采用select ... for update方式。这种方式会有潜在的危险，就是如果没有commit就会造成这行数据被锁住，其他有涉及到这行数据的任务都会被挂起，应该谨慎使用  
在表里添加一个标示锁的字段，每次操作前，先通过update这个锁字段来完成类似竞争锁的操作，操作完成后在update锁字段复位，标示已归还锁。这种方式比较安全，不好的地方在于这些update锁字段的操作就是额外的性能消耗

**统一触发途径**

当一个数据可能会被多个触发点或多个业务涉及到，就有并发问题产生的隐患，因此可以通过前期架构和业务设计，尽量统一触发途径，触发途径少了一是减少并发的可能，也有利于对于并发问题的分析和判断。

## 如何保证高并发时线程安全？ ##

对于商城一类系统中，单点登录、购物车、订单这些都有并发。

用AtomicInteger、synchronized、Lock、ThreadLocal等类来保证在代码层面上的线程安全；如果是功能上需要自主多线程处理，那么也会使用线程池ThreadPool来提高并发效率。

对高并发的处理会使用Redis的分布式锁(setnx)，将对于服务器的承载力达到一定数量后，之后的请求全部加入队列处理。

负载均衡：在代码层级上对不同的业务进行读写分离；而数据库上进行集群和主从复制。在应用服务器上对应的对每个服务器都运用lvs+keepalive模式进行服务器集群；如果硬件资源足够的话那么可以对集群节点更加多和更加分散提高并发能力和系统稳定性。

Redis是一个开源，先进的key-value存储，并用于构建高性能，可扩展的Web应用程序的完美解决方案，是线程安全的。  
Redis三个主要特点：  
　　Redis数据库完全在内存中，使用磁盘仅用于持久性。  
　　相比许多键值数据存储，Redis拥有一套较为丰富的数据类型（list,string,sort,set,hash）。  
　　Redis可以将数据复制到任意数量的从服务器。

[https_blog.csdn.net_ls5718_article_details_52563959]: https://blog.csdn.net/ls5718/article/details/52563959
[https_blog.csdn.net_zezezuiaiya_article_details_81456060]: https://blog.csdn.net/zezezuiaiya/article/details/81456060