1创建多线程的四种方式

1.1继承Thread类

• 定义一个类继承自 Thread 类，并重写 run() 方法。
• 创建该类的对象，并调用其 start() 方法启动新线程。

1.2实现Runnable接口

• 定义一个类并实现 Runnable 接口的 run() 方法。
• 创建该类的对象，并将其作为目标传递给一个 Thread 类的实例。
• 调用 Thread 实例的 start() 方法启动新线程。

1.3实现Callable接口（需借助FutureTask）

• 定义一个类并实现 Callable 接口的 call() 方法。
• 创建一个 FutureTask 对象，将 Callable 实例作为参数传入。
• 将 FutureTask 对象作为目标传递给一个 Thread 类的实例，并启动线程。
• 通过 FutureTask 对象的 get() 方法获取异步计算的结果。

1.4使用线程池

• 创建一个执行器服务，例如 Executors.newFixedThreadPool(int nThreads) 。
• 提交实现了 Runnable 或 Callable 接口的任务到执行器服务。
• 执行器服务会自动分配线程来执行这些任务。

2多线程生命周期

2.1背记

• 新建（New）：线程被创建后，尚未启动（未调用start()方法）的状态。
• 就绪（Runnable）：当线程对象的start()方法被调用后，线程进入就绪状态，此时线程已经准备好执行，等待CPU调度。
• 运行（Running）：当CPU开始调度处于就绪状态的线程时，线程进入运行状态，开始执行其任务。
• 阻塞（Blocked）：线程在运行过程中遇到同步锁但申请锁失败，会进入阻塞状态，此时需要获取到锁之后才会继续执行。
• 等待（Waiting）：线程在执行过程中可能会进入等待状态，例如调用了wait()方法，等待其他线程的通知、唤醒，才能继续执行。
• 计时等待（Timed Waiting）：与等待状态类似，但在此状态下的线程有一个预定的等待时间，超时后自动返回到就绪状态。
• 终止（Terminated）：线程完成任务或者因为异常而结束执行，进入终止状态。

2.2理解

2.2.1源码中定义的线程状态

2.2.2新建（NEW ）

Thread thread = new Thread();// 只要线程new出来
System.out.println("线程的名字"+thread.getName()+"线程的状态:"+thread.getState()); 示例代码

2.2.3可运行（RUNNABLE ）

Thread thread = new Thread(()->{
  System.out.println("1111");
  System.out.println("线程的状态"+Thread.currentThread().getState());
});
thread.start();
System.out.println("线程的状态"+thread.getState()); 示例代码

2.2.4锁阻塞（BLOCKED ）

Object o = new Object();
Thread threadA = new Thread(() -> {
    synchronized (o) {
        System.out.println("11111");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}, "A");
threadA.start();
try {
    Thread.sleep(500);
} catch (InterruptedException e) {
    e.printStackTrace();
}
Thread threadB = new Thread(() -> {
    synchronized (o) {
    }
}, "B");
threadB.start();
try {
    Thread.sleep(100);
} catch (InterruptedException e) {
    e.printStackTrace();
}
System.out.println("线程" + threadB.getName() + "状态" + threadB.getState()); 示例代码

2.2.5等待阻塞（WAITING ）

Object o = new Object();
Thread thread = new Thread(() -> {
    synchronized (o) {
        try {
            for (int i = 1; i < 10; i++) {
                System.out.println("i---" + i);
                if (i == 5) {
                    o.wait();
                    // 使用对象的wait方法时 必要要有一个对象和synchronized
                    // 如若不结合synchronized 那么就会出现一个监视器对象状态异常 IllegalMonitorStateException。
                    // 任何一个对象中都有一个ObjectMonitor对象。监视器锁。管程技术。
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
thread.start();
Thread.sleep(2000);
System.out.println(thread.getState());
Thread thread1 = new Thread(() -> {
    // o.notify();//使用notify或者notifyAll()都要结合synchronized使用，不然就会出现监视器异常IllegalMonitorStateException
    synchronized (o) {
        System.out.println("do some thing");
        o.notify();
    }
});
thread1.start();
System.out.println("end"); 示例代码

2.2.6限时等待（TIMED_WAITING ）

Object o = new Object();
Thread thread = new Thread(() -> {
    synchronized (o) {
        try {
            // 线程调用wait(5000)方法
            o.wait(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
thread.start();
// 线程调用sleep(5000)方法
Thread.sleep(5000);
// 线程调用join(5000)方法
thread.join(5000);
System.out.println(thread.getState()); 示例代码

2.2.7终止（TERMINATED ）

Thread thread = new Thread(() -> {
    int i = 0;
    System.out.println("1111");
    try {
        i = 10 / 0;
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println(i);
});
thread.start();
Thread.sleep(100);
System.out.println(thread.getState()); 示例代码

3什么是线程池，线程池有哪些？

• ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
• ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(4);
• ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(4);
• ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();

3.1newCachedThreadPool()

• 工作线程的创建数量几乎没有限制(其实也有限制的，数目为Interger. MAX_VALUE)，这样可灵活的往线程池中添加线程。
• 如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。
• 在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。

3.2newFixedThreadPool()

3.3newScheduleThreadPool()

4ThreadPoolExecutor对象有哪些参数？都有什么作用？怎么设定核心线程数和最大线程数？拒绝策略有哪些？ [重点]

4.17个参数的作用

4.1.1corePoolSize

• allowCoreThreadTimeOut为false：核心线程会一直存活，哪怕是一直空闲着
• allowCoreThreadTimeOut为true：核心线程空闲时间超过keepAliveTime时会被回收

4.1.2maximumPoolSize

4.1.3keepAliveTime

• 非核心空闲超过这个时间将被回收
• 核心线程超过这个时间是否回收受allowCoreThreadTimeOut影响

4.1.4unit

4.1.5workQueue

4.1.6threadFactory

4.1.7RejectedExecutionHandler

4.2线程池大小设置

4.2.1最佳实践

4.2.2具体数值设置

4.2.2.1CPU密集型

4.2.2.2I/O密集型

补充：其实我们平时写的常规业务都是I/O密集型。前端发送过来一个请求，Java代码需要计算的不多，大部分时间是在等待Redis、MySQL、ElasticSearch通过网络传输返回结果

5常见线程安全的并发容器有哪些？

• Set集合：CopyOnWriteArraySet（写时复制技术）
• List集合：CopyOnWriteArrayList（写时复制技术）
• Map集合：ConcurrentHashMap
  • JDK1.7：采用了锁分段（Segment）技术来提高并发性能，每个段（Segment）相当于一个独立的哈希表，并且每个段都有自己的锁，这样可以减少锁的竞争
  • JDK1.8：设计进行了优化，不再使用分段锁（Segment），而是采用了CAS（Compare and Swap）操作和synchronized关键字相结合的方式来实现线程安全，它使用了更细粒度的锁机制，即在链表或红黑树的节点上使用synchronized锁，同时对于一些非竞争性的操作则采用CAS来保证原子性，从而进一步提高了并发性能

6Atomic原子类了解多少？原理是什么？

6.1概述

6.2分别说明

6.2.1AtomicInteger、AtomicLong、AtomicReference

6.2.2AtomicBoolean

6.2.3AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray

6.2.4AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater

7synchronized底层实现是什么？Lock底层是什么？有什么区别？

7.1synchronized原理

7.1.1同步方法

7.1.2同步代码块

7.2Lock原理

7.2.1Lock获取锁的过程

7.2.2Lock释放锁的过程

7.3Lock与synchronized的区别

7.3.1阻塞机制

• 当一个线程使用synchronized获取锁时，若锁被其他线程占用着，那么当前只能被阻塞，直到成功获取锁。
• Lock则提供超时锁和可中断等更加灵活的方式，在未能获取锁的条件下提供一种退出的机制。

7.3.2锁占有模式

• synchronized对线程的同步仅提供独占模式，
• Lock既可以提供独占模式，也可以提供共享模式

7.3.3条件队列

7.3.4总结