三、多线程

小咪咪 2021-10-16 00:44 348阅读 0赞

##  三、多线程 ##

###  1. JAVA面试常见问题之锁机制篇： ###

**详情参考：**[https://blog.csdn.net/weixin\_30646315/article/details/97817912][https_blog.csdn.net_weixin_30646315_article_details_97817912]

###  1. 并发和并行有什么区别？ ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70]

###  2. 线程和进程有什么区别？ ###

![在这里插入图片描述][20190820170636854.png]

###  3. 守护线程是什么？ ###

![在这里插入图片描述][20190820170738437.png]**-------------------------------------------------------------------------------------------**

###  4. 创建线程的几种方式？ ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 1]  
**1.** 通过继承 Thread类创建线程；  
**2.** 通过实现 Runnable接口创建线程；（①创建实现 Runnable接口的类的实例；②创建一个 Thread类对象，将第一步实例化得到的 Runnable对象作为参数传入 Thread类的构方；③通过 Thread类的 start()启动线程；）  
**3.** 通过实现 Callable接口创建线程；

类：class X extends Thread{
    	   run(){
    	   }
        }
    主：X x=new X();
        x.start();

类：class X implements Runnable{
    	   run(){
    	   }
        }
    主：X x=new X();
        Thread t1=new Thread(x);
        t1.start();

**扩展：实现Runnable接口和实现Callable接口的区别、实现Runnable接口相比继承Thread类的优势：**  
[https://blog.csdn.net/qq\_41029923/article/details/99861767][https_blog.csdn.net_qq_41029923_article_details_99861767]

###  5. 线程有哪几种状态？ ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 3]

###  5\_1. Java中有两个线程如何等待一个线程执行完毕？ ###

可使用 join 关键字；

###  5\_2. OOM如何产生的，如何处理OOM问题？ ###

OOM是 Out Of Memery，线程创建过多、没来得及回收导致的，因此不要过多创建线程的数目；

--------------------

###  6. 线程池的核心参数？核心参数各司其职，流程怎么走? ###

**参考：** [https://blog.csdn.net/weixin\_44048746/article/details/104484857][https_blog.csdn.net_weixin_44048746_article_details_104484857]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 4]

**corePoolSize**：核心池大小；  
**maximumPoolSize**：线程池最大线程数；  
**keepAliveTime**：线程没有任务执行时最多存活时间；  
**unit**：为 keepAliveTime设置时间单位；  
**workQueue**：任务队列，用来缓存任务；

**流程图：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 5]  
**流程梳理：**  
用户提交任务，查看核心线程池是否满，没满则创建线程，执行任务，  
满了则交给缓冲队列，缓冲队列没满，则将任务添加到队列，满了，则  
判断最大线程池是否满了，没满则创建线程，执行任务，满了则拒绝策略；

--------------------

###  6. 创建线程池的几种方式？ ###

主要就是 ThreadPoolExecutor类的使用构造函数，四构造函数中各参数代表的意思：  
**corePoolSize**：核心池大小；  
**maximumPoolSize**：线程池最大线程数；  
**keepAliveTime**：线程没有任务执行时最多存活时间；  
**unit**：为 keepAliveTime设置时间单位；  
**workQueue**：任务队列，用来缓存任务，当提交到线程池中的任务核心线程数量不够用时，所有的核心线程都在执行任务，会将任务存到任务队列中，等待核心线程来执行。该参数主要是在核心线程数都在执行任务时，才起作用的参数，主要用来缓存任务。  
还有几种常见的线程池：newSigleThreadExecutor、newCachedThreadPool、newFixedThreadPool、newSigleThreadScheduledExecutor、newScheduledThreadPool  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 6]  
**Java中创建线程池的正确方法：参考：**  
[https://blog.csdn.net/yan88888888888888888/article/details/83927609][https_blog.csdn.net_yan88888888888888888_article_details_83927609]  
**实例1**：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 7]  
**实例2**：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 9]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 10]

--------------------

###  7.1 为什么不推荐使用JDK定义好的线程池，推荐使用自定义线程池？ ###

**参考：**[https://blog.csdn.net/qq\_42794038/article/details/112795486][https_blog.csdn.net_qq_42794038_article_details_112795486]

1.ExecutorService cachedThreadPool=Executors.newCachedThreadPool();
    2.ExecutorService fixedThreadPool=Executors.newFixedThreadPool(10);
    3.ExecutorService singleThreadExecutor=Executors.newSingleThreadExecutor();
    4.ScheduledExecutorService scheduledThreadPool=Executors.newScheduledThreadPool(5);

前三种最长用，但是为什么不推荐用自带的方法创建线程池的，**第一种**方式假如同时有10000个任务，假如任务执行时间大于空闲保持时间那就要创建10000个线程去处理任务，此时就会非常消耗CPU资源；**第二种和第三种**，假如任务量大的时候，绝大多数任务都会堆在队列中，非常的消耗内存，很容易OOM，所以日常开发中最好根据实际情况自己设置线程池参数，使用底层的：

ExecutorService threadPool=new ThreadPoolExecutor(2,5,1L,TimeUnit.SECONDS,new LinkedBlockingQueue<>(3),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

实例1：  
![在这里插入图片描述][20210325193859754.png]  
源码1’：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 11]

--------------------

###  7. 线程池有哪几种状态？ ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 12]

###  8. 线程池中 submit()和 execute()方法的区别？ ###

![在这里插入图片描述][20190820171535397.png]**-------------------------------------------------------------------------------------------**

###  9. Java中怎么保证多线程的运行安全？![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 13] ###

###  10. synchronized锁 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 14]

###  11. synchronized底层实现原理 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 15]

###  12. synchronized与 volatile、synchronized与 Lock、synchronized与 ReenTrantLock的区别分别是什么？ ###

#### volatile和 synchronized的详细解析！！： ####

[https://blog.csdn.net/suifeng3051/article/details/52611310][https_blog.csdn.net_suifeng3051_article_details_52611310]

#### volatile和 synchronized的区别： ####

[https://blog.csdn.net/suifeng3051/article/details/52611233][https_blog.csdn.net_suifeng3051_article_details_52611233]

① volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问的可见性；synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。（volatile关键字就是要告诉编译器，这个变量是经常改变的，而且编译时不要进行代码优化，所以每次读写的时候都要到它所在的地址去读取）  
② volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的（volatile是变量修饰符，synchronized是修饰类、方法、代码段）  
③ volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。  
④ volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 16]  
主要相同点：Lock能完成 synchronized所实现的所有功能；  
主要不同点：synchronized会自动释放锁，而 Lock一定要求程序员手动释放锁，且必须在 finally从句中释放；  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 17]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 18]**-------------------------------------------------------------------------------------------**

###  13. 死锁 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 19]

###  14. 同步和异步有何异同，何时分别使用他们？ ###

**为何要同步：** 线程同步是为了防止多个线程访问一个数据对象时，对数据造成破坏，是保证多线程安全访问竞争资源的一种手段；  
**如何实现同步：**同步要在 Java代码中完成两个操作：  
① 把竞争资源标识为 private；  
② 同步那些访问资源的代码，使用 synchronized关键字来修饰方法或代码块（当 synchronized 方法执行完成或发生异常时，会自动释放锁）；  
**同步例子：** 如果数据将在线程间共享。如正在写的数据以后可能被另一线程读到，或正在读的线程可能被另一线程写过了，那么这些数据就是共享数据，必须进行同步存取；  
\*\*异步例子：\*\*当应用程序在对象上调用了一个需要花费很长一段时间来执行的方法，并且不需要让程序等待方法的返回时，就应该使用异步编程。采用异步途径往往效率更高。

###  15. ThreadLocal是什么？有哪些使用场景？ ###

![在这里插入图片描述][20190820172441377.png]

###  16. atomic的原理 ###

![在这里插入图片描述][20190820173022169.png]

[https_blog.csdn.net_weixin_30646315_article_details_97817912]: https://blog.csdn.net/weixin_30646315/article/details/97817912
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70]: /images/20211015/21de103feb544d03b4d79cd1f0a3599c.png
[20190820170636854.png]: /images/20211015/bb5fb5162ca74b3bb65f7baf18825265.png
[20190820170738437.png]: /images/20211015/55897071a57a4e46a8b94a9688eeaa26.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 1]: /images/20211015/d7f612cce5d745eda311a42482b177cb.png
[https_blog.csdn.net_qq_41029923_article_details_99861767]: https://blog.csdn.net/qq_41029923/article/details/99861767
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 2]: /images/20211015/d9c833b54a9d4a869671d3c41a2b072a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 3]: /images/20211015/3d3dbfee131149ac99fca2f44306083a.png
[https_blog.csdn.net_weixin_44048746_article_details_104484857]: https://blog.csdn.net/weixin_44048746/article/details/104484857
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 4]: /images/20211015/63841d60e1474498a7420696ec840ac4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 5]: /images/20211015/71982a4802c44f37ba5cc8ae8c9f23ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 6]: /images/20211015/8a302179fd234b49947b3f83676e453c.png
[https_blog.csdn.net_yan88888888888888888_article_details_83927609]: https://blog.csdn.net/yan88888888888888888/article/details/83927609
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 7]: /images/20211015/04898e918fc147b588c58f7cd604a3db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 8]: /images/20211015/d40312b4e0074d689ccd99d7461f0f61.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 9]: /images/20211015/ba2dde352bca437a858e6743db338a2f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 10]: /images/20211015/b115e45042b744dea75820bb59d66587.png
[https_blog.csdn.net_qq_42794038_article_details_112795486]: https://blog.csdn.net/qq_42794038/article/details/112795486
[20210325193859754.png]: /images/20211015/1f58f8f3cb684c38bb637db8ace39bae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 11]: /images/20211015/5e24c14c31fa46bf913b8bd085872860.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 12]: /images/20211015/ae7219cf29ab467d84be415b577aba26.png
[20190820171535397.png]: /images/20211015/427dc03ff3b54a309781576c19ca91cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 13]: /images/20211015/bf96abf7396f4e62b56b360ad6284a0b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 14]: /images/20211015/49916c0523a04d0988972d88c08d4feb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 15]: /images/20211015/3aa1b15bb5ec4f1d838f187abc5695b9.png
[https_blog.csdn.net_suifeng3051_article_details_52611310]: https://blog.csdn.net/suifeng3051/article/details/52611310
[https_blog.csdn.net_suifeng3051_article_details_52611233]: https://blog.csdn.net/suifeng3051/article/details/52611233
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 16]: /images/20211015/ac5d4d5631fe4fa5bd1ca42029152098.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 17]: /images/20211015/e4e6899f8ce94120bc486d5c2a306356.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 18]: /images/20211015/c3a990200acf4219872de688f3e54987.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDI5OTIz_size_16_color_FFFFFF_t_70 19]: /images/20211015/48562dcbf3db42318b97fd9de80aae01.png
[20190820172441377.png]: /images/20211015/defd295018504ceaa74ccfee64a77817.png
[20190820173022169.png]: /images/20211015/55762d2915674df4a10213d6211f8bba.png