多线程入门基础#继承Thread类和实现Runnable接口两种方式启动线程

最新推荐文章于 2022-08-15 21:24:21 发布

CRUD_CODER_LIN

最新推荐文章于 2022-08-15 21:24:21 发布

阅读量492

点赞数

分类专栏： JavaSE&JavaWeb

本文链接：https://blog.csdn.net/LINHONG_1994/article/details/96501661

版权

JavaSE&JavaWeb 专栏收录该内容

43 篇文章 1 订阅

订阅专栏

【分享要点】

✔进程与线程的区别

✔并发与并行的区别

✔线程的调度问题

✔线程的创建与启动

【要点总结】

试想一下，之前我们在设计程序的时候，在没有跳转语句情况下，程序都是至上而下的执行的，现在需要设计出这样的一个程序，功能需求是可以边听歌边发邮件，在这种场景下，我们就应该想到多线程或者多进程的技术来解决问题。之所以线程问题被划分在JavaSE高级应用的行列，那肯定有值得我们去思考专研的地方，下面我会从基础的概念慢慢引入，和大家一起学习多线程！

1.什么是进程与线程？

（1）首先，我们需要清楚两个概念，什么是软件、什么是程序，这个对于我们来说不难理解，两者可以理解为：

软件：1个或多应用程序、相关的素材和资源文件等构成一个软件系统。

程序：为了完成某个任务和功能，选择一种编程语言编写的一组指令的集合。

（2）其次，进程和线程我们可以这样理解：

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

简而言之：一个软件中至少有一个应用程序，应用程序的一次运行就是一个进程，一个进程中至少有一个线程。

面试题：进程是操作系统调度和分配资源的最小单位，线程是CPU调度的最小单位。不同的进程之间是不共享内存的。进程之间的数据交换和通信的成本是很高。不同的线程是共享同一个进程的内存的。当然不同的线程也有自己独立的内存空间。对于方法区，堆中的同一个对象的内存，线程之间是可以共享的，但是栈的局部变量永远是独立的。

2.什么是并发与并行？

（1）并行（parallel）：指两个或多个事件在同一时刻发生（重点：在同时发生）。指在同一时刻，有多条指令在多个处理器上同时执行。

（2）并发（concurrency）：指两个或多个事件在同一个时间段内发生（重点：在同一时段）。指在同一个时刻只能有一条指令执行，但多个进程的指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。

对比并行与并发，我们会发现两者主要差异是在时间这个概念上，还是比较好理解的。

3.什么是线程调度？

线程调度一般的分为两种：一是分时调度、二是抢占式调度（下面的案例都是围绕这种情况讲）。

（1）分时调度：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

（2）抢占式调度：优先让优先级高的线程使用 CPU（这也是CPU高速切换的特点），如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

4.如何创建与启动线程呢？

4.1.main进程？

当Java程序编译好后进行运行，其实就存在一个线程，那就是main进程。如图所示：
在这里插入图片描述

4.2.怎么创建与启动多线程？

Java使用java.lang.Thread类就代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。

在JavaSE阶段，创建并启动多线程方式我们暂且需要常见的两种：继承Thread类和实现Runnable接口，后续在JavaEE高级阶段我会进行详细的说明。

方式一：继承Thread类{实现步骤}

（1）定义线程类，继承Thread类；

（2）重写父类Thread的run()方法（该方法代表了线程需要完成的任务,称为线程执行体）；

（3）创建Thread子类线程的实例（即创建线程对象）；

（4）调用线程对象的start()方法来启动该线程。

【1】代码实现如下：

package com.daxia.case1;

public class ThreadTest02 {

	public static void main(String[] args) {
		MyThread my = new MyThread();
		// 注意：我们不能手动调用run()，如果手动调用它，则就是普通的java对象调用方法，没有任何意义(即不能开启多线程)
		// my.run();

		// (1)用子类创建的对象调用start()方法（继承父类中的方法），则才是表示启动线程，实际上线程就把任务交给了操作系统的线程调度器进行管理与运行
		my.start();
		for (int j = 1; j < 10; j += 2) {
			try {
				Thread.sleep(2000);// 线程休眠设置2s
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("main线程：" + j);
		}
	}
}
class MyThread extends Thread {
	@Override
	public void run() {
		// 打印10以内的整数
		for (int i = 2; i <= 10; i += 2) {
			try {
				Thread.sleep(1000); // 线程休眠设置1s，方便观察打印的效果
			} catch (InterruptedException e) {

				e.printStackTrace();
			}
			System.out.println("打印10以内的整数线程：" + i);
		}
	}
}

说明：main线程与打印10以内的整数线程是并列的关系，执行没有先后顺序，线程是抢占式执行！，看打印结果：
打印10以内的整数线程：2
main线程：1
打印10以内的整数线程：4
打印10以内的整数线程：6
main线程：3
打印10以内的整数线程：8
打印10以内的整数线程：10
main线程：5
main线程：7
main线程：9

方式二：实现Runnable接口（一般使用它）{实现步骤}

Java的继承是单继承，当我们无法继承Thread类时，那么该如何做呢？在核心类库中就提供了Runnable接口，

（1）定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体；

（2）重写创建Runnable实现类的实例；

（3）并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象；

（4）调用线程对象的start()方法来启动线程。

【2】代码实现如下：

package com.daxia.case1;

public class RunnableTest03 {
	public static void main(String[] args) {
		MyRunnable my = new MyRunnable();
		/* 【1】my.start(); 错误一！my不能调用start()方法，因为该方法不是Runnable接口中的方法 */
		/*
		 * 【2】Thread t = new Thread(); 错误二！Thread构造器创建对象，在这里不对
		 * t.start();线程调度器，执行对象Theard对象的run()方法，
		 */
		// （1）应使用Thread(Runnable target)有参构造调用, 分配新的 Thread 对象。---参考API1.6文档
		Thread t = new Thread(my);// 线程调度器，执行了Thread对象的run(),但是Thread的run（）中，又调用了my的run（）
        //（2）分配新的 Thread 对象调用start()开启线程
		t.start();
		for (int j = 1; j < 10.; j += 2) {
			try {
				Thread.sleep(2000);// 线程休眠设置2s
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("main线程：" + j);
		}
	}
}
class Father {
}

class MyRunnable extends Father implements Runnable {
	@Override
	public void run() {
		for (int i = 2; i <= 10; i += 2) {
			try {
				Thread.sleep(1000); // 线程休眠设置1s，方便观察打印的效果
			} catch (InterruptedException e) {

				e.printStackTrace();
			}
			System.out.println("打印10以内的整数线程：" + i);
		}
	}

}

打印结果如下：
打印10以内的整数线程：2
main线程：1
打印10以内的整数线程：4
打印10以内的整数线程：6
main线程：3
打印10以内的整数线程：8
打印10以内的整数线程：10
main线程：5
main线程：7
main线程：9

【3】匿名内部类代码实现如下：

package com.daxia.case1;

public class AnonymousTest {
	public static void main(String[] args) {
		/*Thread方式一：
		 * Thread t = new Thread() {
			@Override
			public void run() {
				for (int j = 1; j < 10; j += 2) {
					System.out.println("main线程：" + j);
				}
			}
		};
		t.start();*/
		
		/*Thread方式二：
		 *new Thread() {
			@Override
			public void run() {
				for (int j = 1; j < 10; j += 2) {
					System.out.println("main线程：" + j);
				}
			}
		}.start();*/
		
		/*Runnable方式一：
		 * Runnable r = new Runnable(){
			@Override
			public void run() {
				for (int j = 1; j < 10; j += 2) {
					System.out.println("main线程：" + j);
				}
			}	
		};
		  new Thread(r).start();*/
		//Runnable方式二：
		  new Thread(new Runnable() {
		 
		  @Override public void run() { for (int j = 1; j < 10; j += 2) {
		 System.out.println("main线程：" + j); } } }).start();
		 
		for (int i = 2; i < 10; i += 2) {
			System.out.println("打印10以内的整数线程：" + i);
		}
	}
}

说明：【3】实现原理与【1】【2】一样，匿名内部类在一定程度上简化了代码，提高了编码效率！

推荐阅读往期博文：

•JavaSE高级应用#多线程入门基础#Thread类的构造方法与常用方法

#轻松一刻

在这里插入图片描述

☝上述分享来源个人总结，如果分享对您有帮忙，希望您积极转载；如果您有不同的见解，希望您积极留言，让我们一起探讨，您的鼓励将是我前进道路上一份助力，非常感谢！我会不定时更新相关技术动态，同时我也会不断完善自己，提升技术，希望与君同成长同进步！

☞本人博客：https://coding0110lin.blog.csdn.net/ 欢迎转载，一起技术交流吧！

CRUD_CODER_LIN

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
多线程入门基础#继承Thread类和实现Runnable接口两种方式启动线程

JavaSE高级应用-【多线程基础】两种启动线程的方式【分享要点】✔进程与线程的区别✔并发与并行的区别✔线程的调度问题✔线程的创建与启动【要点总结】试想一下，之前我们在设计程序的时候，在没有跳转语句情况下，程序都是至上而下的执行的，现在需要设计出这样的一个程序，功能需求是可以边听歌边发邮件，在这种场景下，我们就应该想到多线程或者多进程的技术来解决问题。之所以线程问题被划分在Jav...
复制链接

扫一扫