Java多线程

最新推荐文章于 2024-06-19 21:11:55 发布
最新推荐文章于 2024-06-19 21:11:55 发布
阅读量236 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LeoWang0824/article/details/77987465
版权

首先 理解进程的概念，在操作系统中一个程序的 执行周期就称为一个进程。在最初的DOS操作系统由于其本身只是一个单进程的系统，所以在同一时间段只能执行一个程序，而后来windows可以执行多进程,这样一块资源在同一时间段会有多个进程交替执行，但是在同一个时间点只会有一个时间点去执行。

而线程是在进程上面的进一步划分，线程是比进程更小的单位。Java本身是一个多线程的语言，多线程引用体现在哪里呢？

所谓高并发就是访问的线程 爆高



Java多线程的实现

前提：有一个线程的执行主类

用户----》主类main方法------》多线程主类，我们主要考虑 的就是多线程主类的定义结构，现在有两种方式可以实现这个主类，第一种继承Thread类，第二种是实现Runnable或Callable接口

1.Thread实现

package com.wjx.sayHello;

class myThread extends Thread{

	private String name;
	public myThread(String name){
		this.name=name;
	}
	@Override
	public void run(){
		for(int x=0;x<10;x++){
			System.out.println(name+",x="+x);
		}
	}
}




public class TestDemo {
	
	public static void main(String[] args){
		myThread m1=new myThread("A");
		myThread m2=new myThread("B");
		myThread m3=new myThread("C");
		m1.start();
		m2.start();
		m3.start();
		
	}
}

启动多线程public void start()，调用此方法虚拟机会调用run()方法，对象直接调用run()方法没有意义，那为啥呢？看看源码

2.Runnable接口

 Thread  和 Runnable 的关系：public class Thread extends Object implements Runnable

package com.wjx.sayHello;

class myThread implements Runnable{

	private String name;
	public myThread(String name){
		this.name=name;
	}
	@Override
	public void run(){
		for(int x=0;x<10;x++){
			System.out.println(name+",x="+x);
		}
	}
}





public class TestDemo {
	
	public static void main(String[] args){
		myThread m1=new myThread("A");
		myThread m2=new myThread("B");
		myThread m3=new myThread("C");
//		m1.start();
//		m2.start();
//		m3.start();
		new Thread(m1).start();
		new Thread(m2).start();
		new Thread(m3).start();
		
	}
}

3.通过callable

jdk1.5之后追加了一个开发包Java,util.concurrent,这个开发包主要提供一些高并发的类。

由于Runnable 的run()方法也是线程的主方法，但是没有返回值，当线程执行完成带来一些返回值的时候我们这个时候就需要使用Callable来实现多线程

package com.wjx.sayHello;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class myThread implements Callable<String>{

	@Override
	public String call() throws Exception {
		for(int x=0;x<10;x++){
			System.out.println("x="+x);
		}
		return "票卖完了";
	}
	
}
public class TestDemo {
	
	public static void main(String[] args) throws InterruptedException, ExecutionException{
		FutureTask<String> ft=new FutureTask<String>(new myThread());
		new Thread(ft).start();
		System.out.println(ft.get());
			
		
		
	}
}

4.多线程的常用操作方法

（1）线程的命名和取得

package com.wjx.sayHello;
class myThread implements Runnable{
	@Override
	public void run() {
		for(int x=0;x<10;x++){
			System.out.println("线程名字是："+Thread.currentThread().getName()+",x的值是："+x);
		}	
	}	
}
public class TestDemo {
	
	public static void main(String[] args){
		myThread mt=new myThread();
		//Thread(Runnable target, String name)构造方法，返回name值
		new Thread(mt, "Leo").start();//
		new Thread(mt).start();//自动命名，比如Thread-0
		mt.run();//返回main，主方法本身是一个线程
		
	}
}

（2）线程休眠

public static void sleep(long millis) throws InterruptedException

package com.wjx.sayHello;
class myThread implements Runnable{
	@Override
	public void run() {
		for(int x=0;x<10;x++){
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("线程名字是："+Thread.currentThread().getName()+",x的值是："+x);
		}	
	}	
}
public class TestDemo {
	
	public static void main(String[] args){
		myThread mt=new myThread();
		//Thread(Runnable target, String name)构造方法，返回name值
		new Thread(mt, "Leo").start();//
		new Thread(mt).start();//自动命名，比如Thread-0
		mt.run();//返回main，主方法本身是一个线程
		
	}
}


3.线程优先级

package com.wjx.sayHello;
class myThread implements Runnable{
	@Override
	public void run() {
		for(int x=0;x<2;x++){
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("线程名字是："+Thread.currentThread().getName()+",x的值是："+x);
		}	
	}	
}
public class TestDemo {
	
	public static void main(String[] args){
		//获取主方法的优先级，为NORM_PRIORITY 返回是5
		System.out.println(Thread.currentThread().getPriority());
		myThread mt=new myThread();
		Thread t1=new Thread(mt,"ThreadA");
		Thread t2=new Thread(mt,"ThreadB");
		Thread t3=new Thread(mt,"ThreadC");
		// 设置优先级，只是有可能优先执行，并不一定啊
		t1.setPriority(Thread.MIN_PRIORITY); //MIN_PRIORITY 常量1
		t2.setPriority(Thread.NORM_PRIORITY);//MIN_PRIORITY 常量5
		t3.setPriority(Thread.MAX_PRIORITY);//MIN_PRIORITY 常量10
		
		t1.start();
		t2.start();
		t3.start();
		
		
		
	
		
		
	}
}

4 线程的同步和死锁

同步问题的引出：观察一个不同步的问题

package com.wjx.sayHello;
class myThread implements Runnable{
	private int ticket=10;
	@Override
	public void run() {
		for(int x=0;x<20;x++){
			
			if(ticket>0){
				try {
					Thread.sleep(1000);//延迟暴露问题，同步会造成当几个进程同时判断票数>0都满足的同时，由于延迟，ticket--还没有操作，如果此时其他进来，票数可能小于0
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("售票员名字是："+Thread.currentThread().getName()+",票数剩余是："+ticket--);
			}
		}	
	}	
}
public class TestDemo {
	
	public static void main(String[] args){
		//获取主方法的优先级，为NORM_PRIORITY 返回是5

		myThread mt=new myThread();
		Thread t1=new Thread(mt,"张三");
		Thread t2=new Thread(mt,"李四");
		Thread t3=new Thread(mt,"王五");
		
		
		t1.start();
		t2.start();
		t3.start();
//执行结果：
//		售票员名字是：张三,票数剩余是：10
//		售票员名字是：李四,票数剩余是：9
//		售票员名字是：王五,票数剩余是：8
//		售票员名字是：张三,票数剩余是：7
//		售票员名字是：李四,票数剩余是：6
//		售票员名字是：王五,票数剩余是：5
//		售票员名字是：张三,票数剩余是：4
//		售票员名字是：李四,票数剩余是：3
//		售票员名字是：王五,票数剩余是：2
//		售票员名字是：张三,票数剩余是：1
//		售票员名字是：李四,票数剩余是：0
//		售票员名字是：王五,票数剩余是：-1
//结论：不同步数据的访问是不安全的

			
		
	}
}

如何处理：同步处理：所有线程不是一起进入方法，而是按照顺序一步一步进入。当一个程序进入一个方法的时候，上把锁，不解锁，其他进程无法进入，我们使用Synchronized来处理，有两种方式，同步代码块，同步方法。同步虽然保证数据的完整性，但是访问速度变慢了。

1...同步代码块（必须要设置一个被锁定的对象，一般锁定当前对象）

package com.wjx.sayHello;
class myThread implements Runnable{
	private int ticket=10;
	@Override
	public void run() {
		for(int x=0;x<20;x++){
			synchronized(this){
			if(ticket>0){
				try {
					Thread.sleep(1000);//延迟暴露问题，同步会造成当几个进程同时判断票数>0都满足的同时，由于延迟，ticket--还没有操作，如果此时其他进来，票数可能小于0
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("售票员名字是："+Thread.currentThread().getName()+",票数剩余是："+ticket--);
			}
			}
		}	
	}	
}
public class TestDemo {
	
	public static void main(String[] args){
		//获取主方法的优先级，为NORM_PRIORITY 返回是5

		myThread mt=new myThread();
		Thread t1=new Thread(mt,"张三");
		Thread t2=new Thread(mt,"李四");
		Thread t3=new Thread(mt,"王五");
		t1.setPriority(Thread.MIN_PRIORITY);
		t2.setPriority(Thread.MAX_PRIORITY);
		t3.setPriority(Thread.NORM_PRIORITY);
		
		t1.start();
		t2.start();
		t3.start();
//执行结果
//		售票员名字是：王五,票数剩余是：10
//		售票员名字是：王五,票数剩余是：9
//		售票员名字是：王五,票数剩余是：8
//		售票员名字是：张三,票数剩余是：7
//		售票员名字是：李四,票数剩余是：6
//		售票员名字是：李四,票数剩余是：5
//		售票员名字是：李四,票数剩余是：4
//		售票员名字是：李四,票数剩余是：3
//		售票员名字是：李四,票数剩余是：2
//		售票员名字是：李四,票数剩余是：1

		
		
	
		
		
	}
}

2...同步方法 
package com.wjx.sayHello;
class myThread implements Runnable{
	private int ticket=10;
	@Override
	public void run() {
		sale();
	}	
	public synchronized void sale(){
		for(int x=0;x<20;x++){
			
			if(ticket>0){
				try {
					Thread.sleep(1000);//延迟暴露问题，同步会造成当几个进程同时判断票数>0都满足的同时，由于延迟，ticket--还没有操作，如果此时其他进来，票数可能小于0
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("售票员名字是："+Thread.currentThread().getName()+",票数剩余是："+ticket--);
			}
			
		}	
	}
}
public class TestDemo {
	
	public static void main(String[] args){
		//获取主方法的优先级，为NORM_PRIORITY 返回是5

		myThread mt=new myThread();
		Thread t1=new Thread(mt,"张三");
		Thread t2=new Thread(mt,"李四");
		Thread t3=new Thread(mt,"王五");
		t1.setPriority(Thread.MIN_PRIORITY);
		t2.setPriority(Thread.MAX_PRIORITY);
		t3.setPriority(Thread.NORM_PRIORITY);
		
		t1.start();
		t2.start();
		t3.start();


		
		
	
		
		
	}
}

3死锁（同步带来的问题）

模拟一个死锁 ，下面是一个死锁程序，程序造成死锁

package com.wjx.sayHello;
class Pen{
	public synchronized void get(){
		System.out.println("获取笔记本");
	}
	public synchronized void getOther(Book book){
		System.out.println("获取其他，book");
		book.get();
	}
}
class Book{
	public synchronized void get(){
		System.out.println("获取笔");
	}
	public synchronized void getOther(Pen pen){
		System.out.println("获取其他，pen");
		pen.get();
	}
}
public class DeadLock implements Runnable{
	Pen pen =new Pen();
	Book book=new Book();
	public static void main(String[] args) {
		new DeadLock();
	}
	public DeadLock(){
		new Thread(this).start();
		pen.getOther(book);
	}
	@Override
	public void run() {
		book.getOther(pen);
	}

}


四金八两
关注
专栏目录
java多线程嵌套_Java多线程进阶
weixin_36002897的博客
02-16 4286
需要理解锁是什么意思?首先是发生在多线程的情况下;线程a,线程b,共享资源share例如,share的资源一次只能被一个对象操作,这时候需要一个东西来标识(也叫监视器)出来表明该资源已经有人(指的是线程)在使用了,请还要使用的人(指的是线程)进入等待(线程等待池/队列);怎么实现呢?synchronized关键字,配合一个唯一的东西,可以是类.class,也可以是对象本身;但注意的是必须是一个引用...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
java多线程
m0_46702681的博客
06-19 2211
javajava。
Java多线程并发编程技术详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 3万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
Java多线程读取文件
Mr-Bean的博客
08-16 2463
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 2999
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
单核 CPU 支持 Java 多线程吗？我们来一起看看吧
吴名氏的博客
06-09 9万+
单核 CPU 支持 Java 多线程吗？我们来一起看看吧
java多线程使用教程
鹏鹏2077
04-25 5454
本教程介绍了Java多线程的基本知识和使用方法，包括创建线程、实现Runnable接口、继承Thread类、线程同步、线程间通信和线程池等。多线程技术可以提高程序的并发处理能力和响应速度，但同时也带来了线程安全和同步等问题，需要合理使用同步机制来保证线程安全。使用Java提供的Lock接口可以实现更加灵活和精细的线程同步。线程间通信可以使用wait()、notify()和notifyAll()方法来实现。线程池机制可以重用线程，提高了线程的利用率和效率。掌握了这些知识，可以使用Java实现高效、安全、可靠的
编程必备：JAVA多线程详解
拾一二的博客
06-14 8601
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java 多线程的应用场景
才哈哈的博客主页
05-01 1万+
电影院新片首映，观影人数大量增加，为提高日营业额，线下售票窗口由原单窗口调整为3窗口，设计一段简单的程序模拟该售票过程。
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
卡通风格化魔法术技能粒子特效 ：Toon Projectiles 2 1.0
10-19
这款卡通射击特效资源包提供了 15 种独特的射击物、命中效果和闪光效果，风格统一且易于与您的项目集成。它默认支持 Unity 的内置渲染器，并且兼容 HDRP 和 URP 渲染管线。如果您拥有 Hovl Studio 的其他资源，该包将免费提供。所有效果均在各平台兼容，并且可以通过标准尺寸值轻松调整命中效果的大小。需要注意的是，调整射击物大小时，可能需要修改轨迹长度和按距离生成的速率。 该资源还包含了一个演示场景射击脚本，方便用户快速了解如何使用这些特效。该资源包还与 InfinityPBR 的 Projectile Factory 插件兼容，可以进一步增强您的射击游戏效果。 需要注意的是，推广媒体中使用的后处理效果 "Bloom" 并非资源包自带，建议用户在下载资源包之前，先行从 Unity 包管理器下载 "Post Processing Stack"。HDRP 和 URP 渲染管线的用户可以直接利用内置的 "Volume" 组件中的 "Bloom" 效果。
在 MATLAB GUI 中动态更新数据：策略与实践
10-19
通过本文的详细介绍，你应该能够理解如何在 MATLAB GUI 中更新数据。从设计 GUI 界面到处理用户输入，再到动态更新数据，每一步都是构建交互式 MATLAB 应用程序的关键。通过实际的代码示例，你可以更深入地理解这些概念，并将其应用到你自己的项目中。 记住，GUI 的设计和实现是一个迭代的过程。随着你对用户需求的更深入了解，你可能需要不断调整和优化你的 GUI。通过持续的测试和反馈，你可以创建一个既美观又功能强大的 MATLAB GUI 应用程序
【JCR一区级】Matlab实现白鹭群优化算法ESOA-CNN-BiLSTM-Attention的故障诊断算法研究.rar
最新发布
10-20
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
信创实验室建设方案（24页）.pptx
10-19
信创实验室建设方案（24页）
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值