掌握多线程，拿捏

最新推荐文章于 2025-07-21 11:07:13 发布

码农小丘

最新推荐文章于 2025-07-21 11:07:13 发布

阅读量439

点赞数 3

CC 4.0 BY-SA版权

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/Qzhangww/article/details/143433888

前言：

多线程是多任务的一种特别的形式，能满足程序员编写高效率的程序来达到充分利用 CPU 的目的

进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。(进程是资源分配的最小单位)
线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。（线程是cpu调度的最小单位）

简单理解多线程：例如银行窗口，刚开始只有一个窗口办理，有排队有50人，那效率太低了。行长看到那么多人，立马再提供4个窗口，效率立马上来了。简而言之就是利用资源提高效率（多窗口（多任务））

生命周期：

线程是一个动态执行的过程，它也有一个从产生到死亡的过程。

生命周期：

新建状态:使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。
就绪状态:当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。
运行状态:如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
阻塞状态:如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：
- 等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
- 同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
- 其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。
死亡状态:一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

创建线程的三种方式：

1.继承 Thread 类

重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行，本质上也是实现了 Runnable 接口的一个实例。

public class TheadDemo extends Thread {
    private Thread thread;
    private String threadName;

    TheadDemo(String name) {
        threadName = name;
        System.out.println("创建--> " + threadName);
    }

    @Override
    public void run() {
        System.out.println("运行--> " + threadName);
        try {
            for (int i = 4; i > 0; i--) {
                System.out.println("thread: " + threadName + ", " + i);
                // 让线程睡眠一会
                Thread.sleep(3000);
            }
        } catch (InterruptedException e) {
            System.out.println("thread " + threadName + " 异常.");
        }
        System.out.println("thread " + threadName + " 停止.");
    }

    public void start() {
        System.out.println("开始--->" + threadName);
        if (thread == null) {
            thread = new Thread(this, threadName);
            //调用start方法 -》执行run方法
            thread.start();
        }
    }

    public static void main(String[] args) {
        TheadDemo t = new TheadDemo("线程A");
        t.start();
    }

}

执行结果：

开始--->线程A

创建--->线程A

运行--->线程A

thread：线程A,4

thread：线程A,3

thread：线程A,2

thread：线程A,1

thread停止.

2.实现 Runnable 接口

实现Runnable接口，使该类有了多线程类的特征。run()方法是多线程程序的一个约定。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

/**
 * @Author 
 * @Description 实现runnable接口
 * @Date 
 */
public class RunnableDemo implements Runnable {

    private String name;

    public RunnableDemo(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "运行  :  " + i);
            try {
                Thread.sleep((int) Math.random() * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        RunnableDemo a = new RunnableDemo("A线程");
        Thread athread = new Thread(a);
        athread.start();


        RunnableDemo b = new RunnableDemo("B线程");
        Thread bthread = new Thread(b);
        bthread.start();
    }
}

3.通过 Callable （有返回值）

/**
 * @Author 
 * @Description 实现Callable接口
 * @Date 
 */
public class CallableDemo implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int i = 0;
        for (; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        return i;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableDemo callableDemo = new CallableDemo();
        FutureTask<Integer> futuretask = new FutureTask<>(callableDemo);
        new Thread(futuretask).start();
        System.out.println("获取返回值" + futuretask.get());
    }

}

常用函数说明

sleep(long millis): Thread类的方法，在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
join():Thread类的方法，指等待该线程终止。（如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了）
yield():Thread类的方法，暂停当前正在执行的线程对象，并执行其他线程。
wait(): Object类里的方法，强迫一个线程等待。
notify(): Object类里的方法，通知一个线程继续运行。