面试题1：什么是线程以及它在并发编程中的作用是什么
线程（ Thread ）是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
线程是独立调度和分派的基本单位，同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的不同线程间的数据共享会带来同步问题，因此需要引入线程同步和互斥锁等机制来避免数据竞争和条件竞争。
多线程编程的作用主要体现在以下几个方面：
（1）提高性能
多线程编程能够充分利用多核处理器或多处理器系统的优势，实现并行处理，从而提高程序的执行性能。通过将任务分解为多个线程并同时执行，可以显著提高程序的运行速度。
（2）增强响应性
对于交互式应用程序，如用户界面或网络服务，多线程编程可以显著提高系统的响应性。通过将耗时的操作放在单独的线程中执行，可以避免阻塞主线程，保持用户界面的流畅和响应。这对于提供良好的用户体验至关重要。
（3）简化设计
多线程编程可以简化某些复杂问题的设计。通过将大问题分解为多个小问题，并使用多个线程分别处理这些小问题，可以使程序结构更加清晰，便于理解和维护。
（4）资源利用率
多线程编程可以提高系统的资源利用率。多个线程可以共享计算机的资源，如CPU、内存、硬盘等，从而更有效地利用系统资源。
面试题2：线程与进程的区别是什么
线程与进程在操作系统中各自扮演不同的角色，并具有显著的区别。以下是线程与进程的主要区别：
（1）资源分配与调度
进程：进程是资源分配的基本单位，它拥有独立的地址空间、数据栈和其他系统资源。当创建一个新进程时，操作系统会为其分配必要的资源，并确保它与其他进程隔离。进程间的切换涉及较多资源的管理，因此效率相对较低。
线程：线程是CPU调度的基本单位，它共享进程的资源（如内存空间、打开的文件等），但拥有独立的执行栈和程序计数器。线程切换时只需保存和恢复少量寄存器内容，因此切换开销小，效率高。
（2）执行方式
进程：进程是独立的执行实体，拥有自己的地址空间和系统资源。一个进程崩溃不会影响其他进程的执行。
线程：线程是进程内的一条执行路径，多个线程共享进程的资源。同一个进程内的线程间通信较为容易，因为它们可以直接访问共享内存空间。然而，一个线程的错误可能导致整个进程的崩溃。
（3）并发性
进程：由于进程拥有独立的地址空间，多个进程可以同时执行，实现真正的并发。
线程：线程之间共享进程的资源，因此多个线程可以同时执行，但它们实际上是在同一个地址空间内并发执行。
（4）独立性
进程：进程之间相互独立，一个进程的状态不会影响其他进程。
线程：线程是进程的一部分，它们共享进程的资源，因此线程之间的独立性相对较低。
（5）系统开销
进程：由于进程拥有独立的资源，创建和销毁进程涉及较多资源的管理，因此开销较大。
线程：线程创建和销毁的开销相对较小，因为它们共享进程的资源。
总的来说，进程和线程在资源分配、调度、执行方式、并发性、独立性和系统开销等方面存在显著的区别。在选择使用进程还是线程时，需要根据具体的应用场景和需求进行权衡。
面试题3：C++11 如何支持多线程编程
C++11 标准引入了对多线程的原生支持，为开发者提供了更加便捷和高效的方式来编写多线程程序。在 C++11 中，引入了以下几个关键组件来支持多线程编程：
（1）<thread> 头文件
这个头文件包含了std::thread类，用于创建和管理线程。开发者可以使用 std::thread 对象来表示一个线程，并通过调用其成员函数来执行线程任务。
（2）<atomic> 头文件
这个头文件提供了原子操作的支持，包括 std::atomic 类和一套 C 风格的原子类型与原子操作函数。原子操作是一种在多线程环境中安全执行的操作，即在执行过程中不会被其他线程打断，从而保证了数据的一致性和正确性。
（3）<mutex> 头文件
这个头文件提供了互斥量（mutex）的支持，用于同步线程间的访问共享资源。互斥量是一种常用的同步机制，可以确保同一时间只有一个线程可以访问共享资源，从而避免数据竞争和不一致性问题。
（4）<condition_variable> 头文件
这个头文件提供了条件变量的支持，用于线程间的条件同步。条件变量允许一个或多个线程等待某个条件成立，当条件满足时，等待的线程可以被唤醒并继续执行。
（5）<future> 头文件
这个头文件提供了异步任务的支持，包括 std::future 和 std::promise 等类。这些类允许开发者启动一个异步任务，并在需要时获取其结果。这对于实现异步编程和并发计算非常有用。
通过使用这些头文件和类， C++11 使得多线程编程更加简单和直观。开发者可以更加容易地创建和管理线程，实现线程间的同步和通信，从而编写出高效且可靠的多线程程序。需要注意的是，虽然 C++11 提供了多线程支持，但编写多线程程序仍然需要谨慎处理线程同步和数据竞争等问题，以确保程序的正确性和性能。
面试题4：std::thread 类的构造函数参数有哪些，如何使用
std::thread 类的构造函数用于创建并启动一个新的线程。它接受一个可调用对象（函数、函数指针、成员函数指针、Lambda 表达式等）作为参数，这个可调用对象定义了新线程要执行的任务。此外，对于成员函数和带有参数的函数，还需要提供额外的参数。
如下为样例代码：
#include <iostream>
#include <thread>
#include <string>
#include <functional>
void threadFunc(std::string str)
{
// 线程执行的代码
printf("%s\n", str.c_str());
}
class FuncClass
{
public:
void operator()(std::string str)
{
// 线程执行的代码
printf("%s\n", str.c_str());
}
};
int main()
{
// 通过函数指针创建线程
std::thread t1(threadFunc,"function pointer");
t1.join();
// 通过 Lambda 表达式创建线程
std::thread t2([]{
// 线程执行的代码
printf("Lambda expression\n");
});
t2.join();
// 通过 bind 表达式创建线程
std::function<void(std::string)> func = std::bind(threadFunc, std::placeholders::_1);
std::thread t3(func, "bind expression");
t3.join();
// 通过函数对象创建线程
FuncClass funcObj;
std::thread t4(funcObj, "function object");
t4.join();
return 0;
}
上面代码的输出为：
function pointer
Lambda expression
bind expression
function object
在上面代码中，分别使用函数指针、 Lambda 表达式、 bind 表达式、函数对象这四种方式通过 std::thread 创建了线程，随后调用 t.join() 阻塞 main 线程，直到新线程 t 执行完毕。这是一种同步机制，确保主线程等待新线程完成后再继续执行。如果不希望主线程等待，可以使用 t.detach() 来将新线程设置为分离状态，这样新线程将在后台运行，并且当它的任务完成后会自动释放资源。
面试题5：C++11 如何管理线程的生命周期
在 C++11 中，线程的创建与管理主要通过 std::thread 类来实现。使用 C++11 创建与管理线程的主要流程如下：
（1）创建线程
可以使用 std::thread 的构造函数创建一个新线程，并传递给它一个可调用对象（例如函数、函数指针、成员函数指针、 Lambda 表达式等）。这个可调用对象将在新线程中执行。
（2）管理线程
线程被创建后，可以使用std::thread类的成员函数来管理：
join() : 阻塞当前线程，直到被调用的线程完成执行。
detach() : 将线程标记为分离状态，允许它在后台运行，并且不需要显式调用 join() 。分离状态的线程在结束时会自动释放其资源。
get_id() : 获取线程的唯一标识符。
hardware_concurrency() : 返回可用于执行线程的硬件并发性级别，通常对应于CPU的核数。
（3）线程状态
线程可以有以下几种状态：
joinable : 线程可以被 join 。这是线程刚被创建时的默认状态。
detached : 线程是分离的，即它将在后台运行，并且在结束时自动释放资源。
joined : 线程已经被 join ，并且不再处于活动状态。
面试题6：std::thread 的 join 和 detach 方法有什么区别，如何终止一个线程
std::thread 的 join 和 detach 方法用于管理线程的生命周期，但它们的行为和用途有显著的区别。
join 方法
（1）阻塞调用：当调用一个线程的 join 方法时，调用线程（通常是主线程）将阻塞，直到被 join 的线程执行完毕。
（2）线程所有权：调用 join 会使调用线程获得被 join 线程的所有权。这意味着在调用线程完成 join 之后，被 join 的线程对象可以被安全地销毁。
（3）线程状态：一旦线程被 join ，它就不再是可加入（ joinable ）状态。线程对象在 join 之后变成不可加入状态，不能再被 join 。
（4）资源释放：当线程执行完毕后， join 确保线程相关的资源被正确释放。
detach 方法
（1）非阻塞调用：调用线程的 detach 方法不会阻塞调用线程。被 detach 的线程将在后台独立运行，直到它完成其任务。
（2）放弃线程所有权：通过调用 detach，调用线程放弃了被 detach 的线程的所有权。这意味着一旦线程被 detach ，调用线程就不能再控制该线程的执行或等待其结束。
（3）线程状态：一旦线程被 detach，它就变成分离（ detached ）状态。分离状态的线程在结束时会自动释放其资源。
（4）资源释放：当线程执行完毕后，由于线程已经被 detach ，它会自动释放其资源，而不需要调用线程进行任何额外的操作。
选择 join 还是 detach
（1）需要等待线程完成的情况：如果你需要等待线程完成其任务，或者你需要获取线程的返回值，那么应该使用 join 。
（2）后台任务或不需要等待的情况：如果你想要线程在后台运行，并且不需要等待它完成，或者不关心它的返回值，那么应该使用 detach 。
注意：一旦线程被 detach ，就无法再控制它的执行或获取它的状态。因此，在使用 detach 时需要谨慎。
在 C++11 中，线程可以通过两种方式终止：
（1）隐式终止：当线程函数执行完成后，线程会自动终止。在上面的例子中， threadFunc 函数执行完毕后，对应的线程就会自然终止。
（2）显式终止：通过调用线程对象的 detach 或 join 成员函数来显式地管理线程的终止：
join ：调用线程对象的 join 成员函数会阻塞当前线程（通常是主线程），直到被调用的线程执行完毕。这是一种同步机制，确保主线程等待新线程完成后再继续执行。
detach ：调用线程对象的 detach 成员函数会将线程设置为分离状态。这意味着一旦线程函数执行完成，线程对象会自动释放其资源，而无需显式调用 join 。设置为分离状态的线程在其完成时会自动终止。如下为样例代码：
#include <iostream>
#include <thread>
#include <string>
void threadFunc()
{
// 线程执行的代码
std::this_thread::sleep_for(std::chrono::milliseconds(10));
printf("hello thread\n");
}
int main()
{
std::thread t(threadFunc);
// 分离线程（线程完成时自动释放资源）
t.detach();
// 主线程继续执行，不再等待myThread线程
printf("continue main thread\n");
// 避免子线程没有结束，整个程序即退出
std::this_thread::sleep_for(std::chrono::milliseconds(100));
return 0;
}
上面代码的输出为：
continue main thread
hello thread
在上面代码中，由于调用了detach，主线程不会等待 t 线程完成，而是继续执行。当 threadFunc 函数执行完毕后， t 线程会自动终止，并且其资源会被自动释放。
面试题7：什么是线程同步，为什么需要它
线程同步是一种机制，用于协调多个线程的执行，以确保它们能够正确、有序地访问共享资源，从而避免数据竞争和不一致的问题。当多个线程同时访问同一共享资源时，可能会出现数据竞争，这可能导致数据损坏、程序崩溃或其他不可预期的结果。线程同步机制可以确保线程之间的协作和通信，使它们能够按预期的方式共享和访问资源。
线程同步的主要方式包括互斥锁（ Mutex ）、条件变量（ Condition Variable ）、信号量（ Semaphore ）等。这些机制可以控制线程的并发访问，并防止多个线程同时读写共享资源，以此保证数据的安全性、一致性和有效性。
需要线程同步的原因主要有以下几点：
（1）保护共享资源：多个线程可能会同时访问和修改同一共享资源，如果没有同步机制，可能会导致数据不一致或损坏。线程同步可以确保在任何时候只有一个线程能够访问和修改共享资源。
（2）解决数据一致性问题：当一个线程可以修改的变量被其他线程读取或修改时，可能会出现数据一致性问题。线程同步可以确保线程在访问变量的存储内容时不会访问到无效的值。
（3）提高程序执行效率：对于频繁访问共享资源的应用，如果没有线程同步机制，可能会出现性能问题，如资源等待和线程竞争。通过线程同步，可以有效地避免这些问题，提高程序的执行效率和并发性能。
总之，线程同步是确保多线程程序正确、高效运行的关键机制。通过合理地使用线程同步机制，可以避免数据竞争、不一致等问题，提高程序的稳定性和性能。