🌺个人主页：Dawn黎明开始
🎀系列专栏：Java
⭐每日一句：身在井隅，心向阳光，眼里有诗，自在远方📢欢迎大家：关注🔍+点赞👍+评论📝+收藏⭐️
文章目录
一.🔐多线程
📋前言
1.1🔓进程
1.1.1🔑什么是进程?
1.1.2🔑多进程有什么意义呢?
1.2🔓线程
1.2.1🔑什么是线程呢?
1.2.2🔑多线程有什么意义呢?
1.3🔓Java程序的运行原理
1.3.1🔑原理
1.3.2🔑思考题
二.🔐多线程的三种创建方法
2.1.🔓继承Thread类
2.1.1🔑步骤
2.1.2🔑实例练习
2.1.3🔑思考
2.2🔓实现Runnable接口
2.2.1🔑步骤
2.2.2🔑实例练习
2.3🔓实现Callable接口
2.2.1🔑步骤
2.2.2🔑实例练习
2.4🔓三种方法的对比分析
2.4.1🔑分析
2.4.2🔑优点
2.4.3🔑说明
一.🔐多线程
📋前言
要想了解多线程，必须先了解线程，而要想了解线程，必须先了解进程，因为线程是依赖于进程而存在。
1.1🔓进程
1.1.1🔑什么是进程?
定义：
在一个操作系统中，每个独立执行的程序都可称之为一个进程，也就是“正在运行的程序”。
进程是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。
通过任务管理器我们就看到了进程的存在，而通过观察，我们发现只有运行的程序才会出现进程。
1.1.2🔑多进程有什么意义呢?
单进程的计算机只能做一件事情，而我们现在的计算机都可以做多件事情。
举例：一边玩游戏(游戏进程)，一边听音乐(音乐进程)。
📝总结
现在的计算机都是支持多进程的，可以在一个时间段内执行多个任务。多进程可以提高CPU的使用率(前提：单CPU系统)。
🔥思考：
一边玩游戏，一边听音乐是同时进行的吗?
不是。因为单CPU在某一个时间点上只能做一件事情，在计算机中，所有的应用程序都是由CPU执行的，对于一个CPU而言，在某个时间点只能运行一个程序，也就是说只能执行一个进程，操作系统会为每一个进程分配一段有限的CPU使用时间，CPU在这段时间中执行某个进程，然后会在下一段时间切换到另一个进程中去执行。
而我们在玩游戏，或者听音乐的时候，是CPU在做着程序间的高效切换让我们觉得是同时进行的。
📝总结
(1).在多任务操作系统中，表面上看是支持进程并发执行的，例如可以一边听音乐一边聊天，但实际上这些进程并不是在同一时刻运行的。
(2).由于CPU运行速度非常快，能在极短的时间内在不同的进程之间进行切换，所以给人以同时执行多个程序的感觉。
1.2🔓线程
1.2.1🔑什么是线程呢?
定义：
多任务操作系统中，每个运行的程序都是一个进程，用来执行不同的任务，而在一个进程中还可以有多个执行单元同时运行，来同时完成一个或多个程序任务，这些执行单元可以看做程序执行的一条条线索，被称为线程。
说明：
(1).单线程都是按照调用顺序依次往下执行，没有出现多段程序代码交替运行的效果，而多线程程序在运行时，每个线程之间都是独立的，它们可以并发执行。
(2).多线程可以充分利用CUP资源，进一步提升程序执行效率。
(3).多线程看似是同时并发执行的，其实不然，它们和进程一样，也是由CPU控制并轮流执行的，只不过CPU运行速度非常快，故而给人同时执行的感觉。
多线程举例：
扫雷程序、百度云盘、百度网盘下载
1.2.2🔑多线程有什么意义呢?
多线程的存在，不是提高程序的执行速度。其实是为了提高应用程序的使用率。
(1).程序的执行其实都是在抢CPU的资源，CPU的执行权 。
(2).多个进程是在抢这个资源，而其中的某一个进程如果执行路径比较多，就会有更高的几率抢到CPU的执行权。
(3).我们是不能确定哪一个线程能够在哪个时刻抢到，所以线程的执行具有随机性。
1.3🔓Java程序的运行原理
1.3.1🔑原理
Java命令去启动JVM，JVM会启动一个进程，该进程会创建了一个主线程去调用main方法。
1.3.2🔑思考题
🔥JVM的启动是多线程的吗?
是多线程的，原因是:垃圾回收线程也要先启动，否则很容易会出现内存溢出。现在的垃圾回收线程加上前面的主线程，最低启动了两个线程，所以，jvm的启动其实是多线程的。
二.🔐多线程的三种创建方法
2.1.🔓继承Thread类
如何获取线程对象的名称呢?
* public final String getName():获取线程的名称。
* 如何设置线程对象的名称呢?
* public final void setName(String name):设置线程的名称
*
* 针对不是Thread类的子类中如何获取线程对象名称呢?
* public static Thread currentThread():返回当前正在执行的线程对象
* Thread.currentThread().getName()2.1.1🔑步骤
A:自定义类MyThread继承Thread类。
B:MyThread类里面重写run()
C:创建对象
D:启动线程
2.1.2🔑实例练习
🚩实例练习1
代码如下👇🏻
package Process;
public class MyThread extends Thread {
@Override
public void run() { //多线程的任务
for(int i=0;i<200;i++) {
System.out.println(i);
}
}
}
package Process;
public class MyThreadDemo {
public static void main(String[] args) {
// 创建两个线程对象
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
my1.start();
my2.start();
}
}
运行结果👇🏻
🚩实例练习2
代码如下👇🏻
package Process;
public class MyThread1 extends Thread {
public MyThread1() {
super();
}
public MyThread1(String name) {
super(name);
}
@Override
public void run() { //多线程的任务
for(int i=0;i<200;i++) {
System.out.println(this.getName()+":"+i);
}
}
}
package Process;
public class MyThreadDemo1 {
// 创建两个线程对象
public static void main(String[] args) {
MyThread1 my3 = new MyThread1("张三");
MyThread1 my4 = new MyThread1("李四");
my3.start();
my4.start();
for(int i=0;i<20;i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
运行结果👇🏻
2.1.3🔑思考
🔥思考： 调用run()方法为什么是单线程的呢?
因为run()方法直接调用其实就相当于普通的方法调用,所以你看到的是单线程的效果
要想看到多线程的效果，就必须用另一个方法：start()
🔥面试题：run()和start()的区别?
run():仅仅是封装被线程执行的代码，直接调用是普通方法
start():首先启动了线程，然后再由jvm去调用该线程的run()方法。
2.2🔓实现Runnable接口
2.2.1🔑步骤
A:自定义类MyRunnable实现Runnable接口
B:重写run()方法
C:创建MyRunnable类的对象
D:创建Thread类的对象，并把C步骤的对象作为构造参数传递
E:启动线程（Thread类的对象）
🔥思考：有了方法1，为什么还来一个方法2呢？
(1).可以避免由于Java单继承带来的局限性。
(2).适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码，数据有效分离，较好的体现了面向对象的设计思想。
2.2.2🔑实例练习
代码如下👇🏻
package Process;
public class MyRunnable implements Runnable {
@Override
public void run() {
for(int i=0;i<200;i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
package Process;
public class MyRunnableDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyRunnable mr =new MyRunnable();
Thread t1 =new Thread(mr,"王五");
t1.start();
Thread t2=new Thread(mr,"赵六");
t2.start();
//简洁方法
// new Thread(new MyRunnable(),"a").start();
// new Thread(new MyRunnable(),"b").start();
}
}
运行结果👇🏻
2.3🔓实现Callable接口
2.2.1🔑步骤
A:自定义类MyCallable实现Callable接口
B:重写call()方法
C:创建MyCallable类的对象
D:创建FutureTask类的对象，并把C步骤的对象作为构造参数传递
E:创建Thread类的对象，并把D步骤的对象作为构造参数传递
F:启动线程（Thread类的对象）
🔥与两种方式的区别:
(1).该方式的线程执行结束返回一个值
(2).可以通过FutureTask类的对象的get()方法接受返回值
2.2.2🔑实例练习
代码如下👇🏻
package Process;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<Object> {
@Override
public Object call() throws Exception {
int sum=0;
for(int i=0;i<=10;i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
sum+=i;
}
return sum;
}
}
package Process;
import java.util.concurrent.FutureTask;
public class MyCallableDemo {
public static void main(String[] args) throws Exception {
//2、创建Callable接口的实现类对象
MyCallable MyThread1=new MyCallable();
//3、使用 FutureTask封装Callable接口
FutureTask<Object> ft1 =new FutureTask<>(MyThread1);
//4、使用Thread(Runable target,String name)构造方法创建线程对象
Thread thread1 =new Thread(ft1,"线程A");
//5、调用线程对象得start()方法启动线程
thread1.start();
//创建并启动另一个线程
FutureTask<Object> ft2 =new FutureTask<>(MyThread1);
Thread thread2 =new Thread(ft2,"线程B");
thread2.start();
//可以通过FutureTask对象得方法管理返回值
System.out.println("线程A的返回值:"+ft1.get());
System.out.println("线程A的返回值:"+ft2.get());
}
}
运行结果👇🏻
2.4🔓三种方法的对比分析
2.4.1🔑分析
(1).继承Thread类是最简单和直接的方式，但限制了类的扩展性。
(2).实现Runnable接口提供了更好的灵活性，使得多个线程可以共享一个任务。
(3).实现Callable接口则更适合需要获取线程执行结果的情况，可以更方便地处理线程执行后的返回值或异常。
2.4.2🔑优点
通过实现Runnable接口（或者Callable接口）相对于继承Thread类实现多线程来说
(1).适合多个线程去处理同一个共享资源的情况。
(2).可以避免Java单继承带来的局限性。
2.4.3🔑说明
事实上，实际开发中大部分的多线程应用都会采用Runnable接口或者Callable接口的方式实现多线程。
🌺建议大家亲自动手操作，学编程，多实践练习是提升编程技能的必经之路。
🌺欢迎大家在评论区进行讨论和指正！
文章出处登录后可见！
