面试题总结（四）【线程】【华清远见西安中心】

• 什么是线程？

  线程（Thread）是操作系统能够进行运算调度的最小单位。它被包含在进程（Process）中，是进程中的实际执行单位。一个进程可以有多个线程，线程之间共享进程的资源，包括内存、文件和打开的文件描述符等。

  相比于进程，线程更轻量级，创建、销毁和切换线程的开销较小。线程之间可以并发执行，可以利用多核处理器的并行计算能力，提高程序的执行效率和响应性。

  线程的特点如下：

  1. 共享资源：线程之间共享同一个进程的资源，包括内存、文件和文件描述符等。这些资源在进程中是共享的，线程可以直接访问和修改这些资源。

  2. 独立的执行流：每个线程都有自己的执行流，可以独立地执行指令序列。线程之间可以并发执行，彼此之间相互独立，不会相互阻塞。

  3. 调度和切换：线程的调度和切换由操作系统负责。操作系统根据调度算法决定哪个线程获得CPU时间片，从而实现线程间的切换。

  4. 共享地址空间：线程之间共享同一个进程的地址空间。这意味着线程可以直接访问进程的全局变量和静态变量，可以通过共享内存进行通信。

  5. 比进程更轻量级：相比于进程，线程的创建、销毁和切换开销较小。这使得线程更适合于并发执行的任务，能够提高程序的性能和响应性。

  线程的使用可以简化并发编程的复杂性，提高程序的效率和资源利用率。但同时也需要注意线程之间共享资源的同步和互斥，以避免竞态条件和数据访问冲突等问题。在编写多线程程序时，需要合理地设计线程的数量和调度，以充分发挥多线程的优势。

• 线程如何创建，并执行特定的任务？

  线程的创建和执行可以通过编程语言提供的线程库或操作系统提供的API来实现。下面以常见的编程语言Java和C++为例，介绍线程的创建和执行：

  1. Java中创建和执行线程：
     1. 创建线程：Java中创建线程可以通过继承Thread类或实现Runnable接口来实现。继承Thread类需要重写run()方法，实现Runnable接口需要实现run()方法。例如：
       
       // 继承Thread类创建线程
       class MyThread extends Thread {
           public void run() {
               // 线程要执行的任务
           }
       }

       // 实现Runnable接口创建线程
       class MyRunnable implements Runnable {
           public void run() {
               // 线程要执行的任务
           }
       }
       
     2. 启动线程：创建线程之后，可以通过调用start()方法来启动线程，并开始执行线程的任务。
       
       // 创建并启动线程
       Thread myThread = new MyThread();
       myThread.start();

       // 创建并启动线程
       Thread myThread = new Thread(new MyRunnable());
       myThread.start();
       

  2. C++中创建和执行线程：
     1. 创建线程：C++中创建线程可以使用std::thread类来实现，需要传入一个可调用对象（如函数或函数对象）作为线程的入口。例如：
       
       #include <iostream>
       #include <thread>

       void myFunction() {
           // 线程要执行的任务
       }

       int main() {
           // 创建并启动线程
           std::thread myThread(myFunction);
           myThread.join(); // 等待线程执行完成
           return 0;
       }
       
     2. 启动线程：创建线程之后，可以通过调用线程对象的join()方法来等待线程执行完成。也可以使用detach()方法将线程分离，使其在后台执行。
       
       // 创建并启动线程
       std::thread myThread(myFunction);
       myThread.join(); // 等待线程执行完成

       // 创建并启动线程
       std::thread myThread(myFunction);
       myThread.detach(); // 分离线程，后台执行
       

  以上是简单示例，实际使用时可能需要考虑线程同步、互斥、错误处理等问题，以保证线程的正确执行和任务的完成。具体的线程创建和执行方式可以根据具体的编程语言和需求来选择和使用。

• 线程如何退出？

  在C++中，线程的退出可以通过以下几种方式实现：

  1. 线程执行完任务：线程执行完任务后，会自动退出。可以通过在线程函数中返回或调用std::exit()来实现线程的退出。

     
     #include <iostream>
     #include <thread>

     void myFunction() {
         // 线程要执行的任务
     }

     int main() {
         std::thread myThread(myFunction);
         myThread.join(); // 等待线程执行完成
         return 0;
     }
     

  2. 线程显式退出：线程可以通过调用std::this_thread::exit()来显式退出。

     
     #include <iostream>
     #include <thread>

     void myFunction() {
         // 线程要执行的任务
         std::this_thread::exit();
     }

     int main() {
         std::thread myThread(myFunction);
         myThread.join(); // 等待线程执行完成
         return 0;
     }
     

  3. 线程被其他线程终止：一个线程可以被其他线程终止，例如通过设置标志位或调用特定的方法来终止线程的执行。

     
     #include <iostream>
     #include <thread>
     #include <atomic>

     std::atomic<bool> isRunning(true);

     void myFunction() {
         while (isRunning) {
             // 线程要执行的任务
         }
     }

     int main() {
         std::thread myThread(myFunction);
         // ...
         isRunning = false; // 终止线程的执行
         myThread.join(); // 等待线程执行完成
         return 0;
     }
     

  需要注意的是，线程的退出可能需要进行一些清理操作，例如释放资源、关闭文件等。为了保证线程的正确退出，需要在代码中合理地处理退出逻辑，并确保线程的资源得到正确释放。同时，需要注意线程间的同步和互斥问题，以保证线程退出的正确性和安全性。

• 哪些数据是线程私有的？

  在线程中，有以下几种数据是线程私有的：

  1. 线程栈：每个线程都有属于自己的栈空间，用于保存局部变量和函数调用信息。线程栈是线程私有的，不会被其他线程所共享。

  2. 线程局部存储（Thread Local Storage，TLS）：TLS是一块线程私有的内存空间，可以用于存储线程特定的数据。通过TLS，每个线程可以拥有自己的变量副本，而不会被其他线程所访问。在C++中，可以使用thread_local关键字来声明线程局部变量。

     
     thread_local int myThreadLocalVariable; // 声明一个线程局部变量
     

  3. 寄存器：寄存器是CPU中的一组用于保存临时数据的存储器。寄存器是线程私有的，每个线程都会拥有自己的寄存器。在多线程环境下，线程可以使用寄存器来保存一些临时计算结果，提高程序的执行效率。

  需要注意的是，除了上述提到的线程私有的数据外，线程也可以访问和共享其他线程的数据，如全局变量、静态变量、堆内存等。在多线程编程中，需要特别注意线程间数据的同步和互斥，以避免数据竞争和其他并发问题的发生。

• 哪些数据是多线程共享的？

  在多线程编程中，有以下几种数据是多线程共享的：

  1. 全局变量：全局变量是在程序的整个执行过程中都可见的变量，可以被所有线程访问和修改。

  2. 静态变量：静态变量是在程序执行期间都存在的变量，可以被所有线程访问和修改。

  3. 堆内存：堆内存是在程序运行时动态分配的内存，可以被所有线程访问和释放。多个线程可以通过指针共享和操作堆内存。

  4. 共享内存：共享内存是一种特殊的内存区域，多个线程可以同时访问和修改其中的数据。在多线程编程中，可以使用共享内存来实现线程间的通信和数据共享。

  5. 互斥量、条件变量等同步机制：多个线程可以共享同步机制，以实现线程间的同步和互斥。例如，多个线程可以共享一个互斥量来保护临界区，确保同一时间只有一个线程可以进入临界区。

  需要注意的是，对于共享的数据，需要进行适当的同步和互斥操作，以避免数据竞争和其他并发问题的发生。常用的同步机制包括互斥量、条件变量、读写锁等，可以根据具体需求选择合适的同步机制来保证多线程间的数据安全性。

• thread _local关键字的作用是什么？

  thread_local关键字用于声明线程局部变量（Thread Local Variable，TLV），它的作用是将变量声明为每个线程独立拥有的副本。线程局部变量是指每个线程拥有自己独立的变量副本，每个线程对该变量的操作不会影响其他线程的副本。

  使用thread_local关键字声明的变量，每个线程都会有自己的副本，并且在不同的线程中访问这个变量时，每个线程都会访问到自己的副本。这样可以实现在多线程环境下，每个线程都有自己独立的状态和数据。

  thread_local关键字通常用于以下情况：

  1. 线程局部数据：通过声明线程局部变量，每个线程可以拥有自己的变量副本，而不会被其他线程所访问。

  2. 线程安全：线程局部变量是线程私有的，不会被其他线程所修改，因此可以避免线程间的数据竞争和并发问题。

  3. 线程特定数据：线程局部变量可以用于保存线程特定的数据，比如线程ID、线程名称等。

  使用thread_local关键字声明线程局部变量的示例：

  
  thread_local int myThreadLocalVariable; // 声明一个线程局部变量
   

  需要注意的是，thread_local关键字只能用于静态变量、全局变量和静态成员变量，不能用于局部变量。同时，使用线程局部变量要小心内存泄漏的问题，需要确保线程退出时能够正确清理线程局部变量的资源。