答：我是这样理解的。要考虑线程安全是因为多线程不同用户访问同一个数据的时候，
因为线程不同步，同时访问这个数据假如某一方对数据修改了那么就会出现不同步的问题。
比如著名的“银行家算法”就是为了解决线程安全问题。所以要在某一个用户访问数据的时候，对数据进行加锁。
2，都说String是不可变的，为什么我可以这样做呢
String a = "1";
a = "2";
答：a只是一个String对象的引用，并不是对象本身。当a="1"的时候，是把a指向了内存区中的“1”，a="2"的时候，再把a指向内存中的“2”的地址。
3，HashMap的实现原理
答：HashMap就是用哈希表实现的。哈希表是一种数据结构，我觉得他跟电话簿很像。
在jdk1.8中，HashMap是由 数组+链表+(红黑树)组成的.key里存放地址通过单链表指向存放实际值的value。
4，写出三种单例模式，如果能考虑线程安全最好
答：说白了就是一个类只有一个实例。通常有三种：
懒汉式，就是用实例到的时候线才创建所会以线程不安全，
class Single{
private static Single s = null;
public Single() {
if (s == null)
s = new Single();
return s;
}
}
饿汉式，就是你类一旦加载了就创建，线程安全，
public Simple(){
private static Single s=new Single();
private Single(){
}
public static Simple getSimple(){
return s;
}
}
还有双重锁模式，线程安全:
public class Singleton{
private static volatile Singleton instance=null;
private Singleton(){
}
public static Singleton getInstance(){
if(instance==null){
synchronized(Singleton.class){
if(instance==null){
instance=new Singleton();
}
}
}
return instance;
}
}
还有枚举，线程安全
5，ArrayList和LinkedList有什么区别
答：
1.存储方式不一样
ArrayList是通过数组队列实现的，就是一个动态数组
LinkedList是通过链表，而且是循环双链表实现数据存储的
2.访问速度不一样
ArrayList访问数据的速度快，而LinkedList存储的速度快
3.ArrayList查找是根据指定位置读取
LinkedList则不行，是使用二分法查找，效率低
4.ArrayList在插入的时候要判断List的容量，删除的时候要移位，就是将后面的复制到前一个位置
LinkedList则是根据指针结点直接插入和删除
6，实现线程的2种方式
答：一种是继承Thread类，一种是实现Runnable接口例子：
1.继承Thread类
public class NumberThread extends Thread
{
private int first; //序列初值
public NumberThread(String name, int first)
{
super(name);
this.first = first;
}
public void run()
{
System.out.print("\n"+this.getName()+": ");
for (int i=first; i<50; i+=2)
System.out.print(i+" ");
System.out.println(this.getName() +"结束！");
}
public static void main(String args[])
{
NumberThread thread_odd = new NumberThread("奇数线程",1);
NumberThread thread_even = new NumberThread("偶数线程",2);
thread_odd.start(); //启动线程对象
thread_even.start();
}
}
2：实现Runnable接口
public class NumberRunnable implements Runnable
{
private int first;
public NumberRunnable(int first)
{
this.first = first;
}
public void run() //线程体，实现Runnable接口
{
System.out.println();
for (int i=first; i<50; i+=2)
System.out.print(i+" ");
System.out.println("结束！");
}
public static void main(String args[])
{
NumberRunnable target = new NumberRunnable(1);
Thread thread_odd = new Thread(target,"奇数线程");
thread_odd.start();
new Thread(new NumberRunnable(2),"偶数线程").start();
}
}
7，JVM的内存结构
8，Lock与Synchronized的区别
1.synchronized自带的，是Java的关键字，
Lock是一个自己写的类，通过这个类可以实现同步访问；
2.synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定，但是使用Lock则不行，Lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()，最好放到finally{}中。
3.Lock有ReetrantLock（可重入锁）实现类，可选的方法比synchronized多，使用更灵活
9，数据库隔离级别有哪些，各自的含义是什么，MYSQL默认的隔离级别是是什么。
1：Read Uncommitted（读未提交）：一个事务可以读取另一个未提交事务的数据。
2：Read Committed（读提交）：一个事务要等另一个事务提交后才能读取数据。
3：Repeatable Read（重复读）：在开始读取数据（事务开启）时，不再允许修改操作。
4：Serializable（序列化）：Serializable 是最高的事务隔离级别，在该级别下，事务串行化顺序执行，可以避免脏读、不可重复读与幻读。
MySQL的默认隔离级别是Repeatable read。10，请解释如下jvm参数的含义：
-server -Xms512m -Xmx512m -Xss1024K
-XX:PermSize=256m -XX:MaxPermSize=512m -XX:MaxTenuringThreshold=20 XX:CMSInitiatingOccupancyFraction=80 -XX:+UseCMSInitiatingOccupancyOnly。
-server ：服务器模式
-Xms512m ：JVM初始分配的堆内存，一般和Xmx配置成一样以避免每次gc后JVM重新分配内存。
-Xmx512m ：JVM最大允许分配的堆内存，按需分配
-Xss1024K ：设置每个线程的堆栈大小
-Xmn256m ：年轻代内存大小，整个JVM内存=年轻代 + 年老代 + 持久代
-XX:PermSize=256m ：设置持久代(perm gen)初始值，默认物理内存的1/64
-XX:MaxPermSize=512m ： 设置持久代最大值
-XX:MaxTenuringThreshold=20 ： 垃圾最大年龄</fon
-XX:CMSInitiatingOccupancyFraction=80 ： 使用cms作为垃圾回收
使用80％后开始CMS收集</fon
-XX:+UseCMSInitiatingOccupancyOnly ： 使用手动定义初始化定义开始CMS收集
参考链接：https://www.cnblogs.com/aflyun/p/7662306.html