1、并发、并行、串行的区别
- 串行在时间上不可能发生重叠,前一个任务没搞定,下一个任务就只能等着。
- 并行是时间上是重叠的,两个任务在同一时刻互不干扰地同时执行。
- 并发允许两个任务彼此干扰。同一时间点只有一个任务允许,交替执行。比如cpu就是并行的。
2、并发的三大特性
原子性
原子性是指在一个操作中cpu不可以在中途暂停然后再调度,即不被中断操作,要不全部执行完成,要不都不执行。就好比转账,从账户A向账户B转1000元,那么必然包括了2个操作:从账户A减去1000元,往账户B加上1000元。2个操作必须全部完成。
i++不是原子的,它分为4个步骤。
private long count = 0;
public void calc() {
count++;
}
- 将count从主存读到工作内存中的副本中
- +1的运算
- 将结果写入工作内存
- 将工作内存的值刷回主存(什么时候刷入由操作系统决定,不确定的)
那程序中原子性指的是最小的操作单元,比如自增操作,它本身其实并不是原子性操作,分了3步的,包括读取变量的原始值、进行加1操作、写入工作内存。所以在多线程中,有可能一个线程还没自增玩,可能才执行到第二步,另一个线程就已经读取了值,导致结果错误。那如果我们能保证自增操作是一个原子性的操作,那么就能保证其他线程读取到的一定是自增后的数据。
把上面操作的前3步操作变为原子性的,但是第四步还可能导致数据异常,这就看下面的可见性。有原子性和可见性,才能使得i++是安全的。
使用AtomicInteger能保证线程安全,它使用的Volatitle,它保证了可见性,里面还用到了CAS,它保证了原子性。
关键字: synchronized
可见性
当多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看得到修改的值。
若两个线程在不同的cpu,那么线程1改变了i的值还没刷新到主存,线程2又使用了i,那么这个i值肯定还是之前的,线程1对变量的修改线程2没看到,这就是可见性问题。
// 线程1
boolean stop = false;
while(!stop) {
doSomething();
}
// 线程2
stop = true;
如果线程2改变了stop的值,线程1一定会停止吗?不一定。当线程2更改了stop变量的值之后,但是还没来得及写入主存中,线程2转去做其他事情了,那么线程1由于不知道线程2对stop变量的更改,因此还会一直循环下去。
操作系统底层两个协议: 总线锁定, MESI(缓存一致性协议)。使用这两个协议保证变量的可见性。t1线程对0进行+1操作,这时候t2拿到的0会失效,这就是由这两个协议保证的。数据往线程的工作内存和主存写的两步也是原子操作,这也是可见性保证的。
关键字:volatile、 synchronized、final
有序性
虚拟机在进行代码编译时,对于那些改变顺序之后不会对最终结果造成影响的代码,虚拟机不一定会按照我们写的代码顺序来执行,有可能将他们重排序。实际上,对于有些代码进行重排序之后,虽然对变量的值没有造成影响,但有可能会出现线程安全问题。
int a = 0;
bool flag = false;
public void write() {
a = 2; // 1
flag = true; // 2
}
public void multiply() {
if(flag) { // 3
int ret = a * a; // 4
}
}
write方法里的 1和2做了重排序,线程1先对flag赋值为true,随后执行到线程2,ret直接计算出结果,再到线程1,这时候a才赋值为2,很明显迟了一步。
关键字: volatile、 synchronized
创建一个对象 比如new User(); 其实会分为三步, 第一个申请一块内存,第二步给内存属性复制User,第三部给栈中变量赋值。这个场景适合volatile。
3、线程的生命周期、线程有哪些状态?
1、线程通常有五种状态,创建、就绪、运行、阻塞、死亡。
2、阻塞的情况又分为三种:
- 等待阻塞:运行的线程执行wait方法,该线程会释放占用的所有资源,jvm会把该线程放入“等待池” 中。进入这个状态后,是不能自动唤醒的,必须依靠其他线程调用notify或notifyAll方法才能被唤醒,wait是object类的方法。
- 同步阻塞: 运行的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则jvm会把该线程放入“锁池”中。
- 其他阻塞:运行的线程执行sleep或join方法,或发出了io请求时,jvm会把该线程置为阻塞状态。当sleep状态超时、join等待线程终止或者超时、或者io处理完毕时,线程重新转入就绪状态。sleep是Thread类的方法。
1、新建状态(New): 新创建了一个线程对象。
2、就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权。
3、运行状态(Running):就绪状态的线程获取了CPU,执行程序代码。
4、阻塞状态(Blocked): 阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。
5、死亡状态(Dead):线程执行完了或者因异常退出了run方法,该线程结束生命周期。
4、sleep() 、wait()、join()、yield()的区别
1、锁池
所有需要竞争同步锁的线程都会放在锁池当中,比如当前对象的锁已经被其中一个线程得到,则其他线程需要在这个锁池进行等待,当前面的线程释放同步锁后锁池中的线程去竞争同步锁,当某个线程得到后会进入就绪队列进行等待cpu资源分配。
2、等待池
当我们调用wait()方法后,线程会放到等待池当中,等待池的线程是不会去竞争同步锁。只有调用了notify()或notifyAll()后等待池的线程才会开始去竞争锁,notify()是随机从等待池选出一个线程放到锁池,而notifyAll()是将等待池的所有线程放到锁池当中。
sleep和wait的不同
1、sleep是Thread类的静态本地方法,wait则是Object类的本地方法。
2、sleep方法不会释放lock,但是wait会释放,而且会加入到等待队列中。
sleep就是把cpu的执行资格和执行权释放出去,不再运行此线程,当定时时间结束再取回cpu资源,参与cpu的调度,获取到cpu资源后就可以继续运行了。而如果sleep时该线程有锁,那么sleep不会释放这个锁,而是把锁带入了冻结状态,也就是说其他需要这个锁的线程根本不可能获取到这个锁。也就是说无法执行程序。如果在睡眠期间其他线程调用了这个线程的interrupt方法,那么这个线程也会抛出interruptexception异常返回,这点和wait是一样的。
3、sleep方法不依赖于同步器synchronized,但是wait需要依赖synchronized关键字。
4、sleep不需要被唤醒(休眠之后推出阻塞),但是wait需要(不指定时间需要被别人中断)。
5、sleep一般用于当前线程休眠,或者轮询暂停操作,wait则多用于线程之间的通信。
6、sleep会让出CPU执行时间且强制上下文切换,而wait则不一定,wait后可能还是有机会重新竞争到锁继续执行的。
yield和join
yield()执行后线程直接进入就绪状态,马上释放了cpu的执行权,但是依然保留了cpu的执行资格,所以有可能cpu下次进行线程调度还会让这个线程获取到执行权继续执行。
join()执行后线程进入阻塞状态,例如在线程B中调用线程A的join(),那线程B会进入到阻塞队列,直到线程A结束或中断线程。
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable(){
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printLn("22222");
}
});
t1.start();
t1.join();
// 这行代码必须要等t1全部执行完毕,才会执行
System.out.printLn("1111");
}
5、说说你对线程安全的理解
不是线程安全,应该是内存安全,堆是共享内存,可以被所有线程访问。
当多个线程访问一个对象时,如果不用进行额外的同步控制或其他的协调操作,调用这个对象的行为都可以获得正确的结果,我们就说这个对象是线程安全的。
堆是进程和线程共有的空间,分全局堆和局部堆。全局堆就是所有没有分配的空间,局部堆就是用户分配的空间。堆在操作系统对进程初始化的时候分配,运行过程中也可以向系统要额外的堆,但是用完了要还给操作系统,要不然就内存泄露了。
在Java中,堆是Java虚拟机所管理的内存中最大的一块,是所有线程共享的一块内存区域,在虚拟机启动时创建。堆所在内存区域的唯一目的就是存放对象实例,几乎所有的对象实例以及数据都在这里分配内存。
栈是每个线程独有的,保存其运行状态和局部自动变量的。栈在线程开始的时候初始化,每个线程的栈相互独立,因此,栈是线程安全的。操作系统在切换线程的时候会自动切换栈。栈空间不需要在高级语言里面显示地分配和释放。
目前主流操作系统都是多任务的,即多个进程同时运行。为了保证安全,每个进程只能访问分配给自己的内存空间,而不能访问别的进程的,这是由操作系统保障的。
在每个进程的内存空间中都会有一块特殊的公共区域,通常成为堆(内存)。进程内的所有线程都可以访问到该区域,这就是造成问题的潜在原因。
6、Thread、Runnable
Thread和Runnable的实质是继承关系,没有可比性。无论使用Runnable还是Thread, 都会new Thread,然后执行run方法。用法上,如果有复杂的线程操作需求,那就选择继承Thread,如果只是简单的执行一个任务,那就实现runnable。
8、说说你对守护线程的理解
9、ThreadLocal的原理和使用场景
每一个Thread对象均含有一个ThreadLocalMap类型的成员变量threadLocals,它存储本线程中所有ThreadLocal对象及其对应的值。
ThreadLocalMap由一个个Entry对象构成。Entry继承自WeakReference<ThreadLocal<?>>, 一个Entry由ThreadLocal对象和Object构成。由此可见,Entry的key是ThreadLocal对象,并且是一个弱引用。当没指向key的强引用后,该key就会被垃圾收集器回收。
当执行set方法时,TheadLocal首先会获取当前线程对象,然后获取当前线程的ThreadLocalMap对象。再以当前ThreadLocal对象为key,将值存储进ThreadLocalMap对象中。
get方法执行过程类似。ThreadLocal首先会获取当前线程对象,然后获取当前线程的ThreadLocalMap对象。再以当前ThreadLocal对象为key,获取对应的value。
由于每一条线程均含有各自私有的ThreadLocalMap容器,这些容器相互独立互不影响,因此不会存在线程安全性问题,从而也无需使用同步机制来保证多条线程访问容器的互斥性。
使用场景:
1、在进行对象跨层传递的时候,使用ThreadLocal可以避免多次传递,打破层次间的约束。比如User对象需要在controler、service、dao层都要用到,就可以把它放到ThreadLocal中。
2、线程间数据隔离。
3、进行事务操作,用于存储线程事务信息。
4、数据库连接,Session会话管理,这些也都数据线程级的内容。
10、 ThreadLocal内存泄漏原因,如何避免
在程序中controller、service、dao都用共同的形参的时候,使用ThreadLocal很方便。对于内存泄露,只要是我们使用的问题。
内存泄露为程序在申请内存后,无法释放已申请的内存空间,一次内存泄露危害可以忽略,但内存泄露堆积后果很严重,无论多少内存,迟早会被占光。
不再会被使用的对象或者变量占用的内存不能被回收,就是内存泄漏。
强引用:使用最普遍的引用(new),一个对象具有强引用,不会被垃圾回收器回收。当内存空间不足,java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不回收这种对象。
如果想取消强引用和某个对象之间的关联,可以显式地将引用赋值为null,这样可以使jvm在合适的时间就会回收该对象。
弱引用:jvm进行垃圾回收时,无论内存是否充足,都会回收被弱引用关联的对象。在java中,用java.land.ref.Reference类来表示,可以在缓存中使用弱引用。
ThreadLocal的实现原理,每一个Thread维护一个ThreadLocalMap(线程本地变量),key为使用弱引用的ThreadLocal实例,value为线程变量的副本。
ThreadLocalMap使用ThreadLocal的弱引用作为key,如果一个ThreadLocal不存在外部强引用时,key(ThreadLocal)势必会被GC回收,这样就会导致ThreadLocalMap中key为null,而value还存在着强引用,只有thread线程退出以后,value的强引用联调才会断掉,但如果当前线程再迟迟不结束的话,这些key为null的Entry的value就会一直存在一条强引用链(红色链条)。
可以使用强引用
- 当ThreadLocalMap的key为强引用回收ThreadLocal时,因为ThreadLocalMap还持有TheadLocal的强引用,如果没有手动删除,ThreadLocal不会被回收,导致Entry内存泄露。
key使用弱引用
- 当ThreadLocalMap的key为弱引用回收ThreadLocal时,由于ThreadLocalMap持有ThreadLocal的弱引用,即时没有手动删除,ThreadLocal也会被回收。当key为null,在下一次ThreadLocalMap调用set()、get()、remove()方法的时候会被清除value值。
因此,ThreadLocal内存泄露的根源是:由于ThreadLocalMap的生命周期跟Thread一样长,如果没有手动删除对应key就会导致内存泄露,而不是因为弱引用。
TheadLocal正确的使用方法
- 每次使用完ThreadLocal都调用它的remove()方法清除数据。
- 将ThreadLocal变量定义成private static, 这样就一直存在TheadLocal的强引用,也就能保证任何时候都能通过TheadLocal的弱引用访问到Entry的value值,进而清除掉。
11、为什么用线程池?解释下线程池参数?
1、降低资源消耗;提高线程利用率,降低创建和销毁线程的消耗。
2、提高响应速度;任务来了,直接有线程可用可执行,而不是先创建线程,再执行。
3、提高线程的可管理性;线程是稀缺资源;使用线程池可以统一分配调优监控。
- corePoolSize 代表核心线程数,也就是正常情况下创建工作的线程数,这些线程创建后并不会消除,而是一种常驻线程。
- maxinumPoolSize: 代表的最大线程数,它与核心线程数相对应,表示最大允许被创建的线程数,比如当前任务较多,将核心线程数都用完了,还无法满足需求时,此时就会创建新的线程,但是线程池内线程总数不会超过最大线程数。
- keepAliveTime,unit 表示超出核心线程数之外的线程的空闲存活时间,也就是核心线程不会消除,但是超出核心线程数的部分线程如果空闲一定的时间则会被消除,我们可以通过setKeepAliveTime来设置空闲时间。
- workQueue 用来存放待执行的任务,假设我们现在核心线程都已被使用,还有任务进来则全部放入队列,直到整个队列被放满但任务还再持续进入则会开始创建新的线程。
- ThreadFactory 实际上是一个线程工厂,用来生产线程执行任务。我们可以选择使用默认的创建工厂,产生的线程都在同一个组内,拥有相同的优先级,且都不是守护线程。当然我们也可以选择自定义线程工厂,一般我们会根据业务来制定不同的线程工厂。
- Handler 任务拒绝策略,有两种情况,第一种是当我们调用shutdown等方法关闭线程池后,这时候即时线程池内部还没有执行完的任务正在运行,但是由于线程池关闭,我们再继续向线程池提交任务就会遭到拒绝。另一种情况就是当达到最大线程数,线程池已经没有能力继续处理新提交的任务时,这时也就拒绝。
12、简述线程池处理流程
13、线程池中阻塞队列的作用?为什么是先添加队列而不是先创建最大线程?
1、一般的队列只能保证作为一个有限长度的缓冲区,如果超出了缓冲长度,就无法保留当前的任务了,阻塞队列通过阻塞可以保留住当前想要继续入队的任务。
阻塞队列可以保证任务队列中没有任务时阻塞获取任务的线程,使得线程进入wait状态,释放cpu资源。
阻塞队列自带阻塞和唤醒功能,不需要额外处理,无任务执行时,线程池利用阻塞队列的take方法挂起,从而维持核心线程的存活,不至于一直占用cpu资源。
2、在创建新线程的时候,是要获取全局锁的,这个时候其它的就得阻塞,影响了整体效率。
就好比一个企业里面10个(core)正式工的名额,最多找10个正式工,要是任务超过正式人工数(task>core)的情况下,工厂领导(线程池)不是首先扩招工人,还是这10人, 但是任务可以稍微积压一下,即先放到队列去(代价低)。10个正式工慢慢干,迟早会干完的,要是任务还在继续增加,超过正式工的加班忍耐极限了(队列满了),就得招外包帮忙了(注意是临时工)要是正式工加上外包还是不能完成任务,那新来的任务就会被领导拒绝了(线程池的拒绝策略)。
14、线程池线程复用的原理
线程池将线程和任务进行解耦,线程是线程,任务是任务,摆脱了之前通过Thread创建线程时的一个线程必须对应一个任务的限制。
在线程池中,同一个线程可以从阻塞队列中不断获取新任务来执行,其核心原理在于线程池对thread进行了封装 ,并不是每次执行任务都会调用Thread.start()来创建新线程,而是让每个线程去执行一个“循环任务”,在这个“循环任务”中不停检查是否有任务需要执行,如果有则直接执行,也就是调用任务中的run方法,将run方法当成一个普通的方法执行,通过这种方式只使用固定的线程就将所有任务的run方法串联起来。
15、HashMap的扩容机制原理
1.7的HashMap就是用的数组和联表。
1.8的HashMap除了数组和联表,还用了红黑树。
1.7的扩容,是先生成新的数组,再把旧数组上的元素转移到新数组上面来,
- resize就是扩容方法。
- 有个双重循环,遍历数组每个下标,如果里面有链表要继续遍历。
1.8的扩容,也是先生成新的数组,再把链表转移过去,如果某个节点下是一个红黑树,hashmap就去计算每个节点在新数组和树上面的位置。因为根据数组容量的不同,节点位置都不同。所以当一个红黑树转移之后,可能被拆出来两个链表,或者一个链表一个红黑树等等各种可能。
16、JDK1.7到JDK1.8 HashMap发生了什么变化(底层)?
1、1.7中底层是数组+链表
17、ConcurrentHashMap的扩容机制
18、如果理解volatile关键字
在并发领域中,存在三大特性:原子性、有序性、可见性。volitle关键字用来修饰对象的属性,在并发环境下可以保证这个属性的可见性,对于加了volatile关键字的属性,在对这个属性进行修改时,会直接将cpu高级缓存中的数据写会到主内存,对这个变量的读取也会直接从主内存中读取,从而保证了可见性,底层是通过操作系统内存屏障来实现的,由于使用了内存屏障,所以会禁止指令重排,所以同时也就保证了有序性,在很多并发场景下,如果用好volatile关键字可以很好的提高执行效率。