这些年背过的面试题——多线程篇

① 其他线程调用了该Object的notify方法，而该线程刚好是那个被唤醒的线程；

• wait 方法必须在 synchronized 保护的代码中使用，而 sleep 方法并没有这个要求。

• wait 方法会主动释放 monitor 锁，在同步代码中执行 sleep 方法时，并不会释放 monitor 锁。

• wait 方法意味着永久等待，直到被中断或被唤醒才能恢复，不会主动恢复，sleep 方法中会定义一个时间，时间到期后会主动恢复。

• wait/notify 是 Object 类的方法，而 sleep 是 Thread 类的方法。

public class RunnableThread implements Runnable {    @Override    public void run() {System.out.println('用实现Runnable接口实现线程');}}

class CallableTask implements Callable<Integer> {    @Override    public Integer call() throws Exception { return new Random().nextInt();}}

public class ExtendsThread extends Thread {    @Override    public void run() {System.out.println('用Thread类实现线程');}}

static class DefaultThreadFactory implements ThreadFactory {    DefaultThreadFactory() {        SecurityManager s = System.getSecurityManager();        group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();        namePrefix = "pool-" + poolNumber.getAndIncrement() +"-thread-";    }    public Thread newThread(Runnable r) {        Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(),0);        if (t.isDaemon()) t.setDaemon(false);  //是否守护线程        if (t.getPriority() != Thread.NORM_PRIORITY) t.setPriority(Thread.NORM_PRIORITY); //线程优先级        return t;    }}

/*** 线程池构造函数7大参数*/public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,    TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,    RejectedExecutionHandler handler) {}

1. 当线程池小于corePoolSize，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程。

2. 当线程池达到corePoolSize时，新提交任务将被放入 workQueue 中，等待线程池中任务调度执行。

3. 当workQueue已满，且 maximumPoolSize 大于 corePoolSize 时，新提交任务会创建新线程执行任务。

4. 当提交任务数超过 maximumPoolSize 时，新提交任务由 RejectedExecutionHandler 处理。

5. 当线程池中超过corePoolSize 线程，空闲时间达到 keepAliveTime 时，关闭空闲线程 。

• newSingleThreadExecutor()：只有一个线程的线程池，任务是顺序执行，适用于一个一个任务执行的场景
• newCachedThreadPool()：线程池里有很多线程需要同时执行，60s内复用，适用执行很多短期异步的小程序或者负载较轻的服务
• newFixedThreadPool()：拥有固定线程数的线程池，如果没有任务执行，那么线程会一直等待，适用执行长期的任务。
• newScheduledThreadPool()：用来调度即将执行的任务的线程池

• newWorkStealingPool()：底层采用forkjoin的Deque，采用独立的任务队列可以减少竞争同时加快任务处理

FixedThreadPool 和 SingleThreadExecutor ：允许请求的队列⻓度为 Integer.MAX_VALUE，会导致OOM。

CachedThreadPool 和 ScheduledThreadPool ：允许创建的线程数量为 Integer.MAX_VALUE，会导致OOM。

• CPU 密集型（n+1）

CPU 密集的意思是该任务需要大量的运算，而没有阻塞，CPU 一直全速运行。

CPU 密集型任务尽可能的少的线程数量，一般为 CPU 核数 + 1 个线程的线程池。

• IO 密集型（2*n）

由于 IO 密集型任务线程并不是一直在执行任务，可以多分配一点线程数，如 CPU * 2 

通常情况下，我们创建的变量是可以被任何⼀个线程访问并修改的。如果想实现每⼀个线程都有⾃⼰的。

专属本地变量该如何解决呢？JDK中提供的 ThreadLocal 类正是为了解决这样的问题。类似操作系统中的TLAB。

private static final ThreadLocal threadSession = new ThreadLocal();

private static ThreadLocal<SimpleDateFormat> format1 = new ThreadLocal<SimpleDateFormat>()

1. 可以使用字符串常量池，多次创建同样的字符串会指向同一个内存地址；
2. 可以很方便地用作 HashMap 的 key。通常建议把不可变对象作为 HashMap的 key；
3. hashCode生成后就不会改变，使用时无需重新计算；

4. 线程安全，因为具备不变性的对象一定是线程安全的；

1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；

2）它会强制将对缓存的修改操作立即写入主存；

class Singleton{    private volatile static Singleton instance = null;   //禁止指令重排    private Singleton() {             }    public static Singleton getInstance() {        if(instance==null) { //减少加锁的损耗            synchronized (Singleton.class) {                if(instance==null) //确认是否初始化完成                    instance = new Singleton();            }        }        return instance;    }}

状态的原子性管理线程的阻塞与解除阻塞队列的管理

AQS核⼼思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的⼯作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占⽤，那么就需要⼀套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是⽤CLH（虚拟的双向队列）队列锁实现的，即将暂时获取不到锁的线程加⼊到队列中。