面试题汇总——多线程-爱代码爱编程
创建线程有哪几种方式？
创建线程有三种方式，分别是继承Thread类、实现Runnable接口、实现Callable接口。
通过继承Thread类来创建并启动线程的步骤如下：
-
定义Thread类的子类，并重写该类的run()方法，该run()方法将作为线程执行体。
-
创建Thread子类的实例，即创建了线程对象。
-
调用线程对象的start()方法来启动该线程。
public class MyThread extends Thread {
@Override
public void run() {
// 线程执行的代码
}
}
MyThread t = new MyThread();
t.start(); // 启动线程
通过实现Runnable接口来创建并启动线程的步骤如下：
-
定义Runnable接口的实现类，并实现该接口的run()方法，该run()方法将作为线程执行体。
-
创建Runnable实现类的实例，并将其作为Thread的target来创建Thread对象，Thread对象为线程对象。
-
调用线程对象的start()方法来启动该线程。
public class MyRunnable implements Runnable {
@Override
public void run() {
// 线程执行的代码
}
}
MyRunnable r = new MyRunnable();
Thread t = new Thread(r);
t.start(); // 启动线程
通过实现Callable接口来创建并启动线程的步骤如下：
-
创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，且该call()方法有返回值。然后再创建Callable实现类的实例。
-
使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
-
使用FutureTask对象作为Thread对象的target创建并启动新线程。
-
调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
return sum;
}
}
public class Main {
public static void main(String[] args) {
MyCallable myCallable = new MyCallable();
FutureTask<Integer> task = new FutureTask<>(myCallable);
new Thread(task).start();
try {
Integer result = task.get();
System.out.println("计算结果为：" + result);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
如何实现线程同步？
Java中的线程同步主要有以上四种方式：synchronized 关键字、ReentrantLock 类、CountDownLatch 类、Semaphore 类
1.synchronized 关键字
/ˈsɪŋkrənaɪzd/ 翻译：同步的
synchronized 是Java中最基本的线程同步方式，可以使用 synchronized 关键字来修饰方法或者代码块。当一个线程进入一个 synchronized 代码块或方法时，它会尝试获取锁，如果该锁已经被其他线程持有，则该线程会被阻塞等待锁的释放，直到获取到锁才能执行代码。
2.ReentrantLock 类
翻译：重入锁
ReentrantLock 是Java中的一个锁类，它提供了更丰富的锁控制机制，可以替代 synchronized 关键字。ReentrantLock 可以重复进入、可中断、可设置超时时间、可设置公平性等，使用 ReentrantLock 需要手动获取锁和释放锁。
3.CountDownLatch 类
翻译：倒数锁存器
CountDownLatch 是Java中的一个同步工具类，可以用来控制线程等待。CountDownLatch 维护一个计数器，当计数器的值变为0时，所有等待该计数器的线程将被唤醒。可以通过 CountDownLatch 来实现线程之间的协调和同步。
4.Semaphore 类
翻译：信号
Semaphore 是Java中的一个同步工具类，可以用来控制同时访问某个资源的线程个数。Semaphore 维护一个许可证，可以设置允许同时访问该资源的线程个数，当许可证已经全部分配完毕时，后续的线程将会被阻塞等待，直到有其他线程释放许可证。
介绍一下线程的生命周期
在线程的生命周期中，它要经过新建（New）、就绪（Ready）、运行（Running）、阻塞（Blocked）和死亡（Dead）5种状态。
1.当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时它和其他的Java对象一样，仅仅由Java虚拟机为其分配内存，并初始化其成员变量的值
2.当线程对象调用了start()方法之后，该线程处于就绪状态，Java虚拟机会为其创建方法调用栈和程序计数器，处于这个状态中的线程并没有开始运行，只是表示该线程可以运行了
3.如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态
4.当一个线程开始运行后，它不可能一直处于运行状态，线程在运行过程中需要被中断，目的是使其他线程获得执行的机会;如果线程被中断的话，则进入阻塞状态。
5.线程会以如下三种方式结束，结束后就处于死亡状态：
-
run()或call()方法执行完成，线程正常结束。
-
线程抛出一个未捕获的Exception或Error。
-
直接调用该线程的stop()方法来结束该线程
run()和start()有什么区别？
run()方法被称为线程执行体，它的方法体代表了线程需要完成的任务，而start()方法用来启动线程。
调用start()方法启动线程时，系统会把该run()方法当成线程执行体来处理。但如果直接调用线程对象的run()方法，则run()方法立即就会被执行，而且在run()方法返回之前其他线程无法并发执行。也就是说，如果直接调用线程对象的run()方法，系统把线程对象当成一个普通对象，而run()方法也是一个普通方法，而不是线程执行体。
说一说Java多线程之间的通信方式
1.wait()、notify()、notifyAll()
wait()方法可以让当前线程释放对象锁并进入阻塞状态。notify()方法用于唤醒一个正在等待相应对象锁的线程，使其进入就绪队列，以便在当前线程释放锁后竞争锁，进而得到CPU的执行。notifyAll()用于唤醒所有正在等待相应对象锁的线程，使它们进入就绪队列，以便在当前线程释放锁后竞争锁，进而得到CPU的执行。
2.await()、signal()、signalAll()
await()/signal()/signalAll() 与 wait()/notify()/notifyAll()有着对应关系,功能相似
3.BlockingQueue
程序的两个线程通过交替向BlockingQueue中放入元素、取出元素，即可很好地控制线程的通信。线程之间需要通信，最经典的场景就是生产者与消费者模型，而BlockingQueue就是针对该模型提供的解决方案。
如何实现子线程先执行，主线程再执行？
要实现子线程先执行，主线程再执行，可以使用Java中的join()方法。join()方法可以等待线程执行完毕，然后再继续执行当前线程。如果在主线程中调用子线程的join()方法，主线程就会等待子线程执行完毕，然后再执行自己的代码。
下面是一个示例代码，演示了如何使用join()方法实现子线程先执行，主线程再执行的效果：
public class ThreadExample {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
System.out.println("子线程开始执行");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程执行完毕");
});
t1.start();
t1.join();
System.out.println("主线程开始执行");
System.out.println("主线程执行完毕");
}
}
说一下乐观锁和悲观锁
悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。Java中悲观锁是通过synchronized关键字或Lock接口来实现的。
乐观锁：顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据。
说一说synchronized与Lock的区别
-
synchronized是Java关键字，在JVM层面实现加锁和解锁；Lock是一个接口，在代码层面实现加锁和解锁。
-
synchronized可以用在代码块上、方法上；Lock只能写在代码里。
-
synchronized在代码执行完或出现异常时自动释放锁；Lock不会自动释放锁，需要在finally中显示释放锁。
-
synchronized会导致线程拿不到锁一直等待；Lock可以设置获取锁失败的超时时间。
-
synchronized无法得知是否获取锁成功；Lock则可以通过tryLock得知加锁是否成功。
-
synchronized锁可重入、不可中断、非公平；Lock锁可重入、可中断、可公平/不公平，并可以细分读写锁以提高效率。
介绍一下线程池
系统启动一个新线程的成本是比较高的，因为它涉及与操作系统交互。在这种情形下，使用线程池可以很好地提高性能，尤其是当程序中需要创建大量生存期很短暂的线程时，更应该考虑使用线程池。
与数据库连接池类似的是，线程池在系统启动时即创建大量空闲的线程，程序将一个Runnable对象或Callable对象传给线程池，线程池就会启动一个空闲的线程来执行它们的run()或call()方法，当run()或call()方法执行结束后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个Runnable对象的run()或call()方法。
介绍一下线程池的工作流程
线程池都有哪些状态？
线程池一共有五种状态, 分别是：
-
RUNNING ：能接受新提交的任务，并且也能处理阻塞队列中的任务。
-
SHUTDOWN：关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保存的任务。在线程池处于 RUNNING 状态时，调用 shutdown()方法会使线程池进入到该状态。
-
STOP：不能接受新任务，也不处理队列中的任务，会中断正在处理任务的线程。在线程池处于 RUNNING 或 SHUTDOWN 状态时，调用 shutdownNow() 方法会使线程池进入到该状态。
-
TIDYING：如果所有的任务都已终止了，workerCount (有效线程数) 为0，线程池进入该状态后会调用 terminated() 方法进入TERMINATED 状态。
-
TERMINATED：在terminated() 方法执行完后进入该状态，默认terminated()方法中什么也没有做。进入TERMINATED的条件如下：
-
线程池不是RUNNING状态；
-
线程池状态不是TIDYING状态或TERMINATED状态；
-
如果线程池状态是SHUTDOWN并且workerQueue为空；
-
workerCount为0；
-
设置TIDYING状态成功。
-
