线程

最新推荐文章于 2024-05-01 09:15:00 发布
最新推荐文章于 2024-05-01 09:15:00 发布
阅读量87 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenxiaoba/article/details/108563323
版权

进程与线程

一个程序至少有一个进程，一个进程至少有一个线程。
线程的划分尺度小于进程，使得多线程程序的并发性高。
进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
在Java中，每次程序运行至少启动2个线程：

1.main主线程
2.垃圾收集线程

两种主要的并发情况

IO流阻塞：数据读写，是可以调剂资源的；可以尽可能的拆分线程。
运算阻塞：一次不可以中断的阻塞，是系统无法在运算结束之前调剂资源的阻塞方式；最多阻塞的数量相当于CPU的内核数。要尽可能的避免出现运算阻塞这种情况

线程的创建

线程创建的2种方式

  1. 继承Thread：要通过重写或者实现run方法来完成线程的主体功能
public class ThreadCreateTest {
   public static void main(String[] args) {
   	Thread t = new InheritThread();
   	t.start();
   }
}

class InheritThread extends Thread {
   @Override
   public void run() {
   	System.out.print("继承Thread创建了线程");
   }
}

运行结果：

继承Thread创建了线程

  1. 实现Runnable：要通过重写或者实现run方法来完成线程的主体功能
public class ThreadCreateTest {
   public static void main(String[] args) {
   	Thread t = new Thread(new RunnableIpl());
   	t.start();
   }
}

class RunnableIpl implements Runnable{
   @Override
   public void run() {
   	System.out.println("实现Runnable类创建了线程");
   }
}

执行结果：

实现Runnable类创建了线程

其他说明

1.每一个线程都有一个属于自己独立的执行序列
2.main方法属于主线程；而自己创建的属于子线程
3.线程还可以分为用户线程和守护线程：用户线程是必须执行完的线程；当用户线程执行完以后，无论守护线程是否执行完，都立即停止
4.线程的启动时通过start()方法来启动，而不是通过调用run()方法来启动！
5.继承Thread创建线程时，不会强制要求重写run方法，实现Runnable时则必须重写run方法
6.每个线程都有一个调用栈，每创建一个新的线程，就产生一个新的调用栈

设置线程名称、获取当前线程

设置线程名称：t.setName(String name)
获取当前线程：Thread t = Thread.currentThread()

public class ThreadCreateTest {
	public static void main(String[] args) {
		Thread t = new Thread(new RunnableIpl());
		t.setName("金盏花");
		t.start();
	}
}

class RunnableIpl implements Runnable{
	@Override
	public void run() {
		System.out.println("实现Runnable类创建了线程");
		Thread t = Thread.currentThread();
		System.out.println(t.getName());
	}
}

执行结果

实现Runnable类创建了线程
金盏花

注：线程默认名称：Thread-0 …… n

线程栈

public class ThreadStack {
	public static void main(String[] args) {
		System.out.print("此处主线程执行");
		test();
	}
	
	static void test() {
		Thread t = new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.print("此处子线程执行");
			}
		});
		t.start();
	}
}

说明：
程序运行ThreadStack的main方法时，系统分配线程栈1给主线程，线程栈1将main压入栈中，主线程运行到test方法时，会将test压入线程栈1中，test运行时，创建了线程，系统分配桟2给test创建的线程，桟2将run方法压入栈中
线程栈

等待

方法说明
void wait()导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法。
void notify()唤醒在此对象监视器上等待的单个线程。
void notifyAll()唤醒在此对象监视器上等待的所有线程。

注意：

1.通过对象来进行调度
2.必须在同步状态下才可以等待
在这里插入图片描述
在这里插入图片描述

等待的生命周期

a.创建实例
b.准备就绪
c.运行（即start）时，会获取锁，持有锁之后，等待系统分配资源，获取资源运行相关内容，运行途中因为某些原因，线程进入等待（wait）时，会释放锁
d.线程等待时间到/被唤醒时，线程需要再次获取锁，然后进入就绪状态，获得资源执行后面的内容，执行完成后，会释放锁

休眠

1)任何地方都可以休眠
2)调用Thread的sleep方法进行休眠
3)休眠不可唤醒，只可以时间到自己醒
4)休眠如果在同步状态下，是不会释放锁的
生命周期：

a.创建实例
b.准备就绪
c.运行----->休眠---->时间到---->就绪状态---->运行

优先级

不要用！不靠谱，不推荐，不指望！
1)线程的优先级在1-10直接
2)10最高，1最低
3)不靠谱，不能指望
4)让步是让当前正在运行的线程，直接回到可运行状态，重新抢资源

线程的合并

1)Join：让一个线程加入到另一个线程之后，顺序执行
2)先start再join
3)join类似于sleep，在前一个线程执行之后执行；调用了join以后，依然会回到可执行状态
4)可以指定时间，前面一个线程如果执行时间过长，那么合并线程指定时间到了以后立即执行。

public class ThreadStack {
	public static void main(String[] args) throws Exception{
		System.out.println("此处主线程执行");
		Thread t1 = new ThreadTest();
		t1.start();
		t1.join();
		Thread t2 = new ThreadTest();
		t2.start();
		t2.join();
		Thread t3 = new ThreadTest();
		t3.start();
		t3.join(1000);
		Thread t4 = new ThreadTest();
		t4.start();
		t4.join();
		Thread t5 = new ThreadTest();
		t5.start();
		t5.join();
	}
}

class ThreadTest extends Thread{
	@Override
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName());
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

执行结果：

此处主线程执行
Thread-0
Thread-1
Thread-2
Thread-3
Thread-4

线程的生命周期

线程生命周期
一旦线程启动，它就永远不能再重新启动。只有一个新的线程可以被启动，并且只能一次。
线程生命周期如下：

1.创建线程实例；
2.调用start方法，让线程变为可执行状；
3.等待系统分配资源
4.有资源之后，进入运行状态
5.run方法执行结束，中途没有任何阻塞情况（线程被调度），那么该线程生命周期结束

同步与锁

概念：线程同步指的是，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作。
多线程访问同一个资源会产生线程安全问题，所以需要进行加锁。
每个锁在同一时刻，只能由一个线程持有。
方法或声明执行期间，如程序遇到任何异常或return，线程都会释放锁。
1.多个线程未加锁

public class LockObject {
	public static void main(String[] args) {
		for(int i = 0; i < 10000; i++) {
			new Thread(new ThreadTest1()).start();
		}
	}

}

class ThreadTest1 implements Runnable{
	@Override
	public void run() {
		MathOpera.getMathOpera().add();
	}
}

class MathOpera{
	public MathOpera() {}
	private static MathOpera m = new MathOpera();
	public static MathOpera getMathOpera() {
		return m;
	}
	
	int num = 0;
	public void add() {
		num++;
		System.out.println("增加后的值：" + num);
	}
}

按照平时理解的逻辑，for(int i = 0; i < 10000; i++) {…}执行了10000次，num最后应该是10000，但实际上num可能不是10000，因为有些线程可能获取到了同样的num，将num加1后的值赋值过去，相当于执行了至少2次同样的值加1

…
增加后的值：9986
增加后的值：9987
增加后的值：9988
增加后的值：9989
增加后的值：9990
增加后的值：9991
增加后的值：9992
增加后的值：9993
增加后的值：9994
增加后的值：9995
增加后的值：9996

synchronized：在需要同步的对象中加入此控制，synchronized可以加在方法上，也可以加在特定代码块中，都是锁对象
锁在方法上：

class MathOpera{
	public MathOpera() {}
	private static MathOpera m = new MathOpera();
	public static MathOpera getMathOpera() {
		return m;
	}
	
	int num = 0;
	public synchronized void add() {
		num++;
		System.out.println("增加后的值：" + num);
	}
}

执行结果：

…
增加后的值：9993
增加后的值：9994
增加后的值：9995
增加后的值：9996
增加后的值：9997
增加后的值：9998
增加后的值：9999
增加后的值：10000

锁代码块：

class MathOpera{
	public MathOpera() {}
	private static MathOpera m = new MathOpera();
	public static MathOpera getMathOpera() {
		return m;
	}
	
	int num = 0;
	public void add() {
		synchronized(this) {
			num++;
		}
		System.out.println("增加后的值：" + num);
	}
}

执行后结果：

…
增加后的值：9994
增加后的值：9995
增加后的值：9996
增加后的值：9997
增加后的值：9998
增加后的值：9999
增加后的值：10000

一般而言，锁方法比较霸道，方法被锁了之后，其他线程都只能等待当前线程释放锁之后才能执行，但方法中有部分内容是不需要安全控制的，相当于上厕所时，有人将厕所的大门给关了，其他人进不了厕所，但是你只用到厕所的一个隔间，其他你用不到，锁代码块就相当于锁隔间，其他隔间其他人去使用。一般是找有共享数据修改的代码块来上锁。

实例方法可以通过锁对象控制线程，但是静态方法是不根据对象存在，是在类里的，如果静态方法需要枷锁，可以通过锁类来达到目的
静态方法add里加入对象的同步锁时，可以看到，编译错误：
在这里插入图片描述

锁类之后：

public class LockClass {
	public static void main(String[] args) {
		for(int i = 0; i < 1000; i++) {
			new Thread(new ThreadTest2()).start();
		}
	}
}

class ThreadTest2 implements Runnable{
	@Override
	public void run() {
		new MathOperate().add();
	}
}

class MathOperate{
	static int addCount = 0;
	public static void  add() {
		synchronized(MathOperate.class) {
			addCount++;
			System.out.println("增加后的值：" + addCount);
		}
	}

}

执行结果：

…
增加后的值：988
增加后的值：989
增加后的值：990
增加后的值：991
增加后的值：992
增加后的值：993
增加后的值：994
增加后的值：995
增加后的值：996
增加后的值：997
增加后的值：998
增加后的值：999
增加后的值：1000

温小八
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 多线程原理深剖
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
系统线程（内核线程）和用户线程区别 - 简书.pdf
04-29
"系统线程（内核线程）和用户线程区别" 系统线程（内核线程）和用户线程是两种不同的线程模式，它们在实现和应用方面有很大的区别。 系统线程（内核线程）是由操作系统内核创建和撤销的线程，内核维护进程及线程的...
【多线程与高并发】- synchronized锁的认知
热门推荐
qq_43843951的博客
02-19 22万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
JAVA线程
互联网底层民工的博客
06-26 9385
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。
Linux线程详解
小虾米编程
06-03 3万+
并行和并发的区别 1. 并发(concurrency)：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。其中两种并发关系分别是同步和互斥。（并发是指同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上有多个进程被同时执行的效果--宏观上并行，针对单核处理器） 互斥：进程间相互排斥的使用临界资源的现象，就叫互斥。 ...
Java多线程之线程安全问题
trong_ 的烂笔头
12-26 6009
Java多线程中的线程安全问题, 解决方法, 线程安全和不安全的标准类.
多线程 join 方法
Gonelin的博客
12-22 6254
多线程 join 方法 1.前言 本节对 join 方法进行深入的剖析，主要内容点如下： 了解 join 方法的作用，初步的理解 join 方法的使用带来的效果是学习本节内容的基础； 了解 join 方法异常处理，我们在使用 join 方法是，需要对 join 方法进行有效的异常处理； 通过匿名内部类创建Thread 是我们本节代码示例所使用的的方式，对这种方式的掌握在后续工作中非常重要； 掌握 join 方法如何使用，这是本节的重点内容，也是本节的核心内容； 掌握带参数的 join 方法使用，在后续开发
多线程——线程的退出
glory的博客
09-24 4040
一般来说，一个线程的退出，有多种方式： 1.return方式/exit/_exit 2.利用pthread_exit退出 3.利用phread_cancel 退出以下几种方式均可以让线程退出，但是相互间也是有区别的，下面通过实例来演示。 pthread_exit函数用于实现线程退出 头文件#include<pthread.h> 函数原型void pthread_exit(void *retval); 无返回值 参数列表 void *retval：返回的参数NULL ...
探索Java线程副本技术：深入理解与实践ThreadLocal
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
05-01 3万+
ThreadLocal作为Java线程副本技术的核心实现，为多线程编程提供了强大的线程隔离能力。深入理解其工作原理、掌握正确的使用方法、关注潜在问题及最佳实践，将有助于开发者在复杂并发场景下编写高效、安全、易于维护的代码。
全面详解Android实现多线程的几种方式（史上最全，最详细）
恬静释然的博客
11-19 4万+
一、目录 Android多线程实现方式包括： 二、基础使用 Android多线程实现的基础使用包括： 继承Thread类 实现Runnable接口 Handler 接下来对各个进行分析。 1、继承Thread类 1.1 简介 1.2 使用详解 （1）使用步骤 （2） 具体使用 // 步骤1：创建线程类 （继承自Thread类） class MyThread extends Thr...
Java守护线程
春风化雨
10-09 2062
1、什么是守护线程 Java线程分两种：用户线程和守护线程。 守护线程，是指在程序运行的时，后台提供一种通用服务的线程。比如垃圾回收线程就是一个很称职的守护者，并且这种线程并不属于程序中不可或缺的部分。因此，当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程。反过来说，只要任何非守护线程还在运行，程序就不会终止。 守护线程和用户线程的没有本质的区别，不同之处在于虚拟机的离开；若用户线程已全部退出运行，只剩守护线程存在，虚拟机也即退出。 因没有了被守护者，守护线程也就无工作可做，也
C++ 线程暂停、继续
12-18
在C++编程中，多线程技术是一种常见且强大的并发执行方式，特别是在处理大量数据、实时计算或异步任务时。Visual Studio 2019 提供了对C++11标准库的支持，其中包含了对多线程编程的API。在本项目"线程暂停、继续"中...
C# 跨线程访问UI线程控件
01-20
在C#中，由于使用线程和调用UI的线程属于两个不同的线程，如果在线程中直接设置UI元素的属性，此时就会出现跨线程错误。    下面介绍两种解决方案  第一种：使用控件自带的Invoke或者BeginInvoke方法。 Task....
stm32单片机多线程实例
12-03
多线程是实现复杂任务并发执行的关键技术，能够提高资源利用率，优化系统响应时间。在STM32上实现多线程，通常会借助实时操作系统（RTOS）如RT-Thread。 RT-Thread是一个轻量级、开源的实时操作系统，它为STM32等微...
ｊａｖａ线程
09-28
程研究了线程的基础知识— 线程是什么、线程为什么有用以及怎么开始编写使用线程的简单 程序。 我们还将研究更复杂的、使用线程的应用程序的基本构件— 如何在线程之间交换数据、如何控制 线程以及线程如何互相通信...
计算机网络实验三：UDP协议探索和分析
最新发布
08-24
【实验目的】 1、掌握UDP协议数据格式； 2、掌握UDP首部各字段含义； 3、了解网卡offload技术； 4、熟悉Linux下nc命令的使用方法。
基于springboot和vue的 一站式家装服务管理系统 源码 （优秀毕业设计源码）
08-24
1. 一站式家装服务管理系统 代码说明：经导师指导并认可通过的98分毕设项目代码。 2.适用对象：本代码学习资料适用于计算机、电子信息工程、数学等专业正在做毕设的学生，需要项目实战练习的学习者，也适用于课程设计、期末大作业。 3.技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 4. 作者介绍：大厂码农，java领域创作者，阿里云开发社区乘风者计划专家博主，专注于大学生项目实战开发，文章底部有博主联系方式，更多优质系统、项目定制请私信。 5. 最新计算机软件毕业设计选题大全: https://blog.csdn.net/weixin_45630258/article/details/135901374
Linux教程-磁盘相关-分区-文件系统-挂载-软连接硬连接.zip
08-24
涵盖了Linux系统管理的核心概念和技能。包含加密文件的知识点，逐步深入到磁盘分区的基础知识（分为两部分详细讲解），进而探讨文件系统和挂载的原理。教程还包括对挂载信息的详细解读，以及磁盘空间耗尽的两种常见情况分析。此外，重点讲解了软连接和硬链接的区别，并提供了额外的补充材料以加深理解。适合Linux初学者和系统管理员提升对文件系统管理、磁盘空间优化和链接应用的实战能力。
java源码资源一个支持servlet的web服务器
08-24
java源码资源一个支持servlet的web服务器提取方式是百度网盘分享地址
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值