多线程基础

最新推荐文章于 2024-05-24 10:10:07 发布

何方妖nie丶

最新推荐文章于 2024-05-24 10:10:07 发布

阅读量206

点赞数

分类专栏：多线程与并发文章标签： java 多线程

本文链接：https://blog.csdn.net/weixin_43186116/article/details/106202463

版权

多线程与并发专栏收录该内容

1 篇文章 0 订阅

订阅专栏

多线程基础

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

注：本文档中若无特殊说明，线程统一指Java中的线程。线程是操作系统底层提供的，Java只是提供了通过Java语言来操作线程的API。

并发和并行

并行是指两个或者多个事件在同一时刻发生。

并发是指两个或多个事件在同一时间间隔内发生，不一定要同时。

区分并发和并行最关键的点就是：是否是同时。

线程特性和应用场景

特性

并行
异步

应用

网络请求分发（Tomcat处理Socket就是通过线程来实现的）
文件导入（批量上传）
短信/邮件发送

获取线程的方法

Thread
Runnable
Callable/Future
线程池

线程的状态

在这里插入图片描述

WAITING/TIME_WAITING 和 BLOCKED的区别：

相同点：线程都处于阻塞状态
不同点：WAITING/TIME_WAITING是调用 Java 线程的阻塞方法进入阻塞状态，而 BLOCKED 是线程在争抢锁失败时进入的阻塞状态。

另外，需要注意的是，操作系统中的线程除去 New 和 Terminated 状态，一个线程真实存在的状态，只有：

ready：表示线程已经被创建，正在等待系统调度分配 CPU 使用权。
running：表示线程获得了 CPU 使用权，正在进行运算。
waiting：表示线程等待（或者说挂起），让出 CPU 资源给其他线程使用。

在加上新建状态和死亡状态，一共 5 种。

线程的启动

在Java中，启动一个线程的代码如下：

Thread t = new Thread();
t.start();

最终调用的是Thread类的start0()方法：

private native void start0();

该方法是一个本地方法，由 Jvm 提供，一个Native Method就是一个java调用非java代码的接口。

在hotspot源码中，start0()对应由 Jvm.cpp 提供的JVM_StartThread()方法，该方法会执行如下代码：

// 创建一个JavaThread
native_thread = new JavaThread(&thread_entry, sz);

// 启动线程
Thread::start(native_thread);

再看Thread.cpp源码中的start()方法：

if (!DisableStartThread) {
    if (thread->is_Java_thread()) {
      // 如果线程是JavaThread，那么设置为RUNNABLE状态
      java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),
                                          java_lang_Thread::RUNNABLE);
    }
    // 通过操作系统来启动线程
    os::start_thread(thread);
  }

在linux平台中的实现如下：os_linux.cpp#start_thread

// call one more level start routine
thread->run();

这就是为什么通过start()启动线程最终会执行run()方法的原因。

大致的流程图如下：

在这里插入图片描述

线程的终止

正常情况下线程执行完就会自动终止，但如果线程的run()方法一直不结束，那么线程理论上永远不会终止。

假设存在如下代码：

public class MyThread implements Runnable {

    private int i = 0;

    @Override
    public void run() {
        while (true) {
            System.out.println("Test i=" + i++);
        }
    }

    public static void main(String[] args) {
        Thread t = new Thread(new MyThread());
        t.start();
    }
}

当程序启动时，控制台会不断输出变量i的值，除非手动关闭程序。还有没有其他方法终止线程呢？

调用stop()方法

修改上诉 Demo 中的主函数：
```
Thread t = new Thread(new MyThread());
t.start();

TimeUnit.SECONDS.sleep(10);
t.stop();
```
启动程序后可以发现 10s 后程序会自动退出。

暴力停止，不推荐使用，可能导致线程run()方法还没执行完线程就被终止。

发送中断信号

public class MyThread implements Runnable {

    private int i = 0;

    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("Test i=" + i++);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new MyThread());
        t.start();
        
        TimeUnit.SECONDS.sleep(10);
        t.interrupt();
    }
}

将线程run()方法中的判断条件改为判断线程是否中断（默认为false），当主程序中通过t.interrupt()将值改为true时，相当于线程收到了中断信号，就会退出循环，结束线程。

interrupt 方法另外一个作用就是使线程复位，在调用线程阻塞相关的方法如：sleep、wait方法时，会抛出InterruptedException线程中断异常，该异常会在线程响应中断时抛出。

public class MyThread implements Runnable {

    private int i = 0;

    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                TimeUnit.SECONDS.sleep(2000);
            } catch (InterruptedException e) {
                // 收到中断信号会响应中断，打印异常信息
                e.printStackTrace();
                // 如果再这里执行break，收到中断信号时就会结束循环。
                // break;
                // 这里还可以继续执行中断，你不是给我还原了吗，我再中断以下
                // Thread.currentThread().interrupt();
            }
        }
        System.out.println("MyThread end...");
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new MyThread());
        t.start();

        Thread.sleep(1000);
        t.interrupt();
    }
}

现在假设线程执行循环的逻辑时不停的睡眠2000s，当主程序发出线程中断请求时，会抛出InterruptedException。该异常就代表了线程收到了中断信号，响应中断（默认方式是打印异常信息不做任何处理），然后将线程复位（将中断信号还原成false，线程仍然不会结束）。

线程复位

Thread t = new Thread(new MyThread());
t.start();

Thread.sleep(1000);
Thread.interrupted();

线程中断原理

在前面的例子中，当调用t.interrupt()方法时，最终调用的还是一个本地方法

private native void interrupt0();

根据前面start0()方法的经验，查看jvm.cpp关于interrupt0的实现，核心代码：

JVM_ENTRY(void, JVM_Interrupt(JNIEnv* env, jobject jthread))
  JVMWrapper("JVM_Interrupt");

  // Ensure that the C++ Thread and OSThread structures aren't freed before we operate
  oop java_thread = JNIHandles::resolve_non_null(jthread);
  MutexLockerEx ml(thread->threadObj() == java_thread ? NULL : Threads_lock);
  // We need to re-resolve the java_thread, since a GC might have happened during the
  // acquire of the lock
  JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread));
  if (thr != NULL) {
    Thread::interrupt(thr);
  }
JVM_END

会调用Thread.cpp的interrupt()方法：

void Thread::interrupt(Thread* thread) {
  trace("interrupt", thread);
  debug_only(check_for_dangling_thread_pointer(thread);)
  os::interrupt(thread);
}

再看os_linux.cpp关于interrupt的实现：

void os::interrupt(Thread* thread) {
  assert(Thread::current() == thread || Threads_lock->owned_by_self(),
    "possibility of dangling Thread pointer");

  OSThread* osthread = thread->osthread();

  if (!osthread->interrupted()) {
    // 判断线程是不是中断状态，如果不是，收到中断请求后设置中断状态  
    osthread->set_interrupted(true);
    // More than one thread can get here with the same value of osthread,
    // resulting in multiple notifications.  We do, however, want the store
    // to interrupted() to be visible to other threads before we execute unpark().
    OrderAccess::fence();
    // 如果是sleep中，唤醒  
    ParkEvent * const slp = thread->_SleepEvent ;
    if (slp != NULL) slp->unpark() ;
  }

  // For JSR166. Unpark even if interrupt status already was set
  //   唤醒park()阻塞的线程
  if (thread->is_Java_thread())
    ((JavaThread*)thread)->parker()->unpark();

  ParkEvent * ev = thread->_ParkEvent ;
  if (ev != NULL) ev->unpark() ;

}

最终会通过操作系统来实现线程中断，总的来说，interrupt方法的作用如下：