多线程/线程池/锁相关面试总结
文章目录
多线程(线程池)
启动线程调用start() 方法,run()方法是线程启动后需要执行的方法。
1. 继承thread类
2. 实现runnable 接口
3. 实现callable 接口(call()方法,有返回值通过future对象的get()方法可以获取返回值,get()方法会阻塞,直到任务结果返回)
Callable 和 Future接口的区别
1. Callable规定的方法是call(),而Runnable规定的方法是run()。
2. Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。
3. call()方法可抛出异常,而run()方法是不能抛出异常的。
4. 运行Callable任务可拿到一个Future对象, Future表示异步计算的结果。
5. 它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果。
6. 通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果。
7. Callable是类似于Runnable的接口,实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务
线程池:

常用的是 ThreadPoolExecutor 类 自定义 corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit, BlockingQueue
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}线程池公式 :
maximumPoolSize = 2 * corePoolSize = 4 * cpu线程数
Executors线程池工具类:
Executors.new SingleThreadPoolExecutor(); 最大线程数为1
Executors.new FixedThreadPool() :核心线程数 = 最大线程数
Executors.new CachedThreadPool() :缓存线程池
Executors.new ScheduledThreadPoolExecutor(5) :延迟/周期性线程池 single和fixed阻塞队列最大为 Interger.MAX_VALUE [2的31次方];
cached 和scheduled 最大线程数为 Interger.MAX_VALUE [2的31次方];
===========================================================================
锁 :
锁分类:
- 可重入锁:Synchronized和ReentrantLook都是可重入锁,锁的可重入性标明了锁是针对线程分配方式而不是针对方法。例如调用Synchronized方法A中可以调用Synchronized方法B,而不需要重新申请锁。
- 读写锁:按照数据库事务隔离特性的类比读写锁,在访问统一个资源(一个文件)的时候,使用读锁来保证多线程可以同步读取资源。ReadWriteLock是一个读写锁,通过readLock()获取读锁,通过writeLock()获取写锁。
- 可中断锁:可中断是指锁是可以被中断的,Synchronized内置锁是不可中断锁,ReentrantLock可以通过lockInterruptibly方法中断显性锁。例如线程B在等待等待线程A释放锁,但是线程B由于等待时间太久,可以主动中断等待锁。
- 公平锁:公平锁是指尽量以线程的等待时间先后顺序获取锁,等待时间最久的线程优先获取锁。synchronized隐性锁是非公平锁,它无法保证等待的线程获取锁的顺序,ReentrantLook可以自己控制是否公平锁。
两种锁的底层实现:
- Synchronized:底层使用指令码方式来控制锁的,映射成字节码指令就是增加来两个指令:monitorenter和monitorexit。当线程执行遇到monitorenter指令时会尝试获取内置锁,如果获取锁则锁计数器+1,如果没有获取锁则阻塞;当遇到monitorexit指令时锁计数器-1,如果计数器为0则释放锁。
- Lock:底层是CAS乐观锁,依赖AbstractQueuedSynchronizer类,把所有的请求线程构成一个CLH队列。而对该队列的操作均通过Lock-Free(CAS)操作。
Synchronized和Lock比较
- Synchronized是关键字,内置语言实现,Lock是接口。
- Synchronized在线程发生异常时会自动释放锁,因此不会发生异常死锁。Lock异常时不会自动释放锁,所以需要在finally中实现释放锁。
- Lock是可以中断锁,Synchronized是非中断锁,必须等待线程执行完成释放锁。
- Lock可以使用读锁提高多线程读效率。
sychronized :
Lock :使用Lock必须在try…catch…块中进行,并且将释放锁的操作放在finally块中进行
ReentrantLock: (用法lock.tryLock() )
// 获取锁
void lock()
// 如果当前线程未被中断,则获取锁,可以响应中断
void lockInterruptibly()
// 返回绑定到此 Lock 实例的新 Condition 实例
Condition newCondition()
// 仅在调用时锁为空闲状态才获取该锁,可以响应中断
boolean tryLock()
// 如果锁在给定的等待时间内空闲,并且当前线程未被中断,则获取锁
boolean tryLock(long time, TimeUnit unit)
// 释放锁
void unlock() tryLock()方法是有返回值的,它表示用来尝试获取锁,如果获取成功,则返回true;如果获取失败(即锁已被其他线程获取),则返回false,也就是说,这个方法无论如何都会立即返回(在拿不到锁时不会一直在那等待)。
tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的,只不过区别在于这个方法在拿不到锁时会等待一定的时间,在时间期限之内如果还拿不到锁,就返回false,同时可以响应中断。如果一开始拿到锁或者在等待期间内拿到了锁,则返回true。
ReentrantReadWriteLock : 读写锁 (用法 lock.readLock().lock())
要点 : 共享读,独占写//返回用于读取操作的锁
Lock readLock()
//返回用于写入操作的锁
Lock writeLock() 代码示例 :
// 读数据
public void get() {
// 加读锁
lock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName() + " be ready to read data!");
Thread.sleep((long) (Math.random() * 1000));
System.out.println(Thread.currentThread().getName() + " have read data :" + data);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放读锁
lock.readLock().unlock();
}
}
// 写数据
public void put(Object data) {
// 加写锁
lock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName() + " be ready to write data!");
Thread.sleep((long) (Math.random() * 1000));
this.data = data;
System.out.println(Thread.currentThread().getName() + " have write data: " + data);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放写锁
lock.writeLock().unlock();
}
}
}
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论