进程及线程的常用方法

最新推荐文章于 2024-05-17 13:43:01 发布
最新推荐文章于 2024-05-17 13:43:01 发布
阅读量246 收藏 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.垃圾回收器是一个后台线程

雨霖先森
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python多进程编程常用方法解析
12-20
python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU资源，在python中大部分情况需要使用多进程。python提供了非常好用的多进程包Multiprocessing，只需要定义一个函数，python会完成其它所有事情。...
多进程和多线程
NKJNJK的博客
11-07 204
多进程和多线程 多线程 import time from datetime import datetime from threading import Thread # 进程默认有一个线程，这个线程叫主线程；其他的线程都叫子线程 # Python中的threading模块中Thread类的对象就是线程对象（程序中需要多少个线程就创建多少个Thread类或者它的子类的对象） def download(name): print(f'{name}开始下载！{datetime.now()}')
线程与进程使用详解
weixin_45461033的博客
09-23 1181
1.多线程 并发：指两个或多个事件在同一个时间段里发生 并行：指两个或多个事件在同一个时刻(同时发生)里发生 进程：是指一个内存中运行的内存程序，每个进程都有独立的内存空间，一个应用程序可以同时运行多个进程，进程也是程序的一次执行过程，是系统运行程序的基本单位，系统运行程序既是一个进程从创建，运行到消亡的过程。 简单来说，点击一个程序执行，进入到内存，占用一些内存来执行，这个进入内存的程序叫进程。 线程：是进程的执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，一个进程中也可以有多个线程，这个应
【操作系统基础】进程管理（一）进程与线程的描述与控制
周二Show
07-07 510
一、进程的定义与特征 1. 进程的定义与特征 进程（Process）是资源分配的基本单位。进程是动态的，是程序的一次执行过程，同一个程序执行会对应多个进程。相反，程序是即是静态的，就是存放在磁盘里的可执行文件，就是一系列的指令集合。 2. 进程的组成 程序段、数据段、PCB三部分组成了进程的实体（进程映像），引入进程实体的概念后，可把进程定义为：进程是进程实体的运行过程，是系统进行资源分配和调度的一个独立单位。 2.1 PCB 当进程被创建时，操作系统会为该进程分配一个唯一的、不重复的“身份证号”——PID
进程线程
sansui77088的博客
04-22 117
1 进程 1.1 概念 进程就是正在运行的程序,它代表了程序所占用的内存区域 1.2 特点 独立性 进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间. 动态性 进程与程序的区别在于,程序只是一个静态的指令集合,而进程一个正在系统中活动的指令集合,程序加入了时间的概念以后,称为进程,具有自己的生命周期和各种不同的状态,这些概念都是程序所不具备的. 并发性 多个进程可以在单个处理器C
线程与进程及多线程实现
m0_58702068的博客
11-22 190
这里写目录标题线程与进程概述线程调度同步与异步并发与并行在JAVA中实现多线程程序线程创建方式一：继承Thread:线程创建方式二：实现Runnable实现Runnable与继承Thread相比有如下优势：Thread类第一看常用构造方法，用来创建一个线程：第二看常用的普通中常用的方法：设置和获取线程名称线程休眠sleep线程阻塞线程中断线程守护线程安全问题线程安全1—同步代码块线程安全2—同步方法线程安全3—显示锁Lock公平锁和非公平锁线程死锁 线程与进程概述 进程：一个进程指一个应用程序，每个进程都有
python如何控制进程或者线程的个数
12-16
今天简单总结两种常用的控制线程个数的方法。 方法一：进程池/线程池 如下例demo所示， 创建了一个大小是4的进程池，然后创建5个进程，并启动 from multiprocessing import Pool import os, time, random def ...
python多线程多进程的常用操作。
10-29
python多线程多进程的常用操作。包括 1. 调用进程 2. 进程池 3. 进程通信 Pipe,Queue 4. 调用线程 5. lock 6. threading.local() 在一个线程内，递归调用函数时，传递参数显得复杂，因此把参数保存在一个字典里，...
通过实例解析python创建进程常用方法
12-17
运行程序时，单线程或单进程往往是比较慢的，为加快程序运行速度，我们可以使用多进程，可以理解为多任务同时运行，小编的电脑是四核，所以可以设置四个进程。 下面，我们来了解下多进程的使用： 1、使用...
Python进程和线程
12-22
创建进程的常用方式3.1 使用multiprocessing创建进程3.2 使用Process子类创建进程3.3 使用进程池Pool创建进程4. 通过队列实现进程间通信4.1 进程间不共享全局变量4.2 队列简介4.3 多进程队列的使用4.4 使用队列在...
主线程、进程、线程、并发并行
Alla
11-07 216
1.进程 2.线程 3.主线程 主线程就是java 中main方法
进程与线程
qq_51263139的博客
04-18 883
进程与线程 讲线程之前要了解：进程间的通信（Inter-Process Communication IPC)： 理论上，进程之间是独立的，但实际上往往是多个进程之间的互相配合完成复杂的工作。例如：使用MySQL时，通过workbench进程和mysql服务器进程进行通信，来实现数据的增删查改。因此就有了进程之间交换数据的必要性。 问题是：OS进行资源分配是以进程为基本单位进行分配的，包括内存。分配给A进程的内存不会在分配给B进程。所以，进程之间通过内存来进行数据交换的可能性完全不存在。A,B进程之间被隔离
进程，线程，多进程，多线程以及主线程
maomao092092的专栏
06-28 825
进程与程序的区别          1. 进程是程序的执行，属于动态，程序是完成某个功能的指令的集合，是静态的         2.进程的存在是暂时的，程序的存在是永久的。         3.进程＝程序＋数据＋PCB (进程控制块，process control block)，即进程是一个程序及其数据在处理机上顺序地执行时所发生的活动。         4.一个程序可以对应多个进程
jar包增量更新分析
junlaiyan的专栏
05-16 253
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 617
本文主要提供用java实现的拼图小游戏源代码。
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 901
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
命令执行漏洞（二）
XLbb的博客
05-15 904
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构与算法(验证二叉搜索树)
最新发布
磐门的博客
05-17 245
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
进程和线程常用函数有哪些
07-09
进程和线程是操作系统中的重要概念，常用的函数有： 1. fork(): 创建一个新的进程，该函数会复制当前进程的副本，包括代码、数据和打开的文件等。在父进程中，该函数返回新创建进程的进程ID；在子进程中，该函数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

雨霖先森

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

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

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

打赏作者

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

抵扣说明：

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

余额充值