多线程

最新推荐文章于 2021-05-04 17:45:16 发布
最新推荐文章于 2021-05-04 17:45:16 发布
阅读量67 收藏
点赞数
分类专栏： JAVA类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43934912/article/details/99690935
版权

多线程指多任务同时执行。

一、创建线程和开启

（方法一）继承Thread类,重写run()方法

  • 定义线程体：
public class Test extends Thread{
	//定义线程体
	@Override
	public void run() {
		for(int i=1;i<=100;i++){
			System.out.println("aaa");
		}
	}
}
  • 开启多线程
public static void main(String[] args) {
		//创建线程对象:创建Thread子类的对象
		ThreadDemo01 th=new ThreadDemo01();
		//开启线程 
		th.start();  
		//在开启线程后，run()中的代码和start()后的代码会同时执行，执行顺序由cpu决定。
		for(int i=1;i<=100;i++){
			System.out.println("bbb.....");
		}
}

（方法二）实现Runnable接口,重写run()方法

**优点：**避免单继承的局限性，实现资源共享。推荐使用。

  • 定义线程体：
public class Test implements Runnable{
	//定义线程体
	@Override
	public void run() {
		for(int i=1;i<=100;i++){
			System.out.println("aaa");
		}
	}
}
  • 开启多线程
public static void main(String[] args) {
		ThreadDemo02 th=new ThreadDemo02();
		Thread t=new Thread(th);
		//虽然由Runnable接口实现，但是Runnable接口没有开启多线程的方法，所以还需要Thread类来开启多线程。
		t.start();
	
		for(int i=1;i<=100;i++){
			System.out.println("bbb.....");
		}
}

（方法三）实现Callable接口,重写call()方法

优点： call() 可以有返回值，且可以抛出异常
缺点： 操作复杂，不建议使用

  • 定义线程体：
public class T3 implements Callable<Integer>{
	@Override
	public Integer call() throws Exception {
		int i;
		for(i=1;i<=20;i++){
			if(i>=10)
				System.out.println(i+"学习...");
			else
				System.out.println(i+"吃饭...");
		}
		return i;
	}
}
  • 开启多线程
public static void main(String[] args) throws InterruptedException, ExecutionException {
		T3 th = new T3();
		//创建服务
		ExecutorService ex = Executors.newFixedThreadPool(2);
		//提交执行
		Future<Integer> re1 = ex.submit(th);
		Future<Integer> re2 = ex.submit(th);
		//获取返回值
		Integer i1= re1.get();
		Integer i2= re2.get();
		System.out.println(i1+"--->"+i2);
		//关闭服务
		ex.shutdown();
	}

二、线程状态

  • 新生: new Thread()
  • 就绪: start()，就绪状态的线程会进入到就绪队列中，等待cpu调度
    1. start()
    2. 阻塞状态解除
    3. yield()礼让线程:让出cpu的资源，线程直接进入就绪状态，但是下次cpu可能还会调用自己。
    4. 线程切换
  • 运行: 当cpu分配时间片给线程，这个线程就会进入运行状态开始运行
  • 阻塞:
    1. sleep()：线程睡眠时会进入阻塞状态，让出CPU资源，但不会释放对象锁。
    2. wait()
    3. join():插队，强行执行某线程
    4. IO操作
  • 终止: 线程结束
    1. 正常执行完毕
    2. 添加外部标识进行判断
    3. stop()、destory()已过时

sleep()

作用

  1. 放大发生问题的可能性
  2. 模拟网络延迟
public class Test implements Runnable{
	public static void main(String[] args) {
		new Thread(new Test()).start();
	}

	//模拟网络延迟
	@Override
	public void run() {
		for(int i=10;i>=0;i--){
			if(i==0){
				System.out.println("开始");
				break;
			}
			System.out.println(i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

yield()

public class YieldDemo {	
	static class Inner implements Runnable{
		@Override
		public void run() {
			System.out.println(Thread.currentThread().getName()+"开始执行");
			Thread.yield();
			System.out.println(Thread.currentThread().getName()+"结束执行");
		}
	}
	
	public static void main(String[] args) {
		Inner in=new Inner();
		new Thread(in,"A" ).start();
		new Thread(in,"B" ).start();
	}
}

join()

public class JoinDemo {
	public static void main(String[] args) {
		new Thread(new TimeD()).start();
	}
}

class TimeD implements Runnable{
	@Override
	public void run() {
		System.out.println("开始倒计时");
		Thread th=new Thread(new st());
		th.start();
		th.join();//强行执行倒计时
		System.out.println("结束倒计时");
	}
}

class st implements Runnable{
	@Override
	public void run() {
		for(int i=1;i<=10;i++){
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(i);
		}
	}
}

getStart()：返回线程的枚举类型状态值

  • NEW 至今尚未启动的线程处于这种状态。
  • RUNNABLE正在 Java 虚拟机中执行的线程处于这种状态。
  • BLOCKED受阻塞并等待某个监视器锁的线程处于这种状态。
  • WAITING无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
  • TIMED_WAITING等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。
  • TERMINATED已退出的线程处于这种状态。

int getPriority() 返回线程的优先级。

void setPriority(int newPriority) 更改线程的优先级。

  • 线程的优先级: 1~10 ，1为最小，10为最大，默认为5
  • 设置优先级无法控制线程执行顺序，但是可以增加执行的可能性。

三、线程安全

当多线程,同时操作,同一份资源的时候有可能存在线程不安全问题。
控制线程安全:使用同步锁 synchronized

锁静态方法：public synchronized static

public class Test implements Runnable{
	static int food = 100;
	/*
	 * 学生买饭
	 */

	public void run() {
		go();
	}
	
	public synchronized static void go() {
		while(true){
			//判断饭是否卖完
			if(food<=0){
				break;
			}
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		System.out.println(Thread.currentThread().getName()+"买了一份，还剩"+food--+"份饭");
		}
	}

	public static void main(String[] args) {
		Test t1=new Test();  //100
		//创建线程  资源共享
		Thread th1=new Thread(t1,"张三");
		Thread th2=new Thread(t1,"李四");
		Thread th3=new Thread(t1,"王五");
		Thread th4=new Thread(t1,"赵六");
		th1.start();
		th2.start();
		th3.start();
		th4.start();
	}
}

锁成员方法

public class Test implements Runnable{
	int food = 100;
	/*
	 * 学生买饭
	 */
	@Override
	public synchronized void run() {
		while(true){
			//判断饭是否卖完
			if(food<=0){
				break;
			}
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		System.out.println(Thread.currentThread().getName()+"买了一份，还剩"+food--+"份饭");
		}
	}

	public static void main(String[] args) {
		Test t1=new Test();  //100
		//创建线程  资源共享
		Thread th1=new Thread(t1,"张三");
		Thread th2=new Thread(t1,"李四");
		Thread th3=new Thread(t1,"王五");
		Thread th4=new Thread(t1,"赵六");
		th1.start();
		th2.start();
		th3.start();
		th4.start();
	}
}

锁对象：synchronized(this){ }

public class Test implements Runnable{
	//锁对象:每个对象只有一把锁,对象锁释放,别人就获取不了
	//对象中的所有资源都锁住了,只想要锁某一个资源,推荐锁资源
	int food = 100;
	/*
	 * 学生买饭
	 */
	@Override
	public void run() {
		while(true){
			//判断饭是否卖完
			synchronized (this) { //指代调用成员方法的对象
				if(food<=0){
					break;
				}
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			System.out.println(Thread.currentThread().getName()+"买了一份，还剩"+food--+"份饭");
			}
		}
	}

	public static void main(String[] args) {
		Test t1=new Test();  //100
		//创建线程  资源共享
		Thread th1=new Thread(t1,"张三");
		Thread th2=new Thread(t1,"李四");
		Thread th3=new Thread(t1,"王五");
		Thread th4=new Thread(t1,"赵六");
		th1.start();
		th2.start();
		th3.start();
		th4.start();
	}
}

锁类：synchronized(类){ }

public class Test implements Runnable{
	//锁类: 锁住了类的所有内容-->锁住了这个类的所有对象,锁住了一个对象中的所有资源,如果只想要锁一个对象建议去所对象
	int food = 100;
	/*
	 * 学生买饭
	 */
	@Override
	public void run() {
		while(true){
			//判断饭是否卖完
			synchronized (Test.class) {
				if(food<=0){
					break;
				}
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			System.out.println(Thread.currentThread().getName()+"买了一份，还剩"+food--+"份饭");
			}
		}
	}

	public static void main(String[] args) {
		Test t1=new Test();  //100
		//创建线程  资源共享
		Thread th1=new Thread(t1,"张三");
		Thread th2=new Thread(t1,"李四");
		Thread th3=new Thread(t1,"王五");
		Thread th4=new Thread(t1,"赵六");
		th1.start();
		th2.start();
		th3.start();
		th4.start();
	}
}

锁资源：synchronized(资源){ }

自定义引用数据类型的对象地址永远不变

public class Test implements Runnable{
	Food food=new Food();
	/*
	 * 学生买饭
	 */
	@Override
	public void run() {
		while(true){
			//判断饭是否卖完
			synchronized (food) {
				if(food.num<=0){
					break;
				}
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			System.out.println(Thread.currentThread().getName()+"买了一份，还剩"+food.num--+"份饭");
			}
		}
	}

	public static void main(String[] args) {
		Test t1=new Test();  //100
		//创建线程  资源共享
		Thread th1=new Thread(t1,"张三");
		Thread th2=new Thread(t1,"李四");
		Thread th3=new Thread(t1,"王五");
		Thread th4=new Thread(t1,"赵六");
		th1.start();
		th2.start();
		th3.start();
		th4.start();
	}
}
class Food{
	int num=100;
}

四、线程通信

wait()：线程等待，会让出对象的锁，并让出cpu的资源，对象进入阻塞状态。
notify() ：线程唤醒，使对象加入就绪状态
线程通信解决多线程之间共享数据的处理，wait() 和 notify()继承自Object类，使用wait() 和 notify()必须在一个安全同步的环境下
如果没有在同步环境下会抛出异常:IllegalMonitorStateException

木凊子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
stm32单片机多线程实例
12-03
多线程是实现复杂任务并发执行的关键技术，能够提高资源利用率，优化系统响应时间。在STM32上实现多线程，通常会借助实时操作系统（RTOS）如RT-Thread。 RT-Thread是一个轻量级、开源的实时操作系统，它为STM32等微...
java是内核线程还是用户线程_死磕 java线程系列之线程模型
weixin_39963534的博客
11-22 1004
问题(1)线程类型有哪些？(2)线程模型有哪些？(3)各语言使用的是哪种线程模型？简介在Java中，我们平时所说的并发编程、多线程、共享资源等概念都是与线程相关的，这里所说的线程实际上应该叫作“用户线程”，而对应到操作系统，还有另外一种线程叫作“内核线程”。用户线程位于内核之上，它的管理无需内核支持；而内核线程由操作系统来直接支持与管理。几乎所有的现代操作系统，包括 Windows、Linux、M...
Java创建的线程到底是用户级线程（ULT）还是内核级线程（KLT）
qq_41640103的博客
11-03 5840
Java创建的线程到底是用户级线程（ULT）还是内核级线程（KLT） 1.线程的理解 （1. 线程是调度CPU最小单元，也叫轻量级进程LWP（Light weight process） （2. 分为两种线程模型：用户级线程（ULT），内核级线程（KLT） 用户级线程（ULT）：用户程序实现，不依赖操作系统核心，应用提供创建、同步、调度和管理线程函数来控制用户线程。不需要用户态/核心态切换，速度快。内核对ULT无感知，线程阻塞则进程（包括它所有的线程）阻塞 内核级线程（KLT）:系统内核管理线程（KLT），
Java内核级线程测试&内核级线程与用户级线程区别
廖金龙的博客
04-28 1247
用户级线程 有关线程管理的所有工作都由应用程序完成，内核意识不到线程的存在. 应用程序可以通过使用线程库设计成多线程程序. 通常，应用程序从单线程起始，在该线程中开始运行，在其运行的任何时刻，可以通过调用线程库中的派生例程创建一个在相同进程中运行的新线程。 用户级线程仅存在于用户空间中，此类线程的创建、撤销、线程之间的同步与通信功能，都无须利用系统调用来实现。用户进程利用线程库来控制用户线程。由于...
OS / 线程的 3 种实现方式（内核级，用户级 和 混合型)
布袋和尚
02-18 762
1 、线程的 3 种实现方式 在传统的操作系统中，拥有资源和独立调度的基本单位都是进程。在引入线程的操作系统中，线程是独立调度的基本单位，进程是资源拥有的基本单位。在同一进程中，线程的切换不会引起进程切换。在不同进程中进行线程切换，如从一个进程内的线程切换到另一个进程中的线程时，会引起进程切换。 根据操作系统内核是否对线程可感知，可以把线程分为内核线程和用户线程 在多线程操作系统中，各个系统的实现方式并不相同，在有的系统中实现了用户级线程，有的系统中实现了内核级线程 有些情况下,也把..
多线程测试
09-21
在计算机科学领域，多线程是一种程序设计技术，它允许应用程序同时执行多个任务或子任务。这极大地提高了软件的效率和响应性，特别是在现代多核处理器的环境下。本主题将深入探讨多线程的实现方式及其与单线程的对比...
大漠多线程模板_大漠_大漠多线程_
09-30
"大漠多线程模板"是一个专门针对C#开发的多线程处理框架，它为开发者提供了便捷的方式来管理和优化多线程应用。这个框架由知名开发者"大漠"创建，旨在简化复杂的并发编程，提高代码的可读性和可维护性。 多线程允许...
安卓多线程
04-16
安卓多线程，安卓高级开发中，必备技能，项目开发中都要使用
java中的用户线程和守护线程
远行的博客
06-14 4657
文章目录java线程分类用户线程和守护线程的区别用户线程标准定义优点：缺点抢占式和非抢占式守护线程 java线程分类 在Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程) 用户线程和守护线程的区别 二者其实基本上是一样的。唯一的区别在于JVM何时离开。 用户线程：当存在任何一个用户线程未离开，JVM是不会离开的。 守护线程：如果只剩下守护线程未离开，J...
Java线程中的用户态和内核态
weixin_43776652的博客
05-04 5436
内核态用户态是什么? 操作系统对程序的执行权限进行分级,分别为用户态和内核态。用户态相比内核态有较低的执行权限，很多操作是不被操作系统允许的，简单来说就是用户态只能访问内存,防止程序错误影响到其他程序，而内核态则是可以操作系统的程序和普通用户程序 内核态: cpu可以访问计算机所有的软硬件资源 用户态: cpu权限受限,只能访问到自己内存中的数据,无法访问其他资源 为什么要有用户态和内核态? 系统需要限制不同的程序之间的访问能力,防止程序获取不相同程序的内存数据,或者外围设备的数据,并发送到网络,所有cpu
linux中用户线程、内核线程、轻量级进程的区别
Java程序员的进阶之路
04-04 1395
原文链接：http://www.cnitblog.com/tarius.wu/articles/2277.html 内核线程 内核线程就是内核的分身，一个分身可以处理一件特定事情。这在处理异步事件如异步IO时特别有用。内核线程的使用是廉价的，唯一使用的资源就是内核栈和上下文切换时保存寄存器的空间。支持多线程的内核叫做多线程内核(Multi-Threads kernel )。 轻量级进程（LW...
java多线程核心技术_java多线程编程核心技术——第二章总结
weixin_33911375的博客
02-16 57
第一节synchronized同步方法目录说到线程安全，就要提到非线程安全问题了：“非线程安全问题”：在多个线程同时对同一个对象中的实例变量进行访问时发生。产生的结果就是脏读(读到被修改过的数据)。“线程安全”获得的实例变量是经过同步处理的，不会出现脏读的情况。“非线程安全”的问题存在于实例变量中，如果将实例变量私有，则不存在“非线程安全”问题，所得就是线程安全了。注：在方法内部声明变量，是不存在...
好程序员Java培训告诉你Java-线程怎么来的?
qq_35970166的博客
09-23 112
好程序员Java培训告诉你Java-线程怎么来的?并发处理的广泛应用是使得amdahl定律代替摩尔定律成为计算机性能发展源动力的根本原因，是人类压榨计算机运算能力的最有力武器。 并发并非一定得用多线程，多进程也可以，不过java里面谈论并发，大多数与线程脱不开关系。因此我们从线程说起。好程序员小编主要在本文介绍了以下内容: 线程的实现 线程的调度 线程状态切换 线程的实现 线程是比进程更轻量级的调度执行单位，在linux里面，线程和进程没有什么区别，唯一的就是在地址空间，线程的切换虚拟内存空间依然是相同的，
深入浅出Java多线程-第三章 Java线程的状态-学习
xyfaneast的博客
04-05 140
线程的start()方法是否可以多次调用？ 不可以，调用一次后线程状态就改变了，再次调用会抛异常。 线程状态转换图
java面试题：JVM线程的用户态和内核态
weixin_44844089的博客
09-01 2735
JVM线程用户态和内核态 一. 线程用户态和内核态概念 1.1 为什么会有用户态和内核态 由于需要限制不同的程序之间的访问能力, 防止他们获取别的程序的内存数据, 或者获取外围设备的数据, 并发送到网络, CPU划分出两个权限等级 :用户态 和 内核态 1.2 用户态和内核态的区别 内核态：CPU可以访问内存所有数据, 包括外围设备, 例如硬盘, 网卡. CPU也可以将自己从一个程序切换到另一个程序 用户态：只能受限的访问内存, 且不允许访问外围设备. 占用CPU的能力被剥夺, CPU资源可以被其他程
JVM的线程是用户态线程还是内核态线程？
m0_50654102的博客
04-23 1060
JVM 自己本身有一个线程模型。在 JDK 1.1 的时候，JVM 自己管理用户级线程。这样做缺点非常明显，操作系统只调度内核级线程，用户级线程相当于基于操作系统分配到进程主线程的时间片，再次拆分，因此无法利用多核特性。 为了解决这个问题，后来 Java 改用线程映射模型，因此，需要操作系统支持。在 Windows 上是 1 对 1 的模型，在 Linux 上是 n 对 m 的模型。 Linux 的PThreadAPI 创建的是用户级线程，如果 Linux 要创建内核级线程有KThreadAPI。 映射关系
Java用户级线程和核心级线程的区别是什么
淡淡的宁静的博客
03-28 2524
以上内容转自：https://blog.csdn.net/qq_34173549/article/details/79564161#commentsedit 下面是本人的理解小结： 我的理解是每个进程持有多个轻型进程（即内核级线程），而java中Thread创建的线程是用户级线程。假设进程分配到了x个内核线程，而java进程中创建了y个用户级线程。那y个用户级线程将轮流关联到x个内核...
Delphi多线程编程详解
"Delphi多线程编程详解深入解析了如何在Delphi应用程序中实现多线程技术，包括线程的定义、TThread对象的使用、多线程管理、示例程序、多线程与数据库及图形处理的结合。本资料详细介绍了线程在Win32操作系统中的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值