java多线程基础部分探究

最新推荐文章于 2024-08-28 18:12:40 发布
最新推荐文章于 2024-08-28 18:12:40 发布
阅读量325 收藏
点赞数
分类专栏： java基础知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bigcaicai1995/article/details/47174491
版权

1.多线程实现方式

1.继承Thread类，但是对于单继承的Java，限制很大

2.实现Runnable接口


public class DemoThread {


				public static void main(String[] args) {
					Play play = new Play();
					Thread thread = new Thread(play);
					thread.start();
				}
				
			}


			class Play implements Runnable{


				@Override
				public void run() {
					// TODO Auto-generated method stub
					for(int i = 0; i<10;i++){
						System.out.println("线程："+i);
						try {
							Thread.sleep(2000);
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
					System.out.println();
				}
			}


3.使用Timer和TimerTask组合

最后一种实现多线程的方式，就是使用java.util包中的Timer和TimerTask类实现多线程，使用这种方式也可以比较方便的实现线程。
在这种实现方式中，Timer类实现的是类似闹钟的功能，也就是定时或者每隔一定时间触发一次线程。其实，Timer类本身实现的就是一个线程，
只是这个线程是用来实现调用其它线程的。而TimerTask类是一个抽象类，该类实现了Runnable接口，所以按照前面的介绍，该类具备多线程的能力。
在这种实现方式中，通过继承TimerTask使该类获得多线程的能力，将需要多线程执行的代码书写在run方法内部，然后通过Timer类启动线程的执行。
在实际使用时，一个Timer可以启动任意多个TimerTask实现的线程，但是多个线程之间会存在阻塞。所以如果多个线程之间如果需要完全独立运行的话，
最好还是一个Timer启动一个TimerTask实现。 

public class DemoTimerMark {


					public static void main(String[] args) {
						Timer timer1 = new Timer();
						Timer timer2 = new Timer();
						MyTimerTask task1 = new MyTimerTask(1);
						timer1.schedule(task1, 1000);
						MyTimerTask task2 = new MyTimerTask(2);
						timer2.schedule(task2, 1000);
						
					}
				}


				class MyTimerTask extends TimerTask{


					private int count;
					public MyTimerTask(int i){
						this.count = i;
					}
					@Override
					public void run() {
						// TODO Auto-generated method stub
						for(int i = 0; i<4;i++){
							System.out.println("线程"+this.count+"："+i);
							try {
								Thread.sleep(2000);
							} catch (InterruptedException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
						}
						System.out.println("========================================END=====================================");
					}
					
				}
				//

2,线程状态

1.新生状态 new
2.被阻塞状态 blocked
3.可运行状态 runnable
4.等待 waiting
5.计时等待 time waiting
6.被终止 terminated

3.线程细节

1.线程优先级
setPriority方法可以为线程设置优先级 ，优先级默认继承父线程的优先级 ，线程优先级高度依赖于操作系统。Java线程优先级会被映射到寄主主体平台的优先级上面
2.守护线程 setDaemon(true)
为其他线程提供服务的线程。如计时器线程。当只有一个守护线程时，虚拟机会退出（守护线程永远不要去访问固件资源，因为他会随时中断）

4.锁   方法一：Lock/Condition  方法二：synchronized

1.条件对象
一个锁可以有多个条件，每个条件上可以有多个线程等待，通过调用await()方法，可以让线程在该条件下等待。当调用signalAll()方法，又可以唤醒该条件下的等待的线程。
有关Condition接口的API可以具体参考JavaAPI文档。
2.synchronized 用此关键词声明的方法必须要获得程序的内部锁

3.同步阻塞 使用一个对象的锁来实现额外的原子操作称为 客户端锁定


5,银行取款问题

		// 银行取款问题
		// 不加锁
			public class BankProblem {
	
				public static void main(String[] args) {
					Bank bank = new Bank();
					for(int i=0;i<1000;i++){
						Transable transable = new Transable(bank,i);
						Thread thread =new Thread(transable);
						thread.start();
					}
				}
			}
			class Bank{
				private int[] count = new int[10];
				public Bank(){
					for(int i=0;i<10;i++){
						this.count[i] = 1000;
					}
				}
				public  void  trans(String name,int from,int to,int n) throws InterruptedException{
					if(count[from]>n){
						count[from]-=n;
						System.out.print("");
						count[to]+=n;
						System.out.println(name+" ： 用户"+from+"向用户"+to+"转入："+n+"   目前总资金为:"+this.toString());
					}
				}
				@Override
				public String toString() {
					// TODO Auto-generated method stub
					int out = 0;
					for(int i:count)
						out+=i;
					return out+"";
				}
				public int[] getCount() {
					return count;
				}

				public void setCount(int[] count) {
					this.count = count;
				}
			}
			class Transable implements Runnable{


				private Bank bank;
				private int i;
				public Transable(Bank bank,int i){
					this.bank = bank;
					this.i = i;
				}
				@Override
				public void run() {
					// TODO Auto-generated method stub
					while(true){
						try {
							bank.trans("线程"+i, RandomUtils.nextInt(10), RandomUtils.nextInt(10), RandomUtils.nextInt(1000));

						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
			
					}
				}
	
			}

上述代码中会发生线程安全问题,对此有下面几个解决方案 


	//=============================================================。
			解决方法一
			public synchronized void  trans(String name,int from,int to,int n) throws InterruptedException{
					if(count[from]>n){
						count[from]-=n;
						System.out.print("");
						count[to]+=n;
						System.out.println(name+" ： 用户"+from+"向用户"+to+"转入："+n+"   目前总资金为:"+this.toString());
					}
				}	
			// 方法二
				public  void  trans(String name,int from,int to,int n) throws InterruptedException{
						lock.lock();
						try{
						while(count[from]>n){
							count[from]-=n;
							System.out.print("");
							count[to]+=n;
							System.out.println(name+" ： 用户"+from+"向用户"+to+"转入："+n+"   目前总资金为:"+this.toString());
						}
						}finally{
							lock.unlock();
						}
					}				
				// 用条件对象改进 解决方法三
				// 测试时，为试着将n改为 2*n 由于条件对象，照样可以运行，但是几秒之后发生死锁问题
				public  void  trans(String name,int from,int to,int n) throws InterruptedException{
					lock.lock();
					try{
					while(count[from]<n)
						condition.await();
						count[from]-=n;
						System.out.print("");
						count[to]+=n;
						System.out.println(name+" ： 用户"+from+"向用户"+to+"转入："+n+"   目前总资金为:"+this.toString());
						condition.signalAll();
					}finally{
						lock.unlock();
					}
				}
				// 用synchronized 方法代替显式的锁，很方便，代码如下，与上面的代码功能一样  解决方法四
					public synchronized  void  trans(String name,int from,int to,int n) throws InterruptedException{
							while(count[from]<n)
								wait();
								count[from]-=n;
								System.out.print("");
								count[to]+=n;
								System.out.println(name+" ： 用户"+from+"向用户"+to+"转入："+n+"目前总资金为:"+this.toString());
								notifyAll();
					}
				// 前面3，4方法都有死锁。有一个解决方法是，给wait（）一个时间限制，超时后，自动退出
				public  void  trans(String name,int from,int to,int n) throws InterruptedException{
						lock.lock();
						try{
						while(count[from]<n)
							if(!condition.await(100, TimeUnit.MILLISECONDS)){
								System.out.println("遇到死锁，此交易退出!!");
								return;
							}
							count[from]-=n;
							count[to]+=n;
							System.out.println(name+" ： 用户"+from+"向用户"+to+"转入："+n+"   目前总资金为:"+this.toString());
							condition.signalAll();
						}finally{
							lock.unlock();
						}
					}


6.阻塞队列

将线程安全等问题交给阻塞队列 
	public class BlockingQueueTest {


				public static String src = "/usr/spring-framework-2.5.5_src";
				public static void main(String[] args) {
					BlockingQueue<File> queue = new ArrayBlockingQueue<File>(19999);
					new Thread(new Find(queue, src)).start();
					for(int i = 0;i<10;i++)
					new Thread(new search(queue, "volatile")).start();
				}
			}


			class Find implements Runnable{
				private BlockingQueue<File> queue;
				private String firstFileName;
				public Find(BlockingQueue<File> queue, String firstFileName) {
					super();
					this.queue = queue;
					this.firstFileName = firstFileName;
				}
				@Override
				public void run() {
					File file = new File(firstFileName);
					try {
						findFile(file);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
	
				private void findFile(File file) throws InterruptedException{
					if(file.isDirectory()){
						File[] f = file.listFiles();
						for(File tmp:f){
							findFile(tmp);
						}
					}else{
						if(!queue.offer(file, 1000, TimeUnit.MILLISECONDS))
							System.out.println("添加失败");
					}
				}
			}
			class search implements Runnable{
				private BlockingQueue<File> queue;
				private String keyWords;
				public search(BlockingQueue<File> queue, String keyWords) {
					super();
					this.queue = queue;
					this.keyWords = keyWords;
				}
				@Override
				public void run() {
					// TODO Auto-generated method stub
					boolean b = true;
					try {
						while(b){
						File f = queue.poll(1000, TimeUnit.MILLISECONDS);
						if(f==null){
							b = false;
						}else{
							Scanner in = new Scanner(f);
							int len = 0;
							String tmp = "";
							while(in.hasNext()){
								len++;
								tmp = in.nextLine();
								if(tmp.contains(keyWords)){
									System.out.println("文件名为:"+f.getName()+" 第"+len+"行 : ");
									System.out.println("			"+tmp);
								}
							}
						}
						queue.peek();
						}
					} catch (Exception e) {
						e.printStackTrace();
					}finally{
					}
				}
			}


7.Future  封装一个有返回值的一部运行任务,相当于有返回值的Runnable

	//Callable 相当于一个带有参数的Runable


			public class FutureTest {


				public static String src = "/usr/spring-framework-2.5.5_src/src";
				public static String key = "class";
				public static void main(String[] args) throws InterruptedException, ExecutionException {
					FutureTask<Integer> futureTask = new  FutureTask<Integer>(new Find(new File(src), key));
					new Thread(futureTask).start();
					System.out.println("个数为:"+futureTask.get());
				}
			}
			class Find implements Callable<Integer>{
				private File firstFile;
				private String key;
				private int count;
				public Find(File file,String key) {
					super();
					this.firstFile = file;
					this.key = key;
				}
				private Integer findFile(File file) throws InterruptedException, ExecutionException{
					List<Future<Integer>> list = new ArrayList<Future<Integer>>();
					if(file.isDirectory()){
						File[] f = file.listFiles();
						for(File tmp:f){
							if(tmp.isDirectory()){
								FutureTask<Integer> futureTask = new  FutureTask<Integer>(new Find(tmp, key));
								list.add(futureTask);
								new Thread(futureTask).start();
							}else{
								if(search(tmp))
									count++;
							}
						}
					}else{
						if(search(file))
							count++;
					}
					for(Future<Integer> future:list){
						count+=future.get();
					}
					return count;
				}
				public boolean search(File f) {
					try {
						if(f==null){
							return false;
						}else{
							Scanner in = new Scanner(f);
							String tmp = "";
							while(in.hasNext()){
								tmp = in.nextLine();
								if(tmp.contains(key)){
									return true;
								}
							}
						}
					} catch (Exception e) {
						e.printStackTrace();
					}finally{
					}
					return false;
				}
				@Override
				public Integer call() throws Exception {
					try {
						return findFile(firstFile);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					return null;
				}
			}



8,连接池

//简单使用连接池只需要将上面的代码修改下 

				public class ThreadPoolTest {


					public static String src = "/usr/spring-framework-2.5.5_src/src";
					public static String key = "class";
					public static void main(String[] args) throws InterruptedException, ExecutionException {
				//		FutureTask<Integer> futureTask = new  FutureTask<Integer>(new FindByPool(new File(src), key));
				//		new Thread(futureTask).start();
				//		System.out.println("个数为:"+futureTask.get());
						ExecutorService service = Executors.newCachedThreadPool();
						Future<Integer> future = service.submit(new FindByPool(new File(src), key,service));
						System.out.println(future.get());
					}
				}
				class FindByPool implements Callable<Integer>{
					private File firstFile;
					private String key;
					private ExecutorService service;
					private int count;
					public FindByPool(File file, String key2, ExecutorService service) {
						// TODO Auto-generated constructor stub
						this.firstFile = file;
						this.key = key2;
						this.service =  service;
					}
					private Integer findFile(File file) throws InterruptedException, ExecutionException{
						List<Future<Integer>> list = new ArrayList<Future<Integer>>();
						if(file.isDirectory()){
							File[] f = file.listFiles();
							for(File tmp:f){
								if(tmp.isDirectory()){
									FindByPool pool = new FindByPool(tmp,key,service);
									list.add(service.submit(pool));
								}else{
									if(search(tmp))
										count++;
								}
							}
						}else{
							if(search(file))
								count++;
						}
						for(Future<Integer> future:list){
							count+=future.get();
						}
						return count;
					}
					public boolean search(File f) {
						try {
							if(f==null){
								return false;
							}else{
								Scanner in = new Scanner(f);
								String tmp = "";
								while(in.hasNext()){
									tmp = in.nextLine();
									if(tmp.contains(key)){
										return true;
									}
								}
							}
						} catch (Exception e) {
							e.printStackTrace();
						}finally{
						}
						return false;
					}
					@Override
					public Integer call() throws Exception {
						try {
							if(firstFile!=null)
							return findFile(firstFile);
							else return 0;
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						return 0;
					}
				}

上面就是简单使用Java多线程的部分,还有关于线程安全与高并发部分的内容没有写出来.尽快补上


RunningCaiCai
关注
专栏目录
Java多线程：线程状态探究
流楚丶格念的博客
07-16 1284
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？Java中的线程状态被定义在了java.lang.Thread.State枚举类中，State枚举类的源码如下： 翻译过来就是 我们可以看到Java中的线程存在6种状态，每种线程状态的含义如下各个状态的转换，如下图所示：需求：编写一段代码，依次显示一个线程的这些状态：NEW -> RUNNABLE -> TIME_WAITING -> RUNNABLE ->
JAVA多线程基础篇
北漂的PHPcoder
07-21 211
JAVA多线程篇线程CPU并行并发JAVA中的多线程线程间数据共享AQSCASSringBoot 中应用多线程 线程 进程、线程、协程的概念在多个语言中都有不同的提现，例如JAVA中存在进程+主线程+子线程的概念，GO中的进程+主线程+协程的概念，PHP中的进程+主线程都有不用的解决方案，但是我们还是要明确各个名词的概念 CPU 并行 并发 JAVA中的多线程 线程间数据共享 AQS CAS SringBoot 中应用多线程 ...
Java 多线程锁的深入探究
道长的博客
07-11 364
在 Java 多线程编程中，锁是确保线程安全和避免数据竞争的重要工具。本文将深入探讨 Java 中常见的几种锁机制，帮助您更好地理解和应用多线程编程。
Java虚拟线程探究与性能解析
淘系技术
08-28 7049
虚拟线程是由Java运行时而不是操作系统实现的Java线程，和传统线程(或称之为平台线程)之间的主要区别在于，我们可以很容易地在同一个Java进程中运行大量活动的虚拟线程，甚至数百万个。大量的虚拟线程赋予了它们强大的功能：通过允许服务器并发处理更多的请求，它们可以更有效地运行以thread-per-request（每个请求一个线程）的方式编写的服务器应用程序，从而实现更高的吞吐量和更少的硬件浪费。...
JAVA多线程基础
PC1123的博客
03-14 373
目录 线程的创建 Thread Runnable 区别 线程的创建流程图 线程常用方法 第一类： 第二类： 两种线程模式： 线程的生命周期： 死锁 概念 释放锁 多线程售票问题 遇见的问题 解决方案 线程相关概念 程序：是一些指令的集合，也就是我们写的代码 进程：就是运行中的程序，操作系统会为一个进程分配内存空间，分配资源。 进程是程序的一次执行过程，是动态过程：有它自身的产生、存在和消亡的过程 线程：由进程创建的，是进程的一个实体,一个进程可
深入探究Java多线程并发编程的要点
09-03
Java多线程并发编程是Java开发中的重要领域，它涉及到如何高效、安全地在多个线程之间共享资源。本文将深入探讨Java多线程并发编程的要点，特别是关键字`synchronized`的使用以及`wait()`与`notify()`在获取对象锁...
Java多线程同步问题的探究.pdf
10-24
在探究Java多线程同步问题时，需要关注的关键知识点包括synchronized关键字的使用、JDK 5引入的java.util.concurrent.locks包下的锁机制、以及JDK 1.2中ThreadLocal类的使用。此外，了解JVM（Java虚拟机）在处理多...
Java多线程start（）方法原理解析
08-25
然而，很多开发者对start（）方法的原理和实现机制不甚了解，本文将深入探究Java多线程start（）方法的原理和实现机制。 为什么启动线程不用run（）方法而是使用start（）方法？ 很多开发者可能会问，为什么启动...
Java学习教程-探究JAVA线程状态及转化视频
06-16
在Java中，线程的状态及其转换是非常关键的概念，理解和掌握这些可以帮助我们编写出更加高效、稳定的多线程程序。本教程将深入探讨Java线程的五种基本状态以及它们之间的转换。 1. **新建（New）**：当使用`Thread`...
基于ssm的二手车交易网站设计与实现.docx
09-17
基于ssm的二手车交易网站设计与实现.docx
zotero 6 插件,包含茉莉花、DOI、绿青蛙、sci-hub等11个常用插件
09-17
zotero 6 插件，茉莉花、DOI、绿青蛙、sci-hub、Better notes、GPT、IF、PDF翻译、Style、TAG、影响因子
linux_命令_tail_的升级版，可使用_tails_同时跟踪多个文件并格式化输出成更方便查看的_tails.zip
最新发布
09-17
linux_命令_tail_的升级版，可使用_tails_同时跟踪多个文件并格式化输出成更方便查看的_tails
基于ssm的房屋出租出售系统设计与实现.docx
09-17
基于ssm的房屋出租出售系统设计与实现.docx
jdk9 免安装包，配置环境变量即可
09-17
jdk9 免安装包，配置环境变量即可
吉他谱_Sonne - Rammstein.pdf
09-17
初级入门吉他谱 guitar tab
思科合作伙伴工程师技术参考手册_V2_20080228.pdf
09-17
cisco设备配置指导
Java项目-基于SSM+Jsp的彩妆小样售卖商城的设计与实现（源码+数据库脚本+部署视频+代码讲解视频+全套软件）
09-17
【基于SSM+Jsp的彩妆小样售卖商城的设计与实现】高分通过项目，已获导师指导。 本项目是一套基于SSM+Jsp的彩妆小样售卖商城，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的Java学习者。也可作为课程设计、期末大作业 包含：项目源码、数据库脚本、开发说明文档、部署视频、代码讲解视频、全套软件等，该项目可以直接作为毕设使用。 项目都经过严格调试，确保可以运行！
一个自用的中秋数据集，拿来玩的，没啥用
09-17
数据集
基于ssm的弹幕视频网站设计与实现.docx
09-17
基于ssm的弹幕视频网站设计与实现.docx
Java多线程并发编程详解：synchronized与wait/notify机制
深入探究Java多线程并发编程的要点主要聚焦于如何在Java中有效地管理线程之间的交互和同步。首先，我们关注的是关键字`synchronized`的使用，它是Java中实现线程同步的关键机制。`synchronized`可以用于修饰函数或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值