C C++最全Thread 类及常用的方法_thread类，字节C C++高工面试

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

| 优先级 | getPriority() |
| 是否为后台线程 | isDaemon() |
| 是否存活 | isAlive() |
| 是否被中断 | isInterrupted() |

解释：

1. 线程的唯一标识就是线程 Id
2. 名称在上面的案例中有所体现，为调试提供了便利
3. 状态表示线程当前所处的情况，上面的案例中，线程因为调用了 sleep 方法就进入了阻塞状态
4. 优先级表示该线程被调度到的难易度，高的更容易被调度到
5. 判断是否为后台线程。如果是后台线程，那么该后台线程不会影响 java 进程的结束；如果是非后台线程，JVM 就会等到所有的非后台线程执行完毕，才会结束运行，因此会影响到总进程的结束
6. 是否存活是来判断线程是否还存在的方法。当创建出 Thread 实例对象时，线程未必就创建了，需要调用 start 方法，才是真正的创建了线程。当线程中的 run 方法执行完毕，线程结束被销毁了，创建出的实例对象还没被销毁回收。所以说，创建出的实例对象和线程的生命周期是不完全相同的

在线程的状态中，除了NEW 和 TERMINATED 以外的状态都是活着的

代码：

public class func8 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            for (int i = 0;i < 5;i ++) {
                System.out.println("新线程~");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"newThread");
        System.out.println("新线程状态：" +t.getState());
        //创建了对象，没创建线程
        t.start();
        System.out.println("新线程状态：" +t.getState());
        //创建了线程
        System.out.println("新线程Id："+t.getId());
        System.out.println("新线程名称："+t.getName());
        System.out.println("新线程是否为后台线程：" + t.isDaemon());
        System.out.println("新线程是否被中断：" + t.isInterrupted());
        System.out.println("新线程优先级：" + t.getPriority());
        System.out.println("主线程名称："+Thread.currentThread().getName());
        while (t.isAlive()) {} //当t线程还存在时，主线程就搁这儿循环着，直到线程结束
        System.out.println("新线程状态：" +t.getState());//线程结束
    }
}

结果：

三、创建线程

创建 Thread 类的对象不意味着线程被创建出，start() 方法才是真正的在操作系统内部创建一个新的线程，通过重写 run 方法来描述需要执行的任务，从而真正实现了多线程运行。

四、中断线程

方法一：手动设置标志位，作为中断线程的条件

public class func9 {
    private static Boolean flag = false;//手动设置的标志位 flag
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!flag) {
                //flag 为真时停止循环
                System.out.println("myThread");
                try {
                    Thread.sleep(1000);//打印一次，阻塞一秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();//创建了线程 t
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag = true;
        //等3秒后，在主线程中将 flag 的值改成 true，从而使线程t循环条件不成立
    }
}

方法二：使用 Thread 实例中的标志位

public class func10 {
    public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                //通过 isInerrupted()判断标志位是否为true，为true说明线程要退出
                while (!this.isInterrupted()) {
                   System.out.println("my Thread");
                   try {
                       Thread.sleep(1000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                       //System.out.println("完善工作");
                       //break;
                   }
               }
            }
        };
        t.start();//创建新的线程
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.interrupt();
        //t线程运行3秒后，通过 interrupt() 方法将标志位设置为 true
    }
}

结果：

可以看见当3秒后标志位设置为 true，希望 t 线程中断退出时，结果只是报了个 InterruptedException 异常。

事实上，当调用 interrupt 方法时，如果线程为就绪状态，就会直接修改线程中的标志位；如果是阻塞状态，就会引起 InterruptedException 异常（因为调用了 sleep 方法，正阻塞着呢，结果被强行呼醒了）

但收到中断线程这个信号后，出现了异常，只是单纯的打印了一下异常，并没有对出现的异常进行反应，于是 t 线程就继续循环，就好像中断线程这个信号只是提醒了一下，线程打个日志就完事，当做没听见。

事实上，这样的机制是有存在的道理的，如果调用了 interrupt 方法后，线程说中断就中断，是非常不符合常理的，此时并不知道线程执行到什么地方，收到中断的信号后，怎么说也要进行收尾工作，由线程自己决定什么时候被销毁

因此我们要在捕捉到 InterruptedException 异常后，进行工作完善，然后通过 break 跳出循环，结束线程

方法二和方法一相比更加好。因为方法一中的中断标志被修改后，即使当时正在 sleep ，也会把当下的 sleep 的时间过完，才会进行下一轮判断，才知道线程被中断。方法二即使是在 sleep，收到中断信号后，就会马上被唤醒，中断信息收到的更加的及时。

结果：

五、线程等待

通过 join() 方法来决定线程执行顺序（主要控制结束线程的顺序）。

public class func11 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
           for (int i = 0;i < 3;i ++) {
               System.out.println("my Thread~~");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t1.start();
        //t1.join();
        for (int i = 0;i < 3;i ++) {
            System.out.println("my main!!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

结果：

在没有调用 join 方法时，main 线程和 t1 线程是并发的，结果输出是相间的。调用 join 方法后，main 线程就会阻塞等待，要等 t1 线程执行完毕，才会执行 join 方法后的内容

不带参数的 join 方法，等待结束的条件就是 t1 线程结束，没结束就会一直死等；该方法也可以带参数，通过参数来指定等待时间

六、获取线程引用

在线程代码中，需要获取当前线程对应的 Thread 类的实例化对象，才能进行更多的操作

方法一：通过继承 Thread 类创建的线程，可以在重写的 run 方法中通过 this 获取当前线程的实例

在上面的中断线程中的方法二中就是通过 this.isInterrupted() 来获取当前实例是否被中断的信息。

如果将创建线程的方式改成创建 Runnable 实例的方法，当前的run 方法就不是 Thread 类的方法，this 指向的是 Runnable，就没有办法获取 Thread 实例，更没有办法使用其中的方法

方法二：通过 Thread 类的 currentThread() 方法，哪个线程调用了该方法，就返回哪个线程的实例对象

七、线程休眠

该方法在前面经常介绍，那就是 sleep 方法

一旦调用 sleep 方法，线程就会阻塞等待，等待的时间取决于指定的参数

操作系统是以线程为单位进行调度的，每个线程都对应着一个 PCB，并通过双向链表组织这些 PCB

操作系统调度 PCB 时，就是从就绪队列中选出一个 PCB 去 CPU 上执行，当执行着的线程调用了 sleep 方法，这个 PCB 就会被移动到阻塞队列中，等到 sleep 的时间到了，就会回到就绪队列中，准备好被执行

join 方法也会产生阻塞等待，就像线程等待中的例子，main 线程执行到 join方法后，就到阻塞队列中，等待对应的 t1 线程执行完毕，才会回到就绪队列中，做好被执行的准备

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

(img-A0mZr4d9-1715697773829)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！