进程及线程的常用方法

最新推荐文章于 2024-08-10 09:00:00 发布
最新推荐文章于 2024-08-10 09:00:00 发布
阅读量293 收藏 1
点赞数 1
分类专栏： Java基础 文章标签： java 数据结构 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GL280599ZL/article/details/127599958
版权

进程及线程的常用方法

一、进程

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

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

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

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

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

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

理论上是可以的

四、线程

1.线程的介绍

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

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

2.线程和进程的关系

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

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

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

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

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

注意：线程是在进程里的，他们是包含关系

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

微信、QQ、支付宝、淘宝等等都是

六、Java中编写多线程

1.创建线程的方式 – 线程类

1.创建线程类：

1.创建类 – MyThread

2.继承Thread

3.重写run方法

2.启动线程：

1.创建线程类的对象：MyThread t = new MyThread();

2.启动线程：t.start();

public class Test01 {

	public static void main(String[] args) {
		
		//创建子线程
		MyThread t = new MyThread();
		
		//启动线程
		t.start();
	}
}

public class MyThread  extends Thread{

	//线程对象抢到CPU资源后才调用的方法
	//run方法的作用：该线程的功能都是编写在run方法中
	@Override
	public void run() {
		System.out.println("调用MyThread中的run()");
	}
}

2.创建线程的方式 – 任务类

1.创建任务类：

1.创建Task类

2.实现Runnable接口

3.重写run方法

2.启动线程：

1.创建线程对象：Thread t = new Thread(new Task());

2.启动线程：t.start();

public class Test01 {

	public static void main(String[] args) {
		
		//创建子线程(并将任务对象交给线程)
		Thread t = new Thread(new Task());
		
		//启动线程
		t.start();
	}
}

//任务类
public class Task implements Runnable {

	//线程对象抢到CPU资源后调用的方法
	//run方法的作用：该线程的功能都是编写在run方法中
	@Override
	public void run() {
		System.out.println("调用Task类中的run()");

	}

}

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

需求：编写一个多线程的应用程序，主线程打印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);
		}
	}
}

八、线程的优先级别

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

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();
	}
}

public class A extends Thread{

	@Override
	public void run() {
	for (int i = 1; i <= 500; i++) {
		System.out.println("A:" + i);
	 }
	}
}

public class B extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 500; i++) {
			System.out.println("B：" + i);
		}
	}
}


public class C extends Thread {

	@Override
	public void run() {
		for (int i = 1; i <= 500; i++) {
			System.out.println("C：" + i);
		}
	}
}

九、线程的命名

1.方案一

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();
	}
}


public class MyThread extends Thread{

	private String threadName;

	public MyThread(String threadName) {
		this.threadName = threadName;
	}
	
	@Override
	public void run() {
		for (int i = 1; i <= 500; i++) {
			System.out.println(threadName + ":" + i);
		}
	}	
}

2.方案二

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();
	}
}


public class MyThread extends Thread {

	public MyThread(String name){
		super(name);
	}
	
	@Override
	public void run() {
		// 获取当前线程的对象
		Thread thread = Thread.currentThread();
		
		for (int i = 1; i <=500; i++) {
			System.out.println(thread.getName() + "：" + i);
		}
	}
}

十、线程休眠

1.Thread.sleep(1000); – Thread类的静态方法

2.该方法写在哪个线程中，哪个线程就休眠(进入到阻塞状态)

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

import java.util.Random;

public class Test01 {

	public static void main(String[] args) throws InterruptedException{
		
		String[] names = {"孙权","周瑜","大乔","小乔","诸葛瑾"};
		
		Random ran = new Random();
		int index = ran.nextInt(names.length);
		
		for (int i = 3; i > 0; i--) {
			System.out.println(i);
			
			Thread.sleep(1000);
		  }
		
		System.out.println(names[index]);
	}
}

十一、线程的礼让

需求：创建两个线程A,B，分别各打印1-100的数字，其中B一个线程，每打印一次，就礼让一次，观察实验结果

public class Test01 {

	public static void main(String[] args) {
		
		A a = new A();
		B b = new B();
		
		a.start();
		b.start();
	}
}


public class A extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100 ; i++) {
			System.out.println("A：" + i);
	   }
	}	
}


public class B extends Thread {

	@Override
	public void run() {
		for (int i = 1; i <= 100 ; i++) {
			System.out.println("B：" + i);
			
			//礼让：让当前线程退出CPU资源，马上又进入到抢资源的状态
			Thread.yield();
		}
	}
}

十二、线程的合并

需求：主线程和子线程各打印200次，从1开始每次增加1，当主线程打印到10之后，

让子线程先打印完再打印主线程

public class Test01 {

	public static void main(String[] args) throws InterruptedException{
		
		MyThread t = new MyThread();
		t.start();
		
		for (int i = 1; i <=200; i++) {
			System.out.println("主线程：" + i);
			if (i == 10) {
				//合并
				t.join();
			}
		}
	}
}


public class MyThread extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 200; i++) {
			System.out.println("子线程：" + i);
		}
	}
}

十三、线程的中断

使用MyThread中的flag属性去控制

1.方案一

public class Test01 {

	public static void main(String[] args) throws InterruptedException{
		
		MyThread t = new MyThread();
		t.start();
		
		Thread.sleep(3000);
		
		//立即中断线程
		//t.stop();//淘汰使用
		
		t.setFlag(false);
	}
}


public class MyThread extends Thread{

	private boolean flag = true;

	public void setFlag(boolean flag) {
		this.flag = flag;
	}

	@Override
	public void run() {
		while(flag){
			System.out.println("111");
			System.out.println("222");
			System.out.println("333");
			System.out.println("444");
	   }
	}
}

2.方案二

public class Test01 {

	public static void main(String[] args) throws InterruptedException{
		
		MyThread t = new MyThread();
		t.start();
		
		Thread.sleep(3000);
		
		//改变线程状态
		t.interrupt();
	}
}


public class MyThread extends Thread{

	@Override
	public void run() {

		Thread thread = Thread.currentThread();
		
		while (!thread.isInterrupted()) {//判断当前线程是否中断
			
			System.out.println("111");
			System.out.println("222");
			System.out.println("333");
			System.out.println("444");
			
		}
	}
}

十四、守护线程

含义：守护线程默默守护着前台线程，当所有前台线程都死亡时，守护线程就会自动死亡

注意：垃圾回收器就是守护线程

t.setDaemon(true);

public class Test01 {

	public static void main(String[] args) throws InterruptedException{
		
		MyThread t = new MyThread();
		t.setDaemon(true);
		t.start();
		
		for (int i = 1; i <=5; i++) {
			System.out.println("主线程：" + i);
			Thread.sleep(1000);
		}
	}
}

//做实验
//父类方法如果不抛异常，子类重写时就不能抛异常，必须try...catch...
class A{
	public void method(){}
}
class B extends A{
	
	@Override
	public void method(){
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}


public class MyThread extends Thread{

	@Override
	public void run() {
		while (true) {
			System.out.println("守护线程正在守护着前台线程");
			
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

十五、线程局部变量（实现线程范围内的共享变量）

1.共享单个数据

public class Test01 {

	public static void main(String[] args) {
		
		//线程1
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				int i = 10;
				
				//存储数据
				Container.map.put(Thread.currentThread(),i);
				
				A a = new A();
				B b = new B();
				a.println();//线程1中的A类对象输出：10
				b.println();//线程1中的B类对象输出：10
			}
		},"线程1").start();
		
		//线程2
		new Thread(new Runnable() {
			@Override
			public void run() {
				int i  = 20;
				
				//存储数据
				Container.map.put(Thread.currentThread(),i);
				
				A a = new A();
				B b = new B();
				a.println();//线程2中的A类对象输出：20
				b.println();//线程2中的B类对象输出：20
				
			}
		},"线程2").start();
	}
}


import java.util.concurrent.ConcurrentHashMap;

public class Container {
	public static final ConcurrentHashMap<Thread, Integer> map = new ConcurrentHashMap<>();
}


public class A {

	public void println(){
		
		Thread thread = Thread.currentThread();
		Integer value = Container.map.get(thread);
		
		System.out.println(thread.getName() + "中的A类对象输出：" + value);
	}
}


public class B {

public void println(){
		
		Thread thread = Thread.currentThread();
		Integer value = Container.map.get(thread);
		
		System.out.println(thread.getName() + "中的B类对象输出：" + value);
	}
}

2.共享多个数据

public class Test01 {

	public static void main(String[] args) {
		
		//线程1
		new Thread(new Runnable() {
			@Override
			public void run() {
				
				Data data = new Data("xxx",10);
				//存储数据
				Container.map.put(Thread.currentThread(),data);
				
				A a = new A();
				B b = new B();
				a.println();//线程1中的A类对象输出：10
				b.println();//线程1中的B类对象输出：10
			}
		},"线程1").start();
		
		//线程2
		new Thread(new Runnable() {
			@Override
			public void run() {
				Data data = new Data("yyy",20);
				//存储数据
				Container.map.put(Thread.currentThread(),data);
				
				A a = new A();
				B b = new B();
				a.println();//线程2中的A类对象输出：20
				b.println();//线程2中的B类对象输出：20
			}
		},"线程2").start();
	}
}


import java.util.concurrent.ConcurrentHashMap;

public class Container {

	public static final ConcurrentHashMap<Thread, Data> map = new ConcurrentHashMap<>();
}


public class A {

	public void println(){
		
		Thread thread = Thread.currentThread();
		Data value = Container.map.get(thread);
		
		System.out.println(thread.getName() + "中的A类对象输出：" + value);
	}
}


public class B {

public void println(){
		
		Thread thread = Thread.currentThread();
		Data value = Container.map.get(thread);
		
		System.out.println(thread.getName() + "中的B类对象输出：" + value);
	}
}

3.使用ThreadLocal的技术

public class Test01 {

	public static void main(String[] args) {
		
		//线程1
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				Data data = Data.getInstance("xxx",10);
				//存储数据
				Container.local.set(data);
				
				A a = new A();
				B b = new B();
				a.println();//线程1中的A类对象输出：10
				b.println();//线程1中的B类对象输出：10
				
			}
		},"线程1").start();
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				Data data = Data.getInstance("yyy",20);
				
				Container.local.set(data);
				
				A a = new A();
				B b = new B();
				a.println();//线程2中的A类对象输出：20
				b.println();//线程2中的B类对象输出：20
				
			}
		},"线程2").start();
	}
}


//容器类
public class Container {
	
	public static final ThreadLocal<Data> local = new ThreadLocal<>();
}


public class A {
	
    public void println(){
		
		Thread thread = Thread.currentThread();
		Data value = Container.local.get();
		
		System.out.println(thread.getName() + "中的A类对象输出：" + value);
		
	}
}


public class B {
	
public void println(){
		
		Thread thread = Thread.currentThread();
		Data value = Container.local.get();
		
		System.out.println(thread.getName() + "中的B类对象输出：" + value);
	}
}

十六、总结

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

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

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

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

5.垃圾回收器是一个后台线程

雨霖先森
关注
专栏目录
线程与进程使用详解
weixin_45461033的博客
09-23 1255
1.多线程 并发：指两个或多个事件在同一个时间段里发生 并行：指两个或多个事件在同一个时刻(同时发生)里发生 进程：是指一个内存中运行的内存程序，每个进程都有独立的内存空间，一个应用程序可以同时运行多个进程，进程也是程序的一次执行过程，是系统运行程序的基本单位，系统运行程序既是一个进程从创建，运行到消亡的过程。 简单来说，点击一个程序执行，进入到内存，占用一些内存来执行，这个进入内存的程序叫进程。 线程：是进程的执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，一个进程中也可以有多个线程，这个应
线程与进程及多线程实现
m0_58702068的博客
11-22 247
这里写目录标题线程与进程概述线程调度同步与异步并发与并行在JAVA中实现多线程程序线程创建方式一：继承Thread:线程创建方式二：实现Runnable实现Runnable与继承Thread相比有如下优势：Thread类第一看常用构造方法，用来创建一个线程：第二看常用的普通中常用的方法：设置和获取线程名称线程休眠sleep线程阻塞线程中断线程守护线程安全问题线程安全1—同步代码块线程安全2—同步方法线程安全3—显示锁Lock公平锁和非公平锁线程死锁 线程与进程概述 进程：一个进程指一个应用程序，每个进程都有
多进程和多线程
NKJNJK的博客
11-07 250
多进程和多线程 多线程 import time from datetime import datetime from threading import Thread # 进程默认有一个线程，这个线程叫主线程；其他的线程都叫子线程 # Python中的threading模块中Thread类的对象就是线程对象（程序中需要多少个线程就创建多少个Thread类或者它的子类的对象） def download(name): print(f'{name}开始下载！{datetime.now()}')
进程和线程
最新发布
2301_76161469的博客
08-10 1303
进程（Process）是操作系统提供的一种 "软件资源"，是操作系统对一个正在运行的程序的一种抽象，即，可以把进程看做程序的一次运行过程，进程依赖于程序运行而存在。线程，也可以称为 轻量级进程，在进程的基础上做出了改进，保持了 独立调度执行这样的 并发支持，同时省去了 分配资源、释放资源 带来的额外开销
【操作系统基础】进程管理（一）进程与线程的描述与控制
周二Show
07-07 560
一、进程的定义与特征 1. 进程的定义与特征 进程（Process）是资源分配的基本单位。进程是动态的，是程序的一次执行过程，同一个程序执行会对应多个进程。相反，程序是即是静态的，就是存放在磁盘里的可执行文件，就是一系列的指令集合。 2. 进程的组成 程序段、数据段、PCB三部分组成了进程的实体（进程映像），引入进程实体的概念后，可把进程定义为：进程是进程实体的运行过程，是系统进行资源分配和调度的一个独立单位。 2.1 PCB 当进程被创建时，操作系统会为该进程分配一个唯一的、不重复的“身份证号”——PID
进程线程
sansui77088的博客
04-22 142
1 进程 1.1 概念 进程就是正在运行的程序,它代表了程序所占用的内存区域 1.2 特点 独立性 进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间. 动态性 进程与程序的区别在于,程序只是一个静态的指令集合,而进程一个正在系统中活动的指令集合,程序加入了时间的概念以后,称为进程,具有自己的生命周期和各种不同的状态,这些概念都是程序所不具备的. 并发性 多个进程可以在单个处理器C
python线程安全及多进程多线程实现方法详解
09-18
Python中的线程安全和多进程多线程是并发编程中的重要概念，它们允许程序利用多核处理器的能力，提高系统的执行效率。线程安全是保证在多线程环境下，多个线程并发执行时不会出现数据不一致或竞态条件的问题。 线程...
进程线程及死锁
12-26
进程、线程、死锁和POSIX规范的系统调用 进程是操作系统中一个独立的执行单元，它拥有自己的虚拟地址空间和系统资源。线程是轻量级的进程，它共享同一个进程的虚拟地址空间和系统资源。理解进程和线程的概念对于...
【Java多线程学习1】什么是进程、线程，什么是并发、并行及线程的创建和线程的基本使用
weixin_43950588的博客
01-02 901
什么是线程、进程，什么是并发、并行及线程的创建和基本使用
线程的常用方法
chris__x的博客
03-22 200
run()和start() 这是多线程最常用的方法了，把需要并行处理的代码放在run()中，run方法必须是public权限，返回值为void。start()方法启动线程自动调用run()方法 public class Case3 { private static class A extends Thread{ @Override public void r...
C++ 进程与线程
qq_37464701的博客
03-22 1207
程序：就是磁盘上的可执行文件，并且只占用磁盘上的空间，是一个静态的概念。进程：被执行后的程序就叫做进程，不占用磁盘空间，需要消耗系统的内存，CPU资源，每个运行的进程都对应一个属于自己的虚拟地址空间。？？？后面有空去了解下？？？CPU时间片：CPU在某个时间点只能处理一个任务，但是操作系统都支持多任务的，那么在计算机CPU只有一个的情况下是怎么完成任务处理的？原理和古时候救济灾民的思路是一样的，每个人分一点，但是又不叫吃饱。
主线程、进程、线程、并发并行
Alla
11-07 251
1.进程 2.线程 3.主线程 主线程就是java 中main方法
进程与线程
qq_51263139的博客
04-18 957
进程与线程 讲线程之前要了解：进程间的通信（Inter-Process Communication IPC)： 理论上，进程之间是独立的，但实际上往往是多个进程之间的互相配合完成复杂的工作。例如：使用MySQL时，通过workbench进程和mysql服务器进程进行通信，来实现数据的增删查改。因此就有了进程之间交换数据的必要性。 问题是：OS进行资源分配是以进程为基本单位进行分配的，包括内存。分配给A进程的内存不会在分配给B进程。所以，进程之间通过内存来进行数据交换的可能性完全不存在。A,B进程之间被隔离
进程，线程，多进程，多线程以及主线程
maomao092092的专栏
06-28 872
进程与程序的区别          1. 进程是程序的执行，属于动态，程序是完成某个功能的指令的集合，是静态的         2.进程的存在是暂时的，程序的存在是永久的。         3.进程＝程序＋数据＋PCB (进程控制块，process control block)，即进程是一个程序及其数据在处理机上顺序地执行时所发生的活动。         4.一个程序可以对应多个进程
线程详解
qq_41181857的博客
07-29 216
线程概念 线程是一个进程内部的控制序列，是程序里的一个执行线路 一切进程至少都有一个执行线程，线程在进程内部运行，本质上是在进程的地址空间内运行。在CPU眼中，看到的PCB要比传统的进程更加轻量化。透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流。 总而言之，线程是在进程内部运行的一个执行流，Linux系统没有真正意义上的线程，而是用PCB模拟的。进程是承担分配系统资源的基本实体，线程是调度的基本单位。在线程组里面，所有的线程都是对等的关系，没有父线程的概念
进程以及进程间关系
Repaint_The_World的专栏
10-04 1041
进程是现代操作系统最为深刻的概念之一，它提供了运行中程序的抽象。一个进程指的是正在内存中运行的一个程序，任何程序都运行在进程的上下文中，进程的上下文包括虚拟的地址空间、独占的cpu以及寄存器等系统状态和系统资源。有了进程这一概念，程序员得以从硬件繁琐的细节中解脱出来，从而能够集中精力在应用程序的功能设计与实现上。 操作系统中最开始只有init一个进程，其后所有的进程都由它创建，称作子进程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

雨霖先森

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值