多线程以及线程成源码分析_多线程cpu压力测试源码-CSDN博客

本文链接：https://blog.csdn.net/qq_35551875/article/details/121497404

什么是多线程

多线程是指操作系统能够进行调度的最小单位.。它是被包含在进程之中的，是进程的实际运作单位，硬件CPU核心数就对应可同时执行线程数。

具体的演变之路

IO数据库交互，刷盘，缓存，分布式，中间件，线程在单节点到分布式计算机都无处不在。

为什么要用线程

从程序启动到一个进程运行，中间需要CPU来调度执行，但是CPU运算速度远远大于磁盘IO计算存储，那么中间的这个间差CPU就会处于等待状态，也就是阻塞，从而导致了CPU资源的浪费。
所有就引出多进程再到多线程，一个进程可以有N个线程

Java中的多线程

1.多线程特征

异步

就是我不需要一直等待结果回来，我在发送完请求之后，不用等待结果，然后可以去做其他事了
具体体现：用户注册完，然后异步抽奖并发送邮件等等

并行

我可以同时去做抽奖，并且发送欢迎的邮件，两个线程之间无关联关系时用

2.Java中使用

有三种方式使用，分别看如下代码

class Test0 extends Thread{
    @Override
    public void run() {
        System.out.println("继承Thread");
    }
}

class Test1 implements Runnable{

    @Override
    public void run() {
        System.out.println("实现Runnable接口");
    }
}

class Test2 implements Callable {

    @Override
    public Object call() throws Exception {
        System.out.println("实现Callable接口,并且获得返回值");
        Thread.sleep(10000);
        return "call线程 返回值";
    }
}

//main方法调用
public static void main(String[] args) throws Exception {
    //继承Thread
    new Test0().start();
    //实现Runnable接口
    new Thread(new Test1()).start();
    //实现callable接口 可获取返回值
    Test2 test2 = new Test2();
    FutureTask<Object> task = new FutureTask<Object>(test2);
    //这里jvm先调到FutureTask里面的run方法 再调用result = c.call();到我们的实现方法
    //并把结果保存变量outcome
    new Thread(task).start();
    //通过report获取结果 还没执行完就等待
    System.out.println(task.get());
}

多线程实现原理

1.源码分析，从这里开始

class Test0 extends Thread{
    @Override
    public void run() {
        System.out.println("继承Thread");
    }
}

2.启动线程

	//start方法才是启动一个线程 run()是同步执行一次
	new Test0().start(); 
	//来到Thread类里面
    public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        //加入到线程组
        group.add(this);

        boolean started = false;
        try {
            //主要看这个 ###
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }
	//接下来发现是native方法
    private native void start0();

上面的native方法，最终调用到JVM thread.cpp中，然后JVM 根据不同的操作系统会调用的对应OS create一个线程，并且该方法会告诉CPU start了一个线程，然后在cpu调度算法中执行此线程时会回调到JVM中，最终调用thread 中的run方法，也就是我们手写的代码，线程开始执行

3.线程运行图

线程运行图

线程的生命周期

开启 -> 阻塞(sleep wait) -> 锁阻塞(lock synchronized同步锁) -> 执行完成/异常自己结束

线程运行中，可以通过[jstack 进程号] 查看栈日志

线程的停止

1.先看友好的结束，通过interrupted中断指令停止

		Thread thread = new Thread(() -> {
        	while (!Thread.currentThread().isInterrupted()) {
        		System.out.println(11111);
        	}
        }, "N1");
        thread.start();
        Thread.sleep(1000);
		//通过当前线程的中断标识去停止
        thread.interrupt();
        System.out.println(22222);

2.暴力结束，肯定是线程中执行的块不能正常结束时使用，比如死循环，阻塞，等待

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println(3333);
                }
                System.out.println(11111);

            }
        }, "N1");
        thread.start();
        Thread.sleep(3000);
        //发送中断指令,会往上抛InterruptedException
        thread.interrupted();
        System.out.println(22222);
    }

执行结果

从上面结果可以看到，代码压根不会停，而是会一直跑着，明明发送了中断指令，为什么还不停止呢？先看看这两段代码

 try {
     Thread.sleep(1000);
 } catch (InterruptedException e) {
     System.out.println(3333);
 }
try {
    Thread.currentThread().wait();
} catch (InterruptedException e) {
    e.printStackTrace();
}

线程所有的等待或阻塞操作都会抛出这个异常，因为有可能出现一直等待或阻塞所以才需要线程的中断，但是线程明明中断了，却还不停止，这个过程就叫线程的中断复位

	 try {
         Thread.sleep(1000);
     } catch (InterruptedException e) {
         //这里的选择权在开发者本人 
         //InterruptedException 异常抛出来后会还原中断状态 就是所说的复位
         //然后这里你希望中断就用这个 Thread.currentThread().interrupt()
         //然后在异常中断后做一些事情
         System.out.println(3333);
     }

3.线程的复位

当给出线程interrupted标识时，当前线程并不会马上结束，而是会抛出InterruptedException，需要由开发者自己决定，因为异常中断后可能需要做一些其他的记录。
我们看看代码分析

	public static boolean interrupted() {
		//给当前线程标识一个true
        return currentThread().isInterrupted(true);
    }
    //接下来又到native方法 那就是在JVM做的操作了
    //给了这个线程一个标识，当该线程读到标识时会抛出异常，并且重置interrupted状态
    private native boolean isInterrupted(boolean ClearInterrupted);