Java 基础面试题——多线程
if (corePoolSize < 0 ||maximumPoolSize <= 0 ||maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.acc = System.getSecurityManager() == null ?null:AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
四种拒绝策略
image-20210527134117484
/**
new ThreadPoolExecutor.AbortPolicy() //银行满了，还有人进来，不处理这个人的，抛出异常
new ThreadPoolExecutor.CallerRunsPolicy() //哪来的去哪里！
new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常！
new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试和最早的竞争，也不会抛出异常
线程生命周期(状态)
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态
public enum State {
// 新生,此时仅由 JVM 为其分配内存，并初始化其成员变量的值
NEW,
// 调用了 start()方法之后，该线程处于运行 Java 虚拟机会为其创建方法调用栈和程序计数器，等待调度运行
RUNNABLE,
// 阻塞
BLOCKED,
// 等待，死死地等
WAITING,
// 超时等待
TIMED_WAITING,
// 终止
TERMINATED;
}
终止线程方法
除了正常退出外有三种方法可以结束线程
设置退出标志，使线程正常退出，也就是当 run()方法完成后线程终止
使用 interrupt()方法中断线程
使用 stop 方法强行终止线程(不推荐使用)
1.使用退出标志终止线程
最直接的方法就是设一个 boolean 类型的标志，并通过设置这个标志为 true 或 false 来控制 while 循环是否退出
public class ThreadSafe extends Thread {
public volatile boolean exit = false;
public void run() {
while (!exit){
//do something
}
}
}
2.使用 interrupt()方法中断当前线程
使用 interrupt()方法来中断线程有两种情况：
线程处于阻塞状态当调用线程的 interrupt()方法时，会抛出 InterruptException 异常。阻塞中的那个方法抛出这个异常，通过代码捕获该异常，然后 break 跳出循环状态，从而让我们有机会结束这个线程的执行。
线程未处于阻塞状态，使用 isInterrupted()判断线程的中断标志来退出循环。
代码演示:
//第一种情况
public class ThreadSafe extends Thread {
public void run() {
while (true){
try{
Thread.sleep(5*1000);//阻塞 5 妙
}catch(InterruptedException e){
e.printStackTrace();
break;//捕获到异常之后，执行 break 跳出循环。
}
}
}
}
//第二种情况
public class ThreadSafe extends Thread {
public void run() {
while (!isInterrupted()){
//do something, but no throw InterruptedException
}
}
}
3.使用 stop 方法终止线程
程序中可以直接使用 thread.stop()来强行终止线程，但是 stop 方法是很危险的
不安全主要是：
thread.stop()调用之后，创建子线程的线程就会抛出ThreadDeatherror的错误，并且会释放子线程所持有的所有锁。一般任何进行加锁的代码块，都是为了保护数据的一致性，如果在调用thread.stop()后导致了该线程所持有的所有锁的突然释放(不可控制)，那么被保护数据就有可能呈现不一致性，其他线程在使用这些被破坏的数据时，有可能导致一些很奇怪的应用程序错误。
Java 线程锁
乐观锁
乐观锁是一种乐观思想，即认为读多写少，遇到并发写的可能性低，每次去拿数据的时候都认为 别人不会修改，所以不会上锁但是在更新的时候会判断一下在此期间别人有没有去更新这个数 据，采取在写时先读出当前版本号，然后加锁操作,如果失败则要重复读-比较-写的操作。
java 中的乐观锁基本都是通过 CAS 操作实现的，CAS 是一种更新的原子操作
悲观锁
悲观锁是就是悲观思想，即认为写多，遇到并发写的可能性高，每次去拿数据的时候都认为别人 会修改，所以每次在读写数据的时候都会上锁，这样别人想读写这个数据就会 block 直到拿到锁。
java 中的悲观锁就是Synchronized
自旋锁
如果持有锁的线程能在很短时间内释放锁资源，那么那些等待竞争锁 的线程就不需要做内核态和用户态之间的切换进入阻塞挂起状态，它们只需要等一等（自旋）， 等持有锁的线程释放锁后即可立即获取锁，这样就避免用户线程和内核的切换的消耗
优缺点
自旋锁_尽可能的减少线程的阻塞_，
这对于锁的竞争不激烈，且占用锁时间非常短的代码块来 说性能能大幅度的提升，因为自旋的消耗会小于线程阻塞挂起再唤醒的操作的消耗，这些操作会 导致线程发生两次上下文切换！
但是如果锁的竞争激烈，或者持有锁的线程需要长时间占用锁执行同步块，这时候就不适合 使用自旋锁了，因为自旋锁在获取锁前一直都是占用 cpu 做无用功，占着 XX 不 XX，同时有大量 线程在竞争一个锁，会导致获取锁的时间很长，线程自旋的消耗大于线程阻塞挂起操作的消耗， 其它需要 cup 的线程又不能获取到 cpu，造成 cpu 的浪费。所以这种情况下我们要关闭自旋锁；
Synchronized 同步锁
synchronized 它可以把任意一个非 NULL 的对象当作锁。他属于独占式的悲观锁，同时属于可重 入锁。
Synchronized 作用范围
作用于方法时，锁住的是对象的实例(this)；
当作用于静态方法时，锁住的是 Class 实例，此静态方法锁相当于类的一个全局锁， 会锁所有调用该方法的线程
synchronized 作用于一个对象实例时，锁住的是所有以该对象为锁的代码块。
lock 锁
//lock 锁通常使用可重入锁 ReentrantLock
Lock lock = new ReentrantLock();
ReentantLock 继承接口 Lock 并实现了接口中定义的方法，他是一种可重入锁，除了能完 成 synchronized 所能完成的所有工作外，还提供了诸如可响应中断锁、可轮询锁请求、定时锁等 避免多线程死锁的方法
public class SaleTicketDemo02 {
public static void main(String[] args) {
// 并发：多线程操作同一个资源类, 把资源类丢入线程
Ticket2 ticket = new Ticket2();
// @FunctionalInterface 函数式接口，jdk1.8 lambda 表达式 (参数)->{ 代码 }
new Thread(()->{for (int i = 1; i < 40 ; i++)
ticket.sale();},"A").start();
new Thread(()->{for (int i = 1; i < 40 ; i++)
ticket.sale();},"B").start();
new Thread(()->{for (int i = 1; i < 40 ; i++)
ticket.sale();},"C").start();
}
}
// Lock 三部曲
// 1、 new ReentrantLock();
// 2、 lock.lock(); // 加锁
// 3、 finally=> lock.unlock(); // 解锁
class Ticket2 {
// 属性、方法
private int number = 30;
Lock lock = new ReentrantLock();
public void sale(){
lock.lock(); // 加锁
try {
// 业务代码
if (number>0){
System.out.println(Thread.currentThread().getName()+"卖出了"+
(number--)+"票,剩余："+number);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock(); // 解锁
}
}
}
synchronized 和 lock 锁的区别
synchronized 是 java 内置的关键字，lock 是一个 java 类
synchronized 无法获取锁的状态，lock 可以判断是否获得了锁
synchronized 会自动释放锁，lock 不会自动释放锁，需要自己手动释放锁，如果不释放锁，会造成死锁
synchronized 线程一（获得锁，然后锁阻塞了），线程二（等待，然后还是傻傻的等待），lock 锁就不一定会等待下去
synchronized 可重入锁，不可以被中断，非公平，lock 可重入锁，可判断锁，是否为公平锁，可以自行设置
synchronized 适合少量的代码同步问题，lock 适合大量的代码同步问题
公平锁与非公平锁
公平锁：十分公平：可以先来后到
非公平锁：十分不公平：可以插队 （默认）
读写锁
为了提高性能，Ja
va 提供了读写锁，在读的地方使用读锁，在写的地方使用写锁，灵活控制，
如果没有写锁的情况下，读是无阻塞的,在一定程度上提高了程序的执行效率。
读写锁分为读锁和写 锁，多个读锁不互斥，读锁与写锁互斥，这是由 jvm 自己控制的，你只要上好相应的锁即可。
读锁
如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁
写锁
如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁。总之，读的时候上 读锁，写的时候上写锁！
// 加锁的
class MyCacheLock{
private volatile Map<String,Object> map = new HashMap<>();
// 读写锁： 更加细粒度的控制
private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
private Lock lock = new ReentrantLock();
// 存，写入的时候，只希望同时只有一个线程写
public void put(String key,Object value){
readWriteLock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"写入"+key);
map.put(key,value);
System.out.println(Thread.currentThread().getName()+"写入 OK");
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.writeLock().unlock();
}
}
// 取，读，所有人都可以读！
public void get(String key){
readWriteLock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"读取"+key);
Object o = map.get(key);
System.out.println(Thread.currentThread().getName()+"读取 OK");
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.readLock().unlock();
}
}
}
锁优化
减少锁持有时间
只用在有线程安全要求的程序上加锁
减小锁粒度
将大对象（这个对象可能会被很多线程访问），拆成小对象，大大增加并行度，降低锁竞争。
锁分离
最常见的锁分离就是读写锁 ReadWriteLock，根据功能进行分离成读锁和写锁，这样读读不互 斥，读写互斥，写写互斥，即保证了线程安全，又提高了性能，
锁粗化
要求每个线程持有锁的时间尽量短，即在使用完 公共资源后，应该立即释放锁。
但是，凡事都有一个度，如果对同一个锁不停的进行请求、同步 和释放，其本身也会消耗系统宝贵的资源，反而不利于性能的优化
锁消除
如果发现不可能被共享的对象，则可以消除这 些对象的锁操作
死锁
两个线程或两个以上线程都在等待对方执行完毕才能继续往下执行的时候就发生了死锁。结果就是这些线程都陷入了无限的等待中。
如何避免线程死锁?
只要破坏产生死锁的四个条件中的其中一个就可以了。
破坏互斥条件：这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）。
破坏请求与保持条件：一次性申请所有的资源。
破坏不剥夺条件：占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
破坏循环等待条件：靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放
线程基本方法
线程相关的基本方法有 wait，notify，notifyAll，sleep，join，yield 等。
线程等待（wait）
调用该方法的线程进入 WAITING 状态，只有等待另外线程的通知或被中断才会返回，需要注意的是调用 wait()方法后，会释放对象的锁。
线程睡眠（sleep）
sleep 导致当前线程休眠，与 wait 方法不同的是 sleep 不会释放当前占有的锁,sleep(long)会导致线程进入 TIMED-WATING 状态，而 wait()方法会导致当前线程进入 WATING 状态
线程让步（yield）
yield 会使当前线程让出 CPU 执行时间片，与其他线程一起重新竞争 CPU 时间片。一般情况下，优先级高的线程有更大的可能性成功竞争得到 CPU 时间片
线程中断（interrupt ）
中断一个线程，其本意是给这个线程一个通知信号，会影响这个线程内部的一个中断标识位。这个线程本身并不会因此而改变状态
Join 等待其他线程终止
在当前线程中调用一个线程的 join() 方法，则当前线程转为阻塞状态，直到另一个线程结束，当前线程再由阻塞状态变为就绪状态，等待 cpu 的宠幸。
为什么要用 join() 方法 ？
很多情况下，主线程生成并启动了子线程，需要用到子线程返回的结果，也就是需要主线程需要在子线程结束后再结束，这时候就要用到 join() 方法。
线程唤醒（notify）
唤醒在此对象监视器上等待的单个线程，如果所有线程都在此对象上等待，则会选择唤醒其中一个线程，选择是任意的，被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争。
其他方法：
sleep()：强迫一个线程睡眠Ｎ毫秒。
isAlive()： 判断一个线程是否存活。
join()： 等待线程终止。
activeCount()： 程序中活跃的线程数。
enumerate()： 枚举程序中的线程。
currentThread()： 得到当前线程。
isDaemon()： 一个线程是否为守护线程。
setDaemon()： 设置一个线程为守护线程。(用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束)
setName()： 为线程设置一个名称。
wait()： 强迫一个线程等待。
notify()： 通知一个线程继续运行。
setPriority()： 设置一个线程的优先级。
getPriority():：获得一个线程的优先级。
volatile 与 synchronized
volatile 特点
保证可见性
不保证原子性
使用场景
对变量的写操作不依赖于当前值（比如 i++），或者说是单纯的变量赋值（boolean flag = true）
该变量没有包含在具有其他变量的不变式中，也就是说，不同的 volatile 变量之间，不 能互相依赖。只有在状态真正独立于程序内其他内容时才能使用 volatile
区别:
修饰对象不同，volatile 用于修饰变量，synchronized 用与对语句和方法加锁；
各自作用不同，volatile 保证数据的可见性和有序性，但它并不能保证数据的原子性，synchronized 可以保证原子性；
volatile 不会造成线程堵塞，而 synchronized 会造成线程堵塞；
常用的辅助类
CountDownLatch（线程计数器 ）
可以实现类似计数器的功能。比如有 一个任务 A，它要等待其他 4 个任务执行完毕之后才能执行，此时就可以利用 CountDownLatch 来实现这种功能了
public static void main(String[] args) throws InterruptedException {
// 总数是 6，必须要执行任务的时候，再使用！
CountDownLatch countDownLatch = new CountDownLatch(6);
for (int i = 1; i <=6 ; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+" Go out");
countDownLatch.countDown(); // 数量-1
},String.valueOf(i)).start();
}
countDownLatch.await(); // 等待计数器归零，然后再向下执行
System.out.println("Close Door");
}
CyclicBarrier（回环栅栏-等待至 barrier 状态再全部同时执行）
通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环 是因为当所有等待线程都被释放以后，CyclicBarrier 可以被重用。
public static void main(String[] args) {
/**
集齐 7 颗龙珠召唤神龙
*/
// 召唤龙珠的线程
CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
System.out.println("召唤神龙成功！");
});
for (int i = 1; i <=8 ; i++) {
final int temp = i;
// lambda 能操作到 i 吗
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"收集"+temp+"个龙珠");
try {
cyclicBarrier.await(); // 等待
} catch (InterruptedException e) {
e.printStackTrace();
评论