28_3多线程【线程与进程、线程的优先级别、自定义名称、休眠】

程序奇男子

已于 2024-07-11 14:54:05 修改

阅读量975

点赞数 15

分类专栏： JavaSE 文章标签： java 开发语言学习多线程

于 2024-03-18 20:35:44 首次发布

本文链接：https://blog.csdn.net/gangain/article/details/136784377

版权

JavaSE 专栏收录该内容

52 篇文章 1 订阅

订阅专栏

day28下2

多线程

一、什么是进程

进程是系统进行资源分配和调用的独立单元，每一个进程都有它的独立内存空间和系统资源。

二、单进程操作系统和多进程操作系统的区别

单进程操作系统：dos（一瞬间只能执行一个任务）

多进程单用户操作系统：Windows（一瞬间只能执行多个任务）

多进程多用户操作系统：Linux（一瞬间只能执行多个任务）

三、现在的多核CPU是否可以让系统在同一个时刻可以执行多个任务吗？

理论上是可以的
实际上：由于多个进程的多种状态，出现的情况较少

四、什么是线程，理解线程和进程的关系

什么是线程？

线程是进程里面的一条执行路径，每个线程同享进程里面的内存空间和系统资源

一个进程可以有多个线程：各个线程都有不同的分工

理解线程和进程的关系

进程与进程之间的关系：进程之间的内存空间和系统资源是独立的

同一个进程里的多条线程：线程之间的内存空间和系统资源是共享的

进程里：可以有一条或一条以上的线程

进程里只有一条线程的情况下，这条线程就叫做主线程

进程里有多条线程的情况下，只有一条线程叫做主线程

Ps：线程是在进程里的，他们是包含关系
补充：一个test类里面的有main方法，主线程在JVM（Java虚拟机）调用main方法，我们就可以在主线程的代码中创建子线程
ps：mian伪代码理解图

理解图
手画进程、线程理解图
并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。
理解：并发:任务在同一时间段内交替进行,如时间片轮转。并行:任务在同一时刻真正同时进行

五、我们应用的软件有哪些是多线程的应用？

都是

六、Java中，如何来编写多线程的应用程序？有哪些方法？

1.线程类

创建MyThread类，继承Thread，重写run方法

步骤：
1.创建线程类（MyThread），继承Thread，重写run方法
2.创建子线程 – MyThread t = new MyThread();
3.启动线程 ---- t.start();

public class Test01 {
	
	public static void main(String[] args) {
		
		//创建线程的对象
		MyThread t = new MyThread();
		//启动线程
		t.start();
	}
}
//线程类
class MyThread extends Thread{
	
	//当前线程抢到cpu资源后，就会执行run方法
	@Override
	public void run() {
		System.out.println("MyThread类中的run方法被调用了");
	}
}

2.任务类

创建Task类，实现Runnable接口中的run方法

步骤：

1.创建任务类（Task），实现Runnable接口中的run方法

2.创建任务类对象 – Task task = new Task();

3.创建子线程，并把任务交给他 – Thread t = new Thread(task);

4.启动线程 – t.start();

public class Test01 {
	
	public static void main(String[] args) {
		
		Thread t = new Thread(new Task());
		t.start();
	}
}
//任务类
class Task implements Runnable{

	//当前线程抢到cpu资源后，就会执行run方法
	@Override
	public void run() {
		System.out.println("Task类中的run方法被调用了");
	}
}

3.带返回值的任务类

4.线程池

七、感受多线程之间争抢资源的场景

需求：编写一个多线程的应用程序，主线程打印1-100之间的数字，子线程打印200-300之间的数字，观察其输出的结果，体会多线程互相争抢资源的场景

public class Test01 {
	public static void main(String[] args) {
		
		MyThread t = new MyThread();
		t.start();
		
		for (int i = 1; i <= 100; i++) {
			System.out.println("主线程：" + i);
		}
	}
}

public class MyThread extends Thread{

	@Override
	public void run() {
		for (int i = 200; i <= 300; i++) {
			System.out.println("子线程：" + i);
		}
	}
}
//随机一次输出：
主线程：1
主线程：2
子线程：200
子线程：201
子线程：202
子线程：203
子线程：204
主线程：3
主线程：4
    .....

八、小结

进程与进程的关系：独享内存空间和系统资源

线程与进程的关系：有一个进程中至少包含一个线程

线程与线程的关系：在同一个进程里，多个线程共享内存空间和系统资源

一个进程中包含多个线程，只有一个主线程

经典面试题：请问当我们编写一个单纯的main方法时，此时该程序是否为单线程的？为什么？
1.编写一个单纯的main方法时，‌该程序默认是单线程的。‌
在Java中，‌main方法是程序的入口点，‌它启动了一个主线程来执行程序。‌

2.一个单纯的main方法执行时是多线程的，‌包括主线程和垃圾回收线程等
垃圾回收器是一个后台线程

九、线程的优先级别

含义：

给线程定义抢到CPU资源的优先级

理解：
1.优先级别：1~10，数字越大，优先级越高
2.线程的优先级别不能决定线程是否优先抢到资源，优先级别只能影响（概率问题）

随机一次输出：

A：1
A：2
A：3
C：1
B：1
B：2

…

需求：在主线程中创3个子线程，并且设置不同优先级，观察其优先级对线程执行结果的”影响”。

a.setPriority(Thread.MAX_PRIORITY);//10
b.setPriority(Thread.NORM_PRIORITY);//5
c.setPriority(Thread.MIN_PRIORITY);//1
Thread定义了三个级别，所有这里我们使用他自定义的来代替数字

public class A extends Thread{
	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("A：" + i);
		}
	}
}
//同理B、C
public class Test01 {
	public static void main(String[] args) {
		
		A a = new A();
		B b = new B();
		C c = new C();
		
		//设置优先级别
		a.setPriority(Thread.MAX_PRIORITY);//10
		b.setPriority(Thread.NORM_PRIORITY);//5
		c.setPriority(Thread.MIN_PRIORITY);//1
		
		a.start();
		b.start();
		c.start();
		
	}
}

十、给线程自定义名称

自己写getThreadName/setThreadName
调用父类的一个参数的构造方法和getName
Thread.currentThread().getName()

作用理解：多个线程功能一样，名字不一样就可以给其取名称
以优先级为基础代码编写观察

//自己写
public class MyThread extends Thread{
	
	private String threadName;
	
	public MyThread(String threadName) {
		this.threadName = threadName;
	}

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println(threadName + "：" + i);
		}
	}
}
//调用父类
public class MyThread extends Thread{
	
	public MyThread(String name) {
		super(name);
	}

	@Override
	public void run() {
		
		//获取当前线程对象
		Thread t = Thread.currentThread();
		
		for (int i = 1; i <= 100; i++) {
			System.out.println(t.getName() + "：" + i);
		}
	}
}

public class Test01 {
	public static void main(String[] args) {
		
		MyThread a = new MyThread("A");
		MyThread b = new MyThread("B");
		MyThread c = new MyThread("C");
		
		//设置优先级别
		a.setPriority(Thread.MAX_PRIORITY);//10
		b.setPriority(Thread.NORM_PRIORITY);//5
		c.setPriority(Thread.MIN_PRIORITY);//1
		
		a.start();
		b.start();
		c.start();
		
	}
}

十一、让线程休眠

需求：编写一个抽取学员回答问题的程序，要求倒数三秒后输出被抽中的学员姓名

Thread.sleep(1000);

此方法为静态方法，写在哪个线程中，哪个线程就休眠

	public static void main(String[] args) throws InterruptedException {
		
		String[] names = {"东邪","西毒","南帝","北丐","小小","大大","奇男子"};
		
		Random random = new Random();
		int index = random.nextInt(names.length);
		
		for(int i = 3;i>0;i--){
			System.out.println(i);
			
			//Thread的静态方法 -- sleep(毫秒)，表示让当前线程休眠
			Thread.sleep(1000);
		}
		
		System.out.println(names[index]);
	}