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

进程和线程、实现多线程的两种方式、设置获取线程名称、线程优先级及线程控制

2022-09-27 142
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 进程和线程、实现多线程的两种方式、设置获取线程名称、线程优先级及线程控制的简单示例

 一、进程和线程

进程：是正在运行的程序

是系统进行资源分配和调用的独立单位

每一个进程都有它自己的内存空间和系统资源

线程：是进程中的单个顺序控制流，是一条执行路径

单线程：一个进程如果只有一条执行路径，则为单线程程序

多线程：一个进程如果有多条执行路径，则称为多线程程序

二、实现多线程两种方式

方式一：继承Thread类

方法介绍：

方法名 说明
void run() 在线程开启后，此方法将被调用执行
void start() 使此线程开始执行，Java虚拟机会调用run()方法

实现步骤：

定义一个类MyThread继承Thread类

在MyThread类中重写run()方法

创建MyThread类的对象

启动线程

代码演示：

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        // my1.run(); 
        // my2.run(); 
        //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法 
        my1.start();
        my2.start();
    }
}

image.gif

两个小问题

为什么要重写run()方法？

因为run()是用来封装被线程执行的代码

run()方法和start方法的区别？

run()：封装线程执行的代码，直接调用，相当于普通方法的调用

start()：启动线程，然后由JVM调用此线程的run()方法

方式二：实现Runnable接口

Thread构造方法：

方法名 说明
Thread(Runnable target) 分配一个新的Thread对象
Thread(Runnable target,String name) 分配一个新的Thread对象

实现步骤：

定义一个类MyRunnable实现Runnable接口

在MyRunnable类中重写run()方法

创建MyRunnable类的对象

创建Thread类的对象，把MyRunnable对象作为构造方法的参数

启动线程

代码演示：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象 
        MyRunnable my = new MyRunnable();
        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数 
        //Thread(Runnable target) 
        // Thread t1 = new Thread(my); 
        // Thread t2 = new Thread(my); 
        //Thread(Runnable target, String name) 
        Thread t1 = new Thread(my,"高铁");
        Thread t2 = new Thread(my,"飞机");
        //启动线程 
        t1.start();
        t2.start();
    }
}

image.gif

相比继承Thread类，实现Runnable接口的好处

避免了Java单继承的局限性

适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离、较好的体现了面向对象的设计思想

三、设置和获取线程名称

方法介绍：

方法名 说明
void setName(String name) 将此线程的名称更改为等于参数name
String getName() 返回此线程的名称
Thread currentThread() 返回对当前正在执行的线程对象的引用

代码演示：

public class MyThread extends Thread {
    public MyThread() {}
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        //void setName(String name)：将此线程的名称更改为等于参数 name 
        my1.setName("高铁");
        my2.setName("飞机");
        //Thread(String name) 
        MyThread my1 = new MyThread("高铁");
        MyThread my2 = new MyThread("飞机");
        my1.start();
        my2.start();
        //static Thread currentThread() 返回对当前正在执行的线程对象的引用 
        System.out.println(Thread.currentThread().getName());
    }
}

image.gif

四、线程优先级

线程调度

○ 两种调度方式

■ 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片

■ 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一 个，优先级高的线程获取的 CPU 时间片相对多一些

○ Java使用的是抢占式调度模型

■ 假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

优先级相关方法：

方法名 说明
final int getPriority() 返回此线程的优先级
final void setPriority(int newPriority) 更改此线程的优先级 线程默认优先级是5；线程优先级的范围是：1-10

代码演示：

public class ThreadPriority extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}
public class ThreadPriorityDemo {
    public static void main(String[] args) {
        ThreadPriority tp1 = new ThreadPriority();
        ThreadPriority tp2 = new ThreadPriority();
        ThreadPriority tp3 = new ThreadPriority();
        tp1.setName("高铁");
        tp2.setName("飞机");
        tp3.setName("汽车");
        //public final int getPriority()：返回此线程的优先级 
        System.out.println(tp1.getPriority()); //5 
        System.out.println(tp2.getPriority()); //5 
        System.out.println(tp3.getPriority()); //5 
        //public final void setPriority(int newPriority)：更改此线程的优先级 
        // tp1.setPriority(10000); //IllegalArgumentException 
        System.out.println(Thread.MAX_PRIORITY); //10 
        System.out.println(Thread.MIN_PRIORITY); //1 
        System.out.println(Thread.NORM_PRIORITY); //5 
        //设置正确的优先级 
        tp1.setPriority(5);
        tp2.setPriority(10);
        tp3.setPriority(1);
        tp1.start();
        tp2.start();
        tp3.start();
    }
}

image.gif

五、线程控制

相关方法：

方法名 说明
static void sleep(long millis) 使当前正在执行的线程停留（暂停执行）指定的毫秒数
void join() 等待这个线程死亡
void setDaemon(boolean on) 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将推出

代码演示：

sleep演示：
public class ThreadSleep extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep ts1 = new ThreadSleep();
        ThreadSleep ts2 = new ThreadSleep();
        ThreadSleep ts3 = new ThreadSleep();
        ts1.setName("曹操");
        ts2.setName("刘备");
        ts3.setName("孙权");
        ts1.start();
        ts2.start();
        ts3.start();
    }
}
Join演示：
public class ThreadJoin extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}
public class ThreadJoinDemo {
    public static void main(String[] args) {
        ThreadJoin tj1 = new ThreadJoin();
        ThreadJoin tj2 = new ThreadJoin();
        ThreadJoin tj3 = new ThreadJoin();
        tj1.setName("康熙");
        tj2.setName("四阿哥");
        tj3.setName("八阿哥");
        tj1.start();
        try {
            tj1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tj2.start();
        tj3.start();
    }
}
Daemon演示：
public class ThreadDaemon extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}
public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1 = new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();
        td1.setName("关羽");
        td2.setName("张飞");
//设置主线程为刘备 
        Thread.currentThread().setName("刘备");
//设置守护线程 
        td1.setDaemon(true);
        td2.setDaemon(true);
        td1.start();
        td2.start();
        for(int i=0; i<10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

image.gif

文章标签：
Java
调度
关键词：
线程多线程
进程线程
线程设置
进程优先级
线程优先级
夏志121
目录
相关文章
游客qf4jmczx4xu2y
|
1月前
|
调度 开发者 Python
深入浅出操作系统：进程与线程的奥秘
在数字世界的底层，操作系统扮演着不可或缺的角色。它如同一位高效的管家，协调和控制着计算机硬件与软件资源。本文将拨开迷雾，深入探索操作系统中两个核心概念——进程与线程。我们将从它们的诞生谈起，逐步剖析它们的本质、区别以及如何影响我们日常使用的应用程序性能。通过简单的比喻，我们将理解这些看似抽象的概念，并学会如何在编程实践中高效利用进程与线程。准备好跟随我一起，揭开操作系统的神秘面纱，让我们的代码运行得更加流畅吧！
游客qf4jmczx4xu2y
54 3
我不是游客20240119
|
2月前
|
算法 调度 UED
深入理解操作系统：进程调度与优先级队列
【10月更文挑战第31天】在计算机科学的广阔天地中，操作系统扮演着枢纽的角色，它不仅管理着硬件资源，还为应用程序提供了运行的环境。本文将深入浅出地探讨操作系统的核心概念之一——进程调度，以及如何通过优先级队列来优化资源分配。我们将从基础理论出发，逐步过渡到实际应用，最终以代码示例巩固知识点，旨在为读者揭开操作系统高效管理的神秘面纱。
我不是游客20240119
134 2
栈江湖
|
19天前
|
NoSQL Redis
单线程传奇Redis，为何引入多线程？
Redis 4.0 引入多线程支持，主要用于后台对象删除、处理阻塞命令和网络 I/O 等操作，以提高并发性和性能。尽管如此，Redis 仍保留单线程执行模型处理客户端请求，确保高效性和简单性。多线程仅用于优化后台任务，如异步删除过期对象和分担读写操作，从而提升整体性能。
栈江湖
50 1
蓝易云
|
25天前
|
运维 监控 Ubuntu
【运维】如何在Ubuntu中设置一个内存守护进程来确保内存不会溢出
通过设置内存守护进程，可以有效监控和管理系统内存使用情况，防止内存溢出带来的系统崩溃和服务中断。本文介绍了如何在Ubuntu中编写和配置内存守护脚本，并将其设置为systemd服务。通过这种方式，可以在内存使用超过设定阈值时自动采取措施，确保系统稳定运行。
蓝易云
57 4
LuckiBit
|
1月前
|
消息中间件 Unix Linux
【C语言】进程和线程详解
在现代操作系统中，进程和线程是实现并发执行的两种主要方式。理解它们的区别和各自的应用场景对于编写高效的并发程序至关重要。
LuckiBit
63 6
潇洒洒
|
1月前
|
调度 开发者
深入理解：进程与线程的本质差异
在操作系统和计算机编程领域，进程和线程是两个核心概念。它们在程序执行和资源管理中扮演着至关重要的角色。本文将深入探讨进程与线程的区别，并分析它们在现代软件开发中的应用和重要性。
潇洒洒
63 5
天下无贼001
|
1月前
|
算法 调度 开发者
深入理解操作系统：进程与线程的管理
在数字世界的复杂编织中，操作系统如同一位精明的指挥家，协调着每一个音符的奏响。本篇文章将带领读者穿越操作系统的幕后，探索进程与线程管理的奥秘。从进程的诞生到线程的舞蹈，我们将一起见证这场微观世界的华丽变奏。通过深入浅出的解释和生动的比喻，本文旨在揭示操作系统如何高效地处理多任务，确保系统的稳定性和效率。让我们一起跟随代码的步伐，走进操作系统的内心世界。
天下无贼001
41 2
最好zzz
|
1月前
|
调度 开发者
核心概念解析：进程与线程的对比分析
在操作系统和计算机编程领域，进程和线程是两个基本而核心的概念。它们是程序执行和资源管理的基础，但它们之间存在显著的差异。本文将深入探讨进程与线程的区别，并分析它们在现代软件开发中的应用和重要性。
最好zzz
62 4
游客fmoyiwnvddywe
|
2月前
|
监控 Java
线程池大小如何设置
在并发编程中，线程池是一个非常重要的组件，它不仅能够提高程序的响应速度，还能有效地利用系统资源。合理设置线程池的大小对于优化系统性能至关重要。本文将探讨如何根据应用场景和系统资源来设置线程池的大小。
游客fmoyiwnvddywe
37 1
叫个什么名字
|
2月前
|
并行计算 数据处理 调度
Python中的并发编程：探索多线程与多进程的奥秘####
本文深入探讨了Python中并发编程的两种主要方式——多线程与多进程，通过对比分析它们的工作原理、适用场景及性能差异，揭示了在不同应用需求下如何合理选择并发模型。文章首先简述了并发编程的基本概念，随后详细阐述了Python中多线程与多进程的实现机制，包括GIL（全局解释器锁）对多线程的影响以及多进程的独立内存空间特性。最后，通过实例演示了如何在Python项目中有效利用多线程和多进程提升程序性能。 ####
叫个什么名字
64 5