java多线程

最新推荐文章于 2024-10-30 18:07:32 发布
最新推荐文章于 2024-10-30 18:07:32 发布
阅读量68 收藏
点赞数
分类专栏： 线程 java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45775114/article/details/120726394
版权

多线程

  • 并行和串行
  • 并行：多个任务同时执行，效率高。
  • 串行：多个任务依次执行，效率低
  • 单核和多核CPU
  • 单核：如:只有一个人帮干活
  • 多核：有多个人帮你干活
  • 线程和进程
  • 进程(Process)：正在运行的一个程序称为进程（word 、记事本）
  • 线程(Thread)：线程就是进程中的一个任务.
  • 单线程和多线程
  • 如果一个进程中只有一个线程，称为单线程的程序。
  • 如果一个进程中包含两个或者两个以上的线程，称为多线程程序。
  • 进程负责分配内存，多线程共享进程分配的内存
  • 进程的任务之一是向操作系统申请内存
  • 线程向进程申请内存
  • 多线程共享进程分配的内存
  • 线程调度器与调度算法
  • 多个线程谁先执行？线程的运行过程是由线程调度器来负责的。
  • 线程调度器有两个调度算法：时间片轮换调度与抢占式调度

Java对多线程的支持

  • java多线程解决了程序并发执行

创建线程的方式

  • 串行
public class DemoChuanXing {
	public static void main(String[] args) {
		/*
		 * 不使用线程，方法间的调用是串行的
		 * 串行执行时，不能实现多任务并行
		 * 
		 * 串行关键点:
		 * 当a运行时，main等待a运行结束后才能运行main
		 * 当b运行时，a等待b运行结束后才能运行a
		 */
		a();
		System.out.println("main");
	}
	private static void a() {
		b();
		System.out.println("a");	
	}
	private static void b() {
		System.out.println("b");	
	}
}
  • 继承Thread类创建线程
public class MyThread extends Thread{
	/*
	 * 线程并行
	 * 创建线程的方式1、创建类继承Thread类创建线程
	 * (1)创建一个子类继承Thread类，
	 * (2)重写run方法
	 * (3)调用start方法启动线程,启动后会调用run()方法 
	 */
	@Override
	public void run() {
		for(int i=0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+"="+i);
		}
	}
}

public class Test {
	public static void main(String[] args) {
		/*
		 * main方法执行时，jvm会创建一个主线程
		 * 
		 */
		MyThread myThread=new MyThread();
		//启动线程，线程会自动调用run方法
		myThread.start();	
	}
}
  • 关于主线程
  • main方法启动时会自动创建一个线程，称为主线程。
  • 子线程需要在主线程中创建。
  • 关于线程的名称
  • Thread.currentThread()获取当前线程
  • Thread.currentThread().getName()获取当前线程的名称
  • 主线程名称默认是main
  • 子线程名称默认是Thread-00 | 01 | 02
  • 修改线程的名称，调用setName方法
  • Thread.currentThread().setName(“主线程”);
  • t.setName(“子线程”);
  • 实现Runnable接口创建子线程
public class MyThread implements Runnable{
	/*
	 * 创建线程2、实现Runnable接口创建线程
	 * 方法(1)定义类，实现Runnable接口
	 *     (2)重写run方法
	 *     (3)将Runnable接口包装到Thread类中
	 *     (4)调用start启动线程
	 *     Runnable是函数式接口
	 * 
	 */

	@Override
	public void run() {
		for(int i=0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+"="+i);
		}
	}
}

public class Test {
	public static void main(String[] args) {
		
		Thread.currentThread().setName("主线程");
		MyThread myThread=new MyThread();
		//将Runnable接口包装到Thread类中
		Thread t=new Thread(myThread);
		t.setName("子线程");
		t.start();
		
		for(int i=0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+"="+i);
		}
	}
}

Runnable接口是函数式接口，因此可以使用lambda表达式实现线程。

public class Test1 {
	public static void main(String[] args) {
		/*
		 * Runnable是函数式接口,使用lambda表达式实现线程
		 * 
		 */
		Runnable runnable=()->{
			for(int i=0;i<100;i++) {
				System.out.println(Thread.currentThread().getName()+"="+i);
			}
		};
		new Thread(runnable).start();
		
		for(int i=0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+"="+i);
		}
	}
}

实现Callable接口

  • 与Runnable相比，Callable可以有返回值，返回值通过FutureTask进行封装。
ublic class MyCallable implements Callable<Integer>{

	@Override
	public Integer call() throws Exception {
		return 45;
	}
}


public class Test {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		MyCallable myCallable=new MyCallable();
		FutureTask<Integer> f=new FutureTask<>(myCallable);
		Thread thread=new Thread(f);
		thread.start();
		System.out.println(f.get());
	}
}

继承类与实现接口的方式有什么区别

  • java不支持多重继承，因此继承了Thread类就无法继承其他类，但是可以实现多个接口
  • 类可能只要求可执行就行，继承整个Thread类开销过大。

主线程与子线程

  • main方法启动时，JVM自动创建了主线程
  • main方法中new的线程是子线程

线程的基础机制

  1. 让步yield
  • 一个运行中的线程想要放弃执行的权利
  • 此时线程调度器会选择另一个可运行的线程来执行，不过，调度器也可以忽略这个通知
  • yield只是放弃了本时间片的执行，放弃后又回到就绪队列重新排队。
public class ThreadYield {
	public static void main(String[] args) {
		/*
		 * 线程让步yield
		 * 如果一个运行中的线程想要放弃执行的权利，那么可以调用Thread类
		 * 中的静态方法yield来通知线程调度器
		 * 
		 * 本线程要让出对CPU的占用，此时线程调度器会选择另一个可运行的线程来执行，
		 * 不过，调度器也可以忽略这个通知
		 * 注意:yield方法只是临时放弃当前线程的执行，并不代表该线程就不执行了，此时线程将转为就绪状态。
		 */
		Runnable run=()->{
			for(int i=0;i<100;i++) {
				System.out.println(Thread.currentThread().getName()+"="+i);
				Thread.yield();
			}
		};
		new Thread(run).start();
		new Thread(run).start();
	}
}
  1. 休眠sleep
  • 当线程休眠时，它放弃了执行的权利，加入到等待对列，什么都不做，然后等到休眠时间到了再醒过来，加入可运行队列。
public class Sleep {
	public static void main(String[] args) {
		/*
		 * 线程休眠
		 * 与yield方法临时放弃线程执行权利的方式不同，sleep是真正的睡眠。
		 * 
		 * 正常情况下，需要等线程睡眠了指定时间后，才会重新转为可运行状态，被线程调度器所调度。
		 */
		Runnable run=()->{
			while(true) {
				System.out.println(new Date());
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		};
		Thread t=new Thread(run);
		t.start();
	}
}

解析：

  • sleep时，线程休眠了，在休眠期间不会进入到就绪队列
  • 当休眠时间结束后，进入就绪队列排队
  • sleep方法会抛出编译时异常InterruptedException（中断）
  1. 优先级priority

Thread类中定义了三个优先级常量

  • MAX_PRIORITY=10
  • NORM_PRIORITY=5
  • MIN_PRIORITY=1

线程优先级

  • 决定了那个线程更容易获取CPU时间片
  • 虽然线程调度器选择哪一个线程运行是由很多因素决定的，但是调度器确实会让优先级高的线程获得CPU
  • 对于两个优先级不同的线程来说，优先级高的线程会得到更多的执行时间。
  • 但是优先级高的线程不一定先执行
public class Priority {
	public static void main(String[] args) {
		Runnable run=()->{
			for(int i=0;i<100;i++) {
				System.out.println(Thread.currentThread().getName()+"="+i);
			}
		};
		Thread t1=new Thread(run);
		Thread t2=new Thread(run);
		//设置优先级别
		t1.setPriority(Thread.MAX_PRIORITY);
		t2.setPriority(1);	
		t1.start();
		t2.start();
	}
}
  1. 后台线程(background:后台 daemon:守护)

进程退出是如何界定的？

  • 当一个进程中的所有线程都结束了，这个进程就退出了.当一个进程中只要有一个线程还在运行，那么这个进程就不能退出

为什么要后台线程呢？

  • 后台线程是否在运行，不影响进程的结束。所有的非后台进程都结束了，进程就退出了。

后台线程使用场景

  • 监视程序
  • JVM的垃圾回收线程
	public static void main(String[] args) {
		
		Runnable run=()->{
			while(true) {
				System.out.println(new Date());
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		};
		Thread t=new Thread(run);
		//将t设置为守护线程，t是否在运行不影响程序的退出。
		t.setDaemon(true);
		t.start();
	}
  1. 线程间的协作

线程联合join

  • join 方法是让一个线程等待另一个线程执行完毕后再继续执行执行
class A extends Thread{
	@Override
	public void run() {
		for(int i=0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+"="+i);
		}
	}
}
class B extends Thread{
	private A a;
	
	public B(A a) {
		this.a = a;
	}
	@Override
	public void run() {
		for(int i=0;i<100;i++) {
			try {
	/*
     * B调用了A的join方法，当a运行结束后，b开始运行
	 * 
	 */
				a.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"="+i);		
		}
	}
}
public class Test {
	public static void main(String[] args) {
		A a=new A();
		B b=new B(a);
		a.setName("牛牛牛牛牛");
		b.setName("*********");
		a.start();
		b.start();
	}
}
洛 尘
关注
专栏目录
java多线程execute_Java多线程
weixin_34704521的博客
02-16 2751
Java多线程之Executor、ExecutorService、Executors、Callable、Future与FutureTask1. 引子初学Java多线程，常使用Thread与Runnable创建、启动线程。如下例:Thread t1 = new Thread(newRunnable() {@Overridepublic voidrun() {System.out.println(Th...
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
Java多线程读取文件
Mr-Bean的博客
08-16 2472
package com.qwx.test; import java.io.*; /** * @ClassName: ReadFile * @Description: java类作用描述 * @Author: qiaowenxuan * @CreateDate: 2021/8/16$ 18:36$ * @Version: 1.0 */ public class ReadFile { public static void main(String[] args) { Fil
Java 多线程：彻底搞懂线程池
热门推荐
孙强 Jimmy 的博客
07-09 19万+
熟悉Java多线程编程的同学都知道，当我们线程创建过多时，容易引发内存溢出，因此我们就有必要使用线程池的技术了。
Java多线程——线程同步
u010759175的专栏
12-28 3014
1.不安全的买票 //不安全的买票 //线程不安全，有负数或者多人买到同一张票 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"苦逼的我").start(); new Thread(buyTicket,"牛逼的你们").start(); new Thread(buyTic
JAVA多线程是什么
qq_45022104的博客
08-31 4211
一、 什么是多线程： 我们现在所使用操作系统都是多任务操作系统(早期使用的DOS操作系统为单任务操作系统)，多任务操作指在同一时刻可以同时做多件事(可以同时执行多个程序)。 多进程:每个程序都是一个进程，在操作系统中可以同时执行多个程序,多进程的目的是为了有效的使用CPU资源，每开一个进程系统要为该进程分配相关的系统资源(内存资源) 多线程:线程是进程内部比进程更小的执行单元(执行流|程序片段),每个线程完成一个任务,每个进程内部包含了多个线程每个线程做自己的事情，在进程中的所有线程共享该进程的资源； 主
Java 多线程 测试
风信子
04-14 1962
Java 多线程 测试1 Callable2 Runnable3 Thread 1 Callable package com.xu.thread; import java.util.concurrent.Callable; /** * @author Administrator */ public class MyCallable implements Callable { @Override public Object call() throws Exception {
Java多线程(四)线程锁
yuanchun的知识整理
11-03 4849
Java多线程(四)线程锁
Java多线程案例之线程池
trong_ 的烂笔头
01-30 5735
介绍线程池的原理和简单实现, 进一步提高并发编程的效率.
Java多线程（超详细）
loss_rose777的博客
08-14 2万+
25000字带你了解线程的概念，这一定是csdn上最全面的关于线程的文章，不看别后悔哦！
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
服务器虚拟化
最新发布
Hellc007的博客
10-30 470
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 965
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 457
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
ssm智慧社区电子商务系统+vue
weixin_44832324的博客
10-28 1214
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值