Java 基础知识试题3

Java多线程
Java多线程，在面试的时候，问的比较多的就是悲观锁和乐观锁。2，synchronized和lock锁的区别以及volatile和synchronized的区别，3，可重入锁与非可重入锁的区别，4，多线程解决什么问题，6，线程池的原理，7，线程池使用时的注意事项，8，AQS原理，9，ReentranLock源码，设计原理，整体过程等等问题。

面试官在多线程这一部分很可能会问你有没有在项目中实际使用多线程的经历，所以，如果你在你的项目中有实际使用Java多线程的经历的话，会为你加分不少 。

说一说对synchronized关键字的了解
synchronized关键字解决的是多线程之间访问资源的同步性问题，synchronized关键字可以保证被他修饰过的方法或者代码块在任意时刻有且只有一个线程执行，不会发生多线程对资源的抢夺撕扯。

另外，在Java关键字早期版本中，synchronized属于重量级锁，效率低下。

synchronized关键字最主要的三种使用方式
修饰实例方法，作用当前对象实例加锁，进入同步代码块前要获得当前对象实例的锁

修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁。：当静态类用synchronized修饰后是给当前类加锁，会作用于类的所有对象实例，因为静态成员不属于任何一个实例对象，是类成员（static表明这是该类的一个静态资源，不管new了多少个对象，只有一份，所以对该类的所有对象都加了锁）。所以如果一个线程A调用一个实例对象的非静态synchronized方法，而线程B需要调用这个实例对象所属类的静态synchronized方法，是允许的，不会发生互斥现象，因为访问静态synchronized方法占用的锁是当前类的锁，而访问非静态synchronized方法占用的锁是当前实例对象锁。

**修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。**和synchronized方法一样，synchronized（this）代码块上都是是给class类上锁，这里再提一下：synchronized关键字加到非static静态方法上是给对象实例上锁。另外需要注意的是：尽量不要使用synchronized（String a）因为JVM中，字符串常量池具有缓冲功能！

单例模式

手写单例模式(双重校验锁实现对象单例（线程安全）懒汉式)

public class Singleton {
		private volatile static Singleton uniqueInstance;
		private Singleton(){
	    }
	    public static Singleton getUniquelnstance(){
	    	//判断对象是否已经实例过，没有实例化过才进入加锁代码
	    	if（uniqueInstance == null）{
	    		//类对象加锁
	    		synchronized（Singleton.class）{
	    				if(uniqueInstance == null){
	    					uniqueInstance  = new  Singleton ();
	    				}
	    		}
	    	}
	    	return uniqueInstance  ;
	    }
}

另外，需要注意uniqueInstance采用volatile关键字的修饰也是很有必要的

uniqueInstance采用volatile关键字修饰也是很有必要的，uniqueInstance = new Singleton（）；这段代码其实是分为三步执行的：
1，为uniqueInstance分配内存空间
2，初始化uniqueInstance
3，将uniqueInstance指向分配的内存地址

但是由于JVM有指令重排的特性，执行顺序有可能变为1-3-2.
指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程T1执行了1和3，此时T2调用getUniquelnstance（）后发现uniqueInstance不为空，因此返回uniqueInstance，但此时uniqueInstance还未被初始化。

使用volatile可以禁止JVM的指令重排，保证在多线程环境下也能正常运行。

讲一下synchronized关键字的底层原理
synchronized关键字底层原理属于JVM层面。
1，synchronized同步语句块的情况

public class SynchronizedDemo {
	public void method() {
		synchronized (this) {
			System.out.println("synchronized 代码块");
		}
	}
}

通过 JDK 自带的 javap 命令查看 SynchronizedDemo 类的相关字节码信息：首先切换到类的对应目录执行 javac
SynchronizedDemo.java 命令生成编译后的 .class 文件，然后执行 javap -c -s -v -l
SynchronizedDemo.class

synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同
步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。 当执行 monitorenter 指令时，线程试图
获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取
锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权.当计数器为0则可以成功获取，获取后将锁计数器设
为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当
前线程就要阻塞等待，直到锁被另外一个线程释放为止

谈谈synchronized和ReenTrantLock的区别

1，两者都是可重入锁
两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁，比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。

2，synchronized依赖于JVM而ReenTrant Lock依赖于API
synchronized是依赖于JV吗实现的，ReenTrantLock 是 JDK 层面实现的（也就
是 API 层面，需要 lock() 和 unlock 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看
它是如何实现的。

ReenTrantLock比synchronized多了些高级功能
1，等待可中断
2，可实现公平锁
3，可实现选择性通知（锁可以绑定多个条件）

ReenactmentTrantLock提供了一种能够中断等待锁的线程机制， 通过lock.lockInterruptibly()来实现这个机制。也
就是说正在等待的线程可以选择放弃等待，改为处理其他事情。

ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。公平锁就是先等待的线程先获得锁。 ReenTrantLock默认情况下是非公平锁，可以通过 ReenTrantLock类的ReentrantLock(boolean fair) 构造方法来制定是否是公平的。

synchronized关键字与wait()和notify/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也
可以实现， 但是需要借助于Condition接口与newCondition() 方法。 Condition是JDK1.5之后才有的，它具有很
好的灵活性，比如可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视
器），线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵
活。 在使用notify/notifyAll()方法进行通知时，被通知的线程是由 JVM 选择的，用ReentrantLock类结合
Condition实例可以实现“选择性通知” ，这个功能非常重要，而且是Condition接口默认提供的。而
synchronized关键字就相当于整个Lock对象中只有一个Condition实例， 所有的线程都注册在它一个身上。如果
执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的
signalAll()方法 只会唤醒注册在该Condition实例中的所有等待线程

面试中关于线程池的4连击

讲一下Java内存模型，

在当前Java内存模型下，线程可以把变量保存本地内存中，而不是直接在主存中进行读写，这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。

需要解决这个问题，就需要把变量声明为volatile，这就指示JV吗，这个变量是不稳定的，每次使用它都到主内存中进行读取。说白了，volatile关键字的主要作用就是保证变量的可见性然后还有一个作用就是防止指令重排序。

说说synchronized关键字和volatile关键字的区别

synchronized关键字和volatile关键字比较

volatile关键字是轻量级的线程同步，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块，实际开发中synchronized的使用场景还是更多一些。

多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能发生阻塞
volatile关键字能保证数据的可见性，一致性，和禁止指令重排，但是无法保证原子性，synchronized两者都可保证。
volatile关键字主要用于解决变量在多个线程之间的可见性，而synchronized关键字解决的是多个线程之间访问资源的同步性。

为什么要用线程池？
线程池提供了一种限制和管理资源（包括执行一个任务）。每个线程池还维护一些基本统计信息，例如已完成任务的数量。

**降低资源消耗。**通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
提高响应速度当任务到达时，任务可以不需要等到线程创建就能立即执行。
提高线程的可管理性线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源， 还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

实现Runnable接口和Callable接口的区别
如果想让线程池执行任务的话，需要实现的Runnable接口或Callable接口，Runnable接口或Callable接口实现类都可以被ThreadPoolExecutors或ScheduledThreadPoolExecutor执行。两者的区别在于Runnable接口不会返回结果但是Callable接口可以返回结果。

执行execute（）方法和submit（）方法的区别是什么呢？

execute方法 用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；

submit（）方法 方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功，并且可以通过future的get（)方法来获取返回值，get（）方法会阻塞当前线程直到任务完成，而使用
get（long timeout，TimeUnit unit） 方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行
完。

如何创建线程池
不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式会更加明确线程池的运行规则，规避资源耗尽的风险。

Executors 返回线程池对象的弊端如下：
FixedThreadPool 和 SingleThreadExecutor ： 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积
大量的请求，从而导致OOM。
CachedThreadPool 和 ScheduledThreadPool ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能
会创建大量线程，从而导致OOM。

方式一：通过构造方法实现
方式二：通过Executor 框架的工具类Executors来实现 我们可以创建三种类型的ThreadPoolExecutor：
FixedThreadPool ： 该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的
任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线
程空闲时，便处理在任务队列中的任务。
SingleThreadExecutor： 方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会
被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。
CachedThreadPool： 该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但
若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新
的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。

介绍一下Atomic原子类
顾名思义：为不可分割的最小单位

JUC包中的原子类是哪4种？

使用原子的方式更新基本类型
AtomicInteger：整形原子类
AtomicLong：长整型原子类
AtomicBoolean ：布尔型原子类

数组类型
使用原子的方式更新数组里的某个元素
AtomicIntegerArray：整形数组原子类
AtomicLongArray：长整形数组原子类
AtomicReferenceArray ：引用类型数组原子类

引用类型
AtomicReference：引用类型原子类
AtomicStampedRerence：原子更新引用类型里的字段原子类
AtomicMarkableReference ：原子更新带有标记位的引用类型

对象的属性修改类型
AtomicIntegerFieldUpdater:原子更新整形字段的更新器AtomicLongFieldUpdater：原子更新长整形字段的更新器
AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原
子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。

讲讲AtomicInteger的使用
Atomiclnteget类常用方法

public final int get() //获取当前的值
public final int getAndSet(int newValue)//获取当前的值，并设置新的值
public final int getAndIncrement()//获取当前的值，并自增
public final int getAndDecrement() //获取当前的值，并自减
public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输
入值（update）
public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程
在之后的一小段时间内还是可以读到旧的值。

Atomiclnteger类的使用示例
使用AtomicInteger之后，不用对increment（）方法加锁也可以保证线程安全。

class AtomicIntegerTest {
private AtomicInteger count = new AtomicInteger();
//使用AtomicInteger之后，不需要对该方法加锁，也可以实现线程安全。
public void increment() {
count.incrementAndGet();
}
public int getCount() {
return count.get();
}
}

简单介绍AtomicInteger类的原理
AtomicInteger线程安全原理简单分析：
AtomicInteger类主要利用CAS（compare and swap）+ volatile和native方法来保证原子操作，从而避免synchronized的高开销，执行效率大为提升。

CAS的原理是拿期望值和原本的一个值作比较，如果相同则更新成新的值，UnSafe类的ObjectFieldOffset（）方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址，返回值是valueOffset。另外value是一个volatile变量，在内存中可见，因此JVM可以保证任何时刻任何线程总能拿到该变量的最新值。

AtomicInteger类的部分源码：

AtomicInteger类主要利用CAS（比较和交换）+ Volatile和native方法来保证原子操作，从而避免synchronized的高开销，执行效率大为提升。

CAS原理是拿期望值和原值比较，如果相同的话，则更新成新的值，UnSafe类的objectFieldOffset（）方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址，返回值是valueOffset。另外value是一个volatile变量，在内存中可见，因此JVM可以保证任何时刻任何线程总能拿到该变量的最新值。