备案控制台
开发者社区 开发与运维 文章 正文

多线程的基本概念和实现方式，线程的调度，守护线程、礼让线程、插入线程

2024-05-24 27
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 多线程的基本概念和实现方式，线程的调度，守护线程、礼让线程、插入线程

一、什么是多线程

线程：

线程是操作系统能够进行运算调度的最小单位。

线程被包含在进程之中，是进程中的实际运作单位。

进程:

进程是程序的基本执行实体

可以说一个软件运行后，就是一个进程。

在任务管理器中我们可以看到在电脑上运行的一个个进程。

所以线程可以简单理解为：应用软件中互相独立，可以同时运行的功能。

有了多线程，我们就可以让程序同时做多件事情。

多线程的作用：

可以充分利用程序当中的等待时间，让CPU在多个程序当中切换，提高程序的运行效率。

多线程的应用场景：

只要想让多个事情同时运行就需要用到多线程（如软件中的耗时操作、聊天软件、服务器等）。

二、多线程的两个概念（并发和并行）

1.并发：在同一时刻，有多个指令在单个CPU上交替执行

2.并行：在同一时刻，有多个指令在多个CPU上同时执行

计算机的CPU可以分为2核四4线程、4核8线程、8核16线程、16核32线程、32核64线程。

以2核4线程为例：表示在计算机当中如果只有4条线程，那么这四个线程可以同时执行，不需要切换，但线程数超过了4条，就需要切换执行。

所以说并发和并行有可能同时进行。

三、多线程的实现方式

3.1继承Thread类的方式

1.自己定义一个类继承Thread

2.重写run方法

3.创建子类的对象，并启动线程。

package com.practice;
/**
 * @Author YJ
 * @Date 2023/7/21 9:41
 * Description:继承Thread类的方式
 */
public class MyThread extends Thread{
    @Override
    public void run() {
        //书写线程要执行的方法
        //getName()获取线程名
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "：hello world");
        }
    }
}
package com.practice;
/**
 * @Author YJ
 * @Date 2023/7/21 9:37
 * Description:继承Thread类的方式
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        //创建对象，启动线程
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        //为线程命名
        thread1.setName("线程1");
        thread2.setName("线程2");
        //开启线程
        thread1.start();
        thread2.start();
    }
}

3.2实现Runnable接口的方式

.1.自己定义一个类实现Runnable接口

2.重写里面的run方法

3.创建自己的类的对象

4.创建一个Thread类的对象，并开启线程。

package com.practice.threaddemo2;
/**
 * @Author YJ
 * @Date 2023/7/21 9:53
 * Description:实现Runnable接口的方式
 */
public class MyRun implements Runnable{
    @Override
    public void run() {
        //获取当前线程的对象
        Thread thread = Thread.currentThread();
        for (int i = 0; i < 100; i++) {
            System.out.println(thread.getName() + "：hello world!");
        }
    }
}
package com.practice.threaddemo2;
/**
 * @Author YJ
 * @Date 2023/7/21 9:53
 * Description:实现Runnable接口的方式
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //创建自己类MyRun的对象
        MyRun myRun = new MyRun();
        //创建线程对象，并传递任务
        Thread thread1 = new Thread(myRun);
        Thread thread2 = new Thread(myRun);
        //给线程命名
        thread1.setName("线程1");
        thread2.setName("线程2");
        //开启线程
        thread1.start();
        thread2.start();
    }
}

3.3利用Callable接口和Future接口方式

特点：可以获取到多线程运行的结果

1.创建一个类实现Callable接口

2.重写call(有返回值，表示多线程运行的结果)

3.创建实现Callable接口的类的对象（表示多线程要执行的任务）

4.创建FutureTask的对象（作用管理多线程运行的结果）

5.创建Thread类的对象，并启动线程。

package com.practice.threaddemo3;
import java.util.concurrent.Callable;
/**
 * @Author YJ
 * @Date 2023/7/21 10:11
 * Description:利用Callable接口和Future接口方式
 */
public class MyCallable implements Callable<Integer> {
    //求1-100的和
    int sum = 0;
    @Override
    public Integer call() throws Exception {
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}
package com.practice.threaddemo3;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 * @Author YJ
 * @Date 2023/7/21 10:11
 * Description:利用Callable接口和Future接口方式
 */
public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建实现Callable接口的类的对象（表示多线程要执行的任务）
        MyCallable mc = new MyCallable();
        //创建FutureTask的对象（作用管理多线程运行的结果）
        FutureTask<Integer> ft = new FutureTask<>(mc);
        //创建Thread类的对象，并启动线程。
        Thread t1 = new Thread(ft);
        Thread t2 = new Thread(ft);
        //启动线程
        t1.start();
        t2.start();
        //获取结果
        Integer result = ft.get();
        System.out.println(result);
    }
}

四、多线程中常用的成员方法

4.1基本成员方法

String getName()返回线程名字

void setName()设置线程名字（Thread 构造方法也可实现）

细节：

1.如果没有给线程设置名字，线程有默认名字（格式：Thread-X（X是序号，从0开始））

2.如果要给线程设置名字，可以通过set方法设置，也可通过构造方法设置。

package com.practice.threaddemo4;
/**
 * @Author YJ
 * @Date 2023/7/21 10:26
 * Description:构造方法设置名字
 */
public class MyThread extends Thread{
    public MyThread() {
    }
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "@" + i);
        }
    }
}
package com.practice.threaddemo4;
/**
 * @Author YJ
 * @Date 2023/7/21 10:26
 * Description:构造方法设置名字
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //创建线程对象
        MyThread t1 = new MyThread("蓝1");
        MyThread t2 = new MyThread("红2");
        //开启线程
        t1.start();
        t2.start();
    }
}

static Thread currentThread()获取当前线程对象

细节：

当JVM虚拟机启动之后，会自动地启动多条线程，其中有一条线程就叫做main线程，

它的作用就是去调用main方法，并执行里面的代码

在以前我们写的所有的代码，都是运行在main线程中的。

static void sleep(long time):让线程休眠指定的时间，单位为毫秒

细节:

1.哪条线程执行到这里，该线程就会在此停留对应的时间

2.方法的参数，表示睡眠的时间，单位毫秒

3.当时间到了，线程会自动醒来，继续执行代码。

package com.practice.threaddemo4;
/**
 * @Author YJ
 * @Date 2023/7/21 10:43
 * Description:sleep演示
 */
public class ThreadDemoSleep {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("你好~");
        Thread.sleep(5000);
        System.out.println("hi~");
    }
}

4.2线程的优先级

线程的调度：

1.抢占式调度：多个线程在抢夺CPU的执行权，CPU执行线程是不确定的，执行多长时间也不确定（随机性）；

2.非抢占式调度：所有的线程轮流执行。

Java中用的是抢占式调度（注意随机性）

Java中优先级分为1-10级

Thread .getPriority()获取优先级

Thread .setPriority()设置优先级

优先级越高，抢占到CPU的概率越大，但并不是一定的

package com.practice.threaddemo5;
/**
 * @Author YJ
 * @Date 2023/7/21 11:04
 * Description:
 */
public class ThreadDemo {
    public static void main(String[] args) {
        MyRun mr = new MyRun();
        Thread t1 = new Thread(mr,"1");
        Thread t2 = new Thread(mr,"2");
        t1.setPriority(1);
        t2.setPriority(10);
        t1.start();
        t2.start();
    }
}

4.3守护线程

final void setDaemon()

当其他非守护线程执行完毕后，守护线程会陆续结束，守护线程不一定执行完

例如：有两个线程，线程1为1号线程，线程2为2号线程，把线程2设置为守护线程，当两个线程执行的时候，若1号线程执行完毕2号线程没有执行完毕，此时2号线程会陆续结束，即使它没有执行完也会结束。

因为非守护线程已经执行完，守护线程就没有存在的必要了。

package com.practice.threaddemo6;
/**
 * @Author YJ
 * @Date 2023/7/21 11:19
 * Description:
 */
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
        t1.setName("1号");
        t2.setName("2号");
        //设置2号为守护线程（备胎线程）
        //当1号线程结束了，2号线程就没有存在的必要了
        t2.setDaemon(true);
        t1.start();
        t2.start();
    }
}

4.4出让/礼让线程

public static void yield()

尽可能将线程均匀

package com.practice.threaddemo7;
/**
 * @Author YJ
 * @Date 2023/7/21 9:41
 * Description:
 */
public class MyThread extends Thread{
    @Override
    public void run() {
        //书写线程要执行的方法
        //getName()获取线程名
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "@" + i);
            Thread.yield();
        }
    }
}

4.5插入线程

public static void join()

表示把某个线程插入到当前线程之前

当插入的线程执行完后，才执行当前线程

package com.practice.threaddemo8;
/**
 * @Author YJ
 * @Date 2023/7/21 11:19
 * Description:
 */
public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.setName("1号");
        t1.start();
        //执行在main线程上的
        //当前线程：main线程
        //表示将t1线程插入到main线程之前
        t1.join();
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程" + i);
        }
    }
}

五、线程的生命周期

新建状态：创建线程对象start（）

就绪状态（不停的抢CPU）：有执行资格，没有执行权

运行状态（代码）：有执行资格，有执行权

1.若被其他线程抢走CPU执行权就会回到就绪状态

2.若是有sleep()或是其他阻塞式方法会变成阻塞状态

3.若是执行完毕run()会变成死亡状态：线程死亡，变成垃圾

阻塞状态（等着）：没有执行资格，没有执行权

死亡状态：线程死亡，变成垃圾

总结

经过本篇文章，我们了解到了线程的基本概念及如何实现多线程，欢迎各位伙伴评论+点赞！！！

我会持续学习并更新博客,欢迎各位评论！！！

文章标签：
调度
Java
关键词：
线程守护线程
线程守护
多线程线程
线程多线程
线程基本概念
叶落闲庭
目录
相关文章
米诺斯
|
1天前
|
Java
java线程之用户线程与守护线程
java线程之用户线程与守护线程
米诺斯
6 1
java线程之用户线程与守护线程
落雨便归尘
|
4天前
|
存储 Linux C语言
c++进阶篇——初窥多线程(二) 基于C语言实现的多线程编写
本文介绍了C++中使用C语言的pthread库实现多线程编程。`pthread_create`用于创建新线程，`pthread_self`返回当前线程ID。示例展示了如何创建线程并打印线程ID，强调了线程同步的重要性，如使用`sleep`防止主线程提前结束导致子线程未执行完。`pthread_exit`用于线程退出，`pthread_join`用来等待并回收子线程，`pthread_detach`则分离线程。文中还提到了线程取消功能，通过`pthread_cancel`实现。这些基本操作是理解和使用C/C++多线程的关键。
落雨便归尘
22 7
落雨便归尘
|
2天前
|
API C++
c++进阶篇——初窥多线程(三)cpp中的线程类
C++11引入了`std::thread`，提供对并发编程的支持，简化多线程创建并增强可移植性。`std::thread`的构造函数包括默认构造、移动构造及模板构造（支持函数、lambda和对象）。`thread::get_id()`获取线程ID，`join()`确保线程执行完成，`detach()`使线程独立，`joinable()`检查线程状态，`operator=`仅支持移动赋值。`thread::hardware_concurrency()`返回CPU核心数，可用于高效线程分配。
落雨便归尘
8 0
落雨便归尘
|
6天前
|
存储 安全 程序员
c++理论篇——初窥多线程(一) 计算机内存视角下的多线程编程
c++理论篇——初窥多线程(一) 计算机内存视角下的多线程编程
落雨便归尘
16 0
梦回故国楼台梦
|
7天前
|
Java
你还在单线程里奋斗？来看看 Java 多线程创建的魅力！
【6月更文挑战第19天】单线程程序中任务依次执行导致效率低，而Java多线程可并行处理任务，提高效率。在示例中，多线程版本并行运行三个任务，减少总耗时，展示出多线程在处理并发和提升响应速度上的优势。使用`Thread`类创建线程，通过`start()`启动，`join()`确保所有线程执行完毕，揭示了多线程在编程中的强大潜力。
梦回故国楼台梦
13 0
梦回故国楼台梦
|
7天前
|
Java 开发者
线程的诞生之路：Java多线程创建方法的抉择与智慧
【6月更文挑战第19天】Java多线程编程中，开发者可选择继承Thread类或实现Runnable接口。继承Thread直接但受限于单继承，适合简单场景；实现Runnable更灵活，支持代码复用，适用于如银行转账这类需多线程处理的复杂任务。在资源管理和任务执行控制上，Runnable接口通常更优。
梦回故国楼台梦
12 0
梦回故国楼台梦
|
7天前
|
Java
Java 多线程新手必读：线程的创建技巧与陷阱
【6月更文挑战第19天】Java多线程初学者须知：创建线程可通过继承`Thread`或实现`Runnable`接口。继承`Thread`限制单继承，实现`Runnable`更灵活。记得调用`start()`而非`run()`启动线程，避免并发问题时需正确同步共享资源。示例代码展示两种创建方式及未同步导致的问题。
梦回故国楼台梦
11 0
梦回故国楼台梦
|
7天前
|
安全 Java
【极客档案】Java 线程：解锁生命周期的秘密，成为多线程世界的主宰者！
【6月更文挑战第19天】Java多线程编程中，掌握线程生命周期是关键。创建线程可通过继承`Thread`或实现`Runnable`，调用`start()`使线程进入就绪状态。利用`synchronized`保证线程安全，处理阻塞状态，注意资源管理，如使用线程池优化。通过实践与总结，成为多线程编程的专家。
梦回故国楼台梦
18 3
梦回故国楼台梦
|
7天前
|
Java 开发者
告别单线程时代！Java 多线程入门：选继承 Thread 还是 Runnable？
【6月更文挑战第19天】在Java中，面对多任务需求时，开发者可以选择继承`Thread`或实现`Runnable`接口来创建线程。`Thread`继承直接但限制了单继承，而`Runnable`接口提供多实现的灵活性和资源共享。多线程能提升CPU利用率，适用于并发处理和提高响应速度，如在网络服务器中并发处理请求，增强程序性能。不论是选择哪种方式，都是迈向高效编程的重要一步。
梦回故国楼台梦
14 2
梦回故国楼台梦
|
7天前
|
Java 开发者
震惊！Java多线程的惊天秘密：你真的会创建线程吗？
【6月更文挑战第19天】Java多线程创建有两种主要方式：继承Thread类和实现Runnable接口。继承Thread限制了多重继承，适合简单场景；实现Runnable接口更灵活，可与其它继承结合，是更常见选择。了解其差异对于高效、健壮的多线程编程至关重要。
梦回故国楼台梦
18 2