搜公众号
推荐 原创 视频 Java开发 开发工具 Python开发 Kotlin开发 Ruby开发 .NET开发 服务器运维 开放平台 架构师 大数据 云计算 人工智能 开发语言 其它开发 iOS开发 前端开发 JavaScript开发 Android开发 PHP开发 数据库
Lambda在线 > Java编程技术乐园 > Java的线程安全、单例模式、JVM内存结构等知识梳理

Java的线程安全、单例模式、JVM内存结构等知识梳理

Java编程技术乐园 2019-04-09
举报


做一个积极的人

编码、改bug、提升自己

我有一个乐园,面向编程,春暖花开!


知其然,不知其所以然 !在技术的海洋里,遨游!


本篇以一些问题开头,请先不看答案,自己思考一下,看一下你能回答上来多少! 本文内容较多,可以收藏后查看!

思考一下

1、都说String是不可变的,为什么我可以这样做呢? String a = "1"; a = "2";

2、HashMap的实现原理 ?

3、写出三种单例模式,如果能考虑线程安全最好?

4、ArrayList和LinkedList有什么区别 ?

5、什么是线程安全,为什么会出现线程安全问题?

6、实现线程的二种方式?

7、Lock与Synchronized的区别?

8、JVM的内存结构 ?

9、请解释如下jvm参数的含义:

 
   
   
 
  1. -server -Xms512m -Xmx512m -Xss1024K

  2. -XX:PermSize=256m -XX:MaxPermSize=512m -XX:MaxTenuringThreshold=20

  3. -XX:CMSInitiatingOccupancyFraction=80 -XX:+UseCMSInitiatingOccupancyOnly

10、数据库隔离级别有哪些,各自的含义是什么,MYSQL默认的隔离级别是是什么?


1、都说String是不可变的,为什么我可以这样做呢,String a = "1";a = "2";

先看一段代码,然后通过代码和一幅图进行讲解!

 
   
   
 
  1. public class StringTest {


  2. public static void main(String[] args) {

  3. String s = "ABCabc";

  4. System.out.println("s1.hashCode() = " + s.hashCode() + "--" + s);

  5. s = "123456";

  6. System.out.println("s2.hashCode() = " + s.hashCode() + "--" + s);

  7. //运行后输出的结果不同,两个值的hascode也不一致,

  8. //说明设置的值在内存中存储在不同的位置

  9. }

  10. }

【首先创建一个String对象s,然后让s的值为“ABCabc”, 然后又让s的值为“123456”。 从打印结果可以看出,s的值确实改变了。那么怎么还说String对象是不可变的呢?】

也就是说,s只是一个引用,它指向了一个具体的对象,当s=“123456”; 这句代码执行过之后,又创建了一个新的对象“123456”, 而引用s重新指向了这个心的对象,原来的对象“ABCabc”还在内存中存在,并没有改变。内存结构如下图所示:

Java的线程安全、单例模式、JVM内存结构等知识梳理

---图片摘自【Java中的String为什么是不可变的? -- String源码分析】

  • 相关参考文章

1:【知乎-胖胖 回答】如何理解 String 类型值的不可变?: https://www.zhihu.com/question/20618891

2:8 张图理解 Java :https://mp.weixin.qq.com/s/nidDtGZ9P-YJaXSxvZPv_w

Java的线程安全、单例模式、JVM内存结构等知识梳理


2、HashMap的实现原理

HashMap 我之前的专栏中也有写过,分析HashMap要注意JDK版本,jdk1.7和jdk1.8中底层的实现就有不同。

说简单点HashMap是一个集合,通过put(key,value)存储数据,然后使用get(key)获取数据。

实现原理是基于hashing原理,使用hash算法实现。 jdk1.7 数组+链表 jdk1.8 数组+链表+红黑树


  • 详情可参考下面博文:

    java集合系列——Map之HashMap介绍(八): http://blog.csdn.net/u010648555/article/details/60324303HashMap的工作原理 : http://www.importnew.com/7099.html Java8系列之重新认识HashMap : http://www.importnew.com/20386.html



3、写出三种单例模式,如果能考虑线程安全最好

首先总结目前实现单例模式的方式有以下五种:

  • 饿汉式,线程安全

  • 懒汉式,线程不安全(注意加synchronized,变线程安全)

  • 双重检验锁(注意将instance 变量声明成 volatile,并注意jdk版本大于等于1.5)

  • 静态内部类 ,线程安全

  • 枚举,线程安全

注:推荐使用后面三种

具体代码就不一一写了:如果想了解具体的代码如何写,点击下面:

你真的会写单例模式吗——Java实现: http://www.importnew.com/18872.html

  • 双重检验锁 : jdk1.5以后才能正确工作

 
   
   
 
  1. public class Singleton {

  2. private static volatile Singleton singleton = null;


  3. private Singleton(){}


  4. public static Singleton getSingleton(){

  5. if(singleton == null){

  6. synchronized (Singleton.class){

  7. if(singleton == null){

  8. singleton = new Singleton();

  9. }

  10. }

  11. }

  12. return singleton;

  13. }

  14. }

  • 静态内部类 : 延时加载,线程安装

 
   
   
 
  1. public class Singleton {

  2. private static class Holder {

  3. private static Singleton singleton = new Singleton();

  4. }


  5. private Singleton(){}


  6. public static Singleton getSingleton(){

  7. return Holder.singleton;

  8. }

  9. }

  • 枚举 : [Effective Java] 推荐尽可能地使用枚举来实现单例

 
   
   
 
  1. public enum Singleton {

  2. INSTANCE;

  3. private String name;

  4. public String getName(){

  5. return name;

  6. }

  7. public void setName(String name){

  8. this.name = name;

  9. }

  10. }


4 、ArrayList和LinkedList有什么区别

我之前博客也有写过 , java集合系列——List集合总结 :http://blog.csdn.net/u010648555/article/details/59708627

这里在说明一下:简单介绍1 ArrayList是基于数组实现的,是一个数组队列。可以动态的增加容量!

  1. LinkedList是基于链表实现的,是一个双向循环列表。可以被当做堆栈使用!

使用场景

  1. 当集合中对插入元素数据的速度要求不高,但是要求快速访问元素数据,则使用ArrayList!

  2. 当集合中对访问元素数据速度不做要求不高,但是对插入和删除元素数据速度要求高的情况,则使用LinkedList!

具体分析1.ArrayList随机读取的时候采用的是get(index),根据指定位置读取元素,而LinkedList则采用size/2 ,二分法去加速一次读取元素,效率低于ArrayList! 2.ArrayList插入时候要判断容量,删除时候要将数组移位,有一个复制操作,效率低于LinkList!而LinkedList直接插入,不用判断容量,删除的时候也是直接删除跳转指针节点,没有复制的操作!


5、什么是线程安全,为什么会出现线程安全问题?

【参考书 :Java并发编程实战】:https://book.douban.com/subject/10484692/

线程安全就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不一致或者数据污染。[百度百科:线程安全]

线程安全 = 线程(多个线程) + 数据一致!

思考1:为什么会出现线程安全问题?

从百度百科的概念可以知道,发送线程安全问题的两个条件:


  • 多线程访问



  • 访问某个数据,(这里强调一下,某个数据是实例变量即对线程是共享的

    这两个条件都必须满足,缺一不可,否则不会出现线程安全问题。


思考2:怎么解决线程安全问题?

通过加锁机制,可以使用关键字synchronized,或者java并发包中的Lock。还有在使用集合中的类如ArrayList或者HashMap时要考虑是否存在线程安全问题,如果存在最好使用ConcurrentHashMap替代hashMap,或者使用Collections.synchronizedXXX进行封装!

  • 实例:通过一段代码演示线程安全和非线程安全

 
   
   
 
  1. /**

  2. * 线程安全和线程不安全---简单实例

  3. *

  4. * @author:dufy

  5. * @version:1.0.0

  6. * @date 2017/10/13

  7. */

  8. public class ThreadSafey {



  9. private int countUnSafe = 0;//实例变量

  10. private int countSafe = 0;


  11. //线程不安全的方法

  12. public void addUnSafe(){

  13. try {

  14. Thread.sleep(100);//为了更好的测试。休眠100ms

  15. } catch (InterruptedException e) {

  16. e.printStackTrace();

  17. }

  18. countUnSafe ++;

  19. System.out.println("countUnSafe = " + countUnSafe);

  20. }

  21. //线程安全的方法

  22. //这里也可以使用使用同步代码块的方式,建议在实际开发使用同步代码块,相对比同步方法好很多, 也可以使用Lock进行加锁!

  23. public synchronized void addSafe(){

  24. try {

  25. Thread.sleep(100);//为了更好的测试。休眠100ms

  26. } catch (InterruptedException e) {

  27. e.printStackTrace();

  28. }

  29. countSafe ++;

  30. System.out.println("countSafe = " + countSafe);

  31. }


  32. public static void main(String[] args) {


  33. ThreadSafey ts = new ThreadSafey();

  34. UnSafeT unSafeT = new UnSafeT(ts);

  35. SafeT safeT = new SafeT(ts);

  36. //启动10个线程

  37. for (int i = 0; i < 10; i++) {

  38. Thread thread = new Thread(unSafeT);

  39. thread.start();

  40. }

  41. //启动10个线程

  42. for (int i = 0; i < 10; i++) {

  43. Thread thread = new Thread(safeT);

  44. thread.start();

  45. }

  46. }


  47. }

  48. //不安全线程测试类

  49. class UnSafeT implements Runnable{


  50. private ThreadSafey threadSafey;


  51. public UnSafeT(ThreadSafey threadSafey){

  52. this.threadSafey = threadSafey;

  53. }

  54. @Override

  55. public void run() {

  56. threadSafey.addUnSafe();

  57. }

  58. }

  59. //安全线程测试类

  60. class SafeT implements Runnable{


  61. private ThreadSafey threadSafey;


  62. public SafeT(ThreadSafey threadSafey){

  63. this.threadSafey = threadSafey;

  64. }

  65. @Override

  66. public void run() {

  67. threadSafey.addSafe();

  68. }

  69. }

运行结果如下,多次运行后,发现countUnSafe总是有重复的值,并且不按照顺序输出,最后的结果也不是10; countSafe 按照顺序打印,最后的结果也是10。如果你运行了上面的代码,可能和我执行下面打印的不一样,但是结论是一样的。

 
   
   
 
  1. countUnSafe = 3

  2. countUnSafe = 3

  3. countUnSafe = 3

  4. countUnSafe = 3

  5. countUnSafe = 3

  6. countUnSafe = 5

  7. countUnSafe = 8

  8. countUnSafe = 8

  9. countUnSafe = 6

  10. countUnSafe = 5

  11. countSafe = 1

  12. countSafe = 2

  13. countSafe = 3

  14. countSafe = 4

  15. countSafe = 5

  16. countSafe = 6

  17. countSafe = 7

  18. countSafe = 8

  19. countSafe = 9

  20. countSafe = 10

线程安全说简单了就上面这些内容,如何深入需要知道线程的工作原理,JVM下线程是如何进行工作,为什么实例变量会存在线程安全问题,而私有变量不会出现,这就和变量在内存中创建和存储的位置有关。下面进行简单的说明,不会一一展开了。

在程序运行后JVM中有一个主内存,线程在创建后也会有一个自己的内存(工作内存),会拷贝主内存的一些数据,每个线程之间能够共享主内存,而不能访问其他线程的工作内存,那么一个变量是实例变量的时候,如果没有加锁机制,就会出现线程安全问题。

比如:系统有线程A和线程B,这两个线程同时访问了addUnSafe方法,并将countUnsafe变量拷贝在自己的内存中(countUnsafe = 0),然后进行操作,那么这两个线程 都执行countUnsafe++,这两个线程的工作内存中countUnsafe = 1;然后写回主内存,此时主内存countUnsafe = 1,当另一个线程C访问时候,C工作内存操作的countUnsafe的值就是1,此时发生了线程安全问题。

【图片来自--java并发编程艺术-第二章 java内存模型抽象结构】Java的线程安全、单例模式、JVM内存结构等知识梳理

先就讲这么多了,这些在面试中是有定的深度了。后面有时间专门在深入总结。


6、实现线程的二种方式

Java中有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口。具

  • 实现Runnable接口

  • 继承Thread类

注意:线程的启动是调用start()方法,而不是run()方法!

举例并进行解释

1.直接调用run方法实例:

 
   
   
 
  1. public class TestTheadDemo {



  2. public static void main(String[] args) {

  3. for (int i = 0; i < 10; i++) {

  4. ThreadTest thread = new ThreadTest();

  5. thread.run();

  6. // thread.start();

  7. }

  8. }

  9. }


  10. class ThreadTest extends Thread{


  11. @Override

  12. public void run() {

  13. System.out.println("当前线程 : " + Thread.currentThread().getName());

  14. }

  15. }

运行结果 :当前线程全部是main线程,相当于ThreadTest类的thread对象直接调用了run()方法。(直接调用run方法只是一个普通的单线程程式)

 
   
   
 
  1. 当前线程 : main

  2. 当前线程 : main

  3. 当前线程 : main

  4. 当前线程 : main

  5. 当前线程 : main

2.调用start()方法将上面的代码 注释的thread.start();打开, thread.run();注释!

运行结果 :发现启动了不同的线程进行执行。

 
   
   
 
  1. 当前线程 : Thread-0

  2. 当前线程 : Thread-5

  3. 当前线程 : Thread-3

  4. 当前线程 : Thread-4

  5. 当前线程 : Thread-2

  6. 当前线程 : Thread-1

  7. 当前线程 : Thread-7

  8. 当前线程 : Thread-6

  9. 当前线程 : Thread-9

查看start()方法的源码中,发现有个地方

 
   
   
 
  1. public synchronized void start() {

  2. //代码省略....

  3. try {

  4. start0();//注意这个地方,调用了native本地方法

  5. started = true;

  6. } finally {

  7. //代码省略....

  8. }

  9. }

  10. //本地方法

  11. private native void start0();

总结: 调用start()方法,虚拟机JVM通过执行本地native方法start0和操作系统cup进行交互,此时线程并没有正在立即执行,而是等待cup的调度,当cpu分配给线程时间,线程才执行run()方法!

更多相关内容可以参考 [java多线程编程核心技术: 高洪岩 ] :https://book.douban.com/subject/26555197/


7、Lock与Synchronized的区别

在Java中Lock与Synchronized都可以进行同步操作,保证线程的安全,就如上面第一问提到的,线程安全性问题。下面进行简单的额介绍!

(1)、Synchronized的简单介绍

synchronized同步的原理

关键字synchronized可以修饰方法或者以同步块的形式来使用,它主要确保多个线程在同一时刻,只能有一个线程处于方法或者同步块 中,保证了线程对变量访问的可见性和排他性。

synchronized同步实现的基础

  1. 普通同步方法,锁是当前实例对象

  2. 静态同步方法,锁是当前类的class对象

  3. 同步方法块,锁是括号里面的对象

[一张图讲解对象锁和关键字synchronized修饰方法(代码块] :http://blog.csdn.net/u010648555/article/details/78138225

【死磕Java并发】-----深入分析synchronized的实现原理]http://blog.csdn.net/chenssy/article/details/54883355

注:有兴趣也可以看看 volatile关键字!

关键字volatile可以用来修饰字段(成员变量),就是告知程序任何对该变量的访问均需要从共享内存中获取,而对它的改变必须同步刷新回共享内存中,保证所有线程对变量访问的可见性。

关键字volatile和关键字synchronized均可以实现线程间通信!

(2)、Lock的简单介绍

首先明确Lock是Java 5之后,在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问。 Lock是一个接口,其由三个具体的实现:ReentrantLock、ReetrantReadWriteLock.ReadLock 和 ReetrantReadWriteLock.WriteLock,即重入锁、读锁和写锁。增加Lock机制主要是因为内置锁存在一些功能上局限性。

Java并发编程系列之十六:Lock锁 : http://blog.csdn.net/u011116672/article/details/51064186

区别总结:1.synchronized是Java语言的关键字,Lock是一个类,通过这个类可以实现同步访问;

2.synchronized是在JVM层面上实现的,不但可以通过一些监控工具监控synchronized的锁定,而且在代码执行时出现异常,JVM会自动释放锁定,但是使用Lock则不行,Lock是通过代码实现的,要保证锁定一定会被释放,就必须将unLock(),最好放到finally{}中。 3.Lock有ReetrantLock(可重入锁)实现类,可选的方法比synchronized多,使用更灵活。 4..并不是Lock就比synchronized一定好,因为synchronized在jdk后面的版本也在不断优化。在资源竞争不是很激烈的情况下,synchronized的性能要优于ReetrantLock,但是在资源竞争很激烈的情况下,synchronized的性能会下降很多,性能不如Lock。

Lock和synchronized的区别和使用:http://www.cnblogs.com/baizhanshi/p/6419268.html

8、JVM的内存结构

下图:【图片版本-深入理解Java虚拟机:JVM高级特性与最佳实践:周志明】

Java的线程安全、单例模式、JVM内存结构等知识梳理

Java的线程安全、单例模式、JVM内存结构等知识梳理

还有这个博文: JVM内存结构图解 :http://blog.csdn.net/coffeelifelau/article/details/52534672

Java的线程安全、单例模式、JVM内存结构等知识梳理

9、请解释如下jvm参数的含义

 
   
   
 
  1. -server -Xms512m -Xmx512m -Xss1024K -Xmn256m

  2. -XX:PermSize=256m -XX:MaxPermSize=512m

  3. -XX:MaxTenuringThreshold=20

  4. -XX:CMSInitiatingOccupancyFraction=80

  5. -XX:+UseCMSInitiatingOccupancyOnly

Java的线程安全、单例模式、JVM内存结构等知识梳理

-server :服务器模式注:JVM client模式和server模式,生产环境请使用-server,性能更好![JVM client模式和Server模式的区别]:https://zhidao.baidu.com/question/1703232626938481420.html

-Xms512m :JVM初始分配的堆内存,一般和Xmx配置成一样以避免每次gc后JVM重新分配内存。

-Xmx512m :JVM最大允许分配的堆内存,按需分配

-Xss1024K :设置每个线程的堆栈大小

-Xmn256m :年轻代内存大小,整个JVM内存=年轻代 + 年老代 + 持久代

-XX:PermSize=256m :设置持久代(perm gen)初始值,默认物理内存的1/64注意:jdk 8 已经没有此参数

-XX:MaxPermSize=512m : 设置持久代最大值注意:jdk 8 已经没有此参数

*-XX:MaxTenuringThreshold=20 * :垃圾最大年龄

*-XX:CMSInitiatingOccupancyFraction=80 * :使用cms作为垃圾回收 使用80%后开始CMS收集

-XX:+UseCMSInitiatingOccupancyOnly :使用手动定义初始化定义开始CMS收集

还有很多很多参数。。。。

[一个性能较好的JVM参数配置] :http://developer.51cto.com/art/201507/486162.htm

10 、数据库隔离级别有哪些,各自的含义是什么,MYSQL默认的隔离级别是是什么?

事务指定了4种隔离级别(从弱到强分别是):

  1. Read Uncommitted:读未提交

  2. Read Committed:读提交

  3. Repeatable Read:重复读

  4. Serializable:序列化

1:Read Uncommitted(读未提交):一个事务可以读取另一个未提交事务的数据。

2:Read Committed(读提交):一个事务要等另一个事务提交后才能读取数据。

3:Repeatable Read(重复读):在开始读取数据(事务开启)时,不再允许修改操作。

4:Serializable(序列化):Serializable 是最高的事务隔离级别,在该级别下,事务串行化顺序执行,可以避免脏读、不可重复读与幻读。

大多数数据库默认的事务隔离级别是Read committed,比如Sql Server , Oracle。MySQL的默认隔离级别是Repeatable read。

在事务的并发操作中可能会出现脏读(dirty read),不可重复读(repeatable read),幻读(phantom read)。可参考:[理解事务的4种隔离级别]:http://blog.csdn.net/qq_33290787/article/details/51924963

注:Mysql查询事务隔离级别: 查询命令总结:

 
   
   
 
  1. 查看当前会话隔离级别:select @@tx_isolation;

  2. 查看系统当前隔离级别:select @@global.tx_isolation;

  3. 设置当前会话隔离级别:set session transaction isolation level repeatable read;

  4. 设置当前会话隔离级别:set global transaction isolation level repeatable read;


总结

本文只是对相关的只是进行一个总结,因为每一个知识点要展开来说的话,一篇文章可能都介绍不完,后面有时间会深入到具体的一个个知识点中,然后尽量结合实际情况进行讲解,敬请期待吧!

Java的线程安全、单例模式、JVM内存结构等知识梳理

不管做什么,只要坚持下去就会看到不一样!在路上,不卑不亢!

愿你我早日成长为独挡一面的人


Java的线程安全、单例模式、JVM内存结构等知识梳理      

谢谢你的阅读,祝你有所收获,也愿你每天开心愉快!

如果觉得对你有所帮助,你的转发,就是对我最大的鼓励


文章推荐


 
 
 

 

Java相关技术

高效软件工具

干货技术资源

前沿技术分享

FOLLOW US


好点个在看,一起玩耍!


版权声明:本站内容全部来自于腾讯微信公众号,属第三方自助推荐收录。《Java的线程安全、单例模式、JVM内存结构等知识梳理》的版权归原作者「Java编程技术乐园」所有,文章言论观点不代表Lambda在线的观点, Lambda在线不承担任何法律责任。如需删除可联系QQ:516101458

文章来源: 阅读原文

相关阅读

关注Java编程技术乐园微信公众号

Java编程技术乐园微信公众号:aflyun

Java编程技术乐园

手机扫描上方二维码即可关注Java编程技术乐园微信公众号

Java编程技术乐园最新文章

精品公众号随机推荐

举报