Java多线程

最新推荐文章于 2024-07-11 16:53:39 发布
最新推荐文章于 2024-07-11 16:53:39 发布
阅读量150 收藏 1
点赞数 1
文章标签： 大数据 java eclipse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vn666/article/details/125684886
版权

线程:

       是进程里面执行的最小单位,可完成一个独立的循环进程Java虚拟机允许应用程序并发地执行多个线程没个线程都有一个优先级,高优先级的线程优先执行与低线程优先级

1:进程的状态:

        1):就绪状态(Ready)

        2):运行状态(Running)

        3):阻塞状态(Blocked)

多线程:

在一个进程中存在多个线程同时运行,这称为多线程

        优点:充分利用CPU的资源

                简化编程模型

                良好的用户体验

主线程:

  • Thread类
  • 主线程

                main()方法即为主线程入口

                产生其他子线程的进程

                必须最后完成,因为他需要执行各种关闭操作

	public class ThreadDemo01 {
	
		public static void main(String[] args) {
			//main()方法是线程的主入口,是一个线程
			//获取当前的线程对象
			Thread thread=Thread.currentThread();
			System.out.println("当前的线程对象 "+thread);
			
			//获取当前线程名称
			String name =thread.getName();
			System.out.println(name);
			
			//获取线程优先级
			int priority=thread.getPriority();
			System.out.println(priority);
			
			//设置线程的名字
			thread.setName("小丑");
			System.out.println("线程名称 "+thread.getName());
			
			System.out.println("线程的最高级为: "+thread.MAX_PRIORITY);
			System.out.println("线程的最低级为: "+thread.MIN_PRIORITY);
			System.out.println("线程的默认级为: "+thread.NORM_PRIORITY);
		}
	
	}
	
	运行结果:
		当前的线程对象 Thread[main,5,main]
		main
		5
		线程名称 小丑
		线程的最高级为: 10
		线程的最低级为: 1
		线程的默认级为: 5

线程的创建

  1. 通过继承Thread类
  2. 通过实现Runnable接口实现

线程启动的步骤:定义线程--->创建线程对象--->启动线程--->启动线程

继承Thread类 

  1. 创建MyThread类并继承Thread类
  2. 重写Thread中的run()方法
  3. 创建MyThread类对象并调用start()方法启动线程
	public class MyThread extends Thread{
		public MyThread(String name) {
			super(name);
		}
		public MyThread() {
		}
		/**
		 * 将类定义成线程类,可以通过Thread类
		 */
		public void run(){
			for (int i = 0; i <20; i++) {
				System.out.println(Thread.currentThread().getName()+"-"+i);
			}
		}
	}
	public class Test {
	
		public static void main(String[] args) {
			MyThread mt=new MyThread("小丑");
			MyThread mt1=new MyThread("占卜家");
			//start()是开始线程的而不是调用run()方法
			mt.start();
			mt1.start();
		}
	
}

实现Runnable接口

  1. 创建MyRunnable类并实现Runnaable接口
  2. 实现run()方法,执行线程执行体
  3. 调用start()方法启动线程
	public class MyRunnable implements Runnable{
		//避免单继承
		@Override
		public void run() {
			for (int i = 0; i < 20; i++) {
				System.out.println(Thread.currentThread().getName()+"-"+i);
			}
		}
	}
	
	public class Test {
	
		public static void main(String[] args) {
			MyRunnable mr=new MyRunnable();
			//重新调用Thread里面的构造,传入MyRunnable类型的接口
			//通过实现Runnable接口,来实现Thread的构造方法
			Thread th=new Thread(mr,"你");
			Thread th1=new Thread(mr,"我");
			th.start();
			th1.start();
		}
	
}

两类线程的比较:

        继承Thread类:比较简单,可以直接调用对象操作

        实现Runnable接口:可以避免单继承,可以实现更多的资源共享

线程的状态

 线程休眠

       线程的休眠,目的是让出CPU的时间,让其他的线程可以执行,但不会释放对象锁,同时线程不会让出任何显示器的所有权

       线程被中断后,会抛出InterruptedException异常,当前线程的中断状态会被清除.

public class ThreadDemo01 {

	public static void main(String[] args) {
		MyThread mt=new MyThread("小丑");
		//start()是开始线程的而不是调用run()方法
		
		MyRunnable mr=new MyRunnable();
		Thread mt1=new Thread(mr,"占卜家");
		mt.start();
		mt1.start();
	}
}

/**
 * 继承Thread类的线程
 */
 class MyThread extends Thread{
	public MyThread(String name) {
		super(name);
	}
	public MyThread() {
	}
	
	 //将类定义成线程类,可以通过Thread类	 
	public void run(){
		for (int i = 0; i <20; i++) {
			System.out.println(Thread.currentThread().getName()+"-"+i);
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
 
 /**
  * 实现Runnable接口实现的线程
  */
class MyRunnable implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			System.out.println(Thread.currentThread().getName()+"-"+i);
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
	}
	
}

join方法和中断线程

join方法:

      加入线程,让调用的线程先执行指定时间或执行完毕  //强制执行

 中断线程:

     1:使用interrput方法中断线程,但是会清除中断线程,需要设置一个中断状态

     2:自定义中断线程(更加推荐使用)

public class ThreadDemo02 {

	public static void main(String[] args) {
		MyRunnable1 mr=new MyRunnable1();
		Thread t=new Thread(mr,"小丑");
//		t.start();
		
		
		MyRunnable2 mr2=new MyRunnable2();
		Thread t2=new Thread(mr2,"占卜家");
		t2.start();
		for (int i = 0; i <50; i++) {
			System.out.println(Thread.currentThread().getName()+"-"+i);//main方法的线程
			 try {
				Thread.sleep(300);
			} catch (InterruptedException e) {  
				e.printStackTrace();
			}
		if(i==20){
			/*try {
				t.join();//让t线程执行完毕
			} catch (InterruptedException e) {
				e.printStackTrace();
			}*/
//			t.interrupt();
			 mr2.flag=false;//可以调用自定义的异常终止程序
		}
	}

} 
}
class MyRunnable1 implements Runnable{

	@Override
	public void run() {
		for (int i = 0; i <50; i++) {
			if(Thread.interrupted()){//清除中断状态,会把中断状态清除
				break;
			}
			System.out.println(Thread.currentThread().getName()+"-"+i);
			 try {
				Thread.sleep(300);
			} catch (InterruptedException e) {  
				e.printStackTrace();
				Thread.currentThread().interrupt();
			}
		}	
	}
}

class MyRunnable2 implements Runnable{
	boolean flag=true;

	public MyRunnable2(){
		flag=true;
	}
	@Override
	public void run() {
		int i=0;
		while(flag){
			System.out.println(Thread.currentThread().getName()+"--"+(i++));
			try {
				Thread.sleep(300);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
	}
	
}

yiled()方法

会提供一次其它线程去占用cpu资源的机会,但是本身也会去占用cpu的资源

	public class YieldTest {
	
		public static void main(String[] args) {
			MyRunnable mr=new MyRunnable();
			Thread tr=new Thread(mr);
			tr.start();
			
			for (int i = 0; i < 10; i++) {
				System.out.println(Thread.currentThread().getName()+" "+i);
				if(i==5){
					System.out.print(Thread.currentThread().getName()+"线程礼让 ");
					Thread.yield();
				}
			}
		}
	
	}
	
	class MyRunnable implements Runnable{
	
		@Override
		public void run() {
			for (int i = 0; i < 10; i++) {
				System.out.println(Thread.currentThread().getName()+" "+i);
				if(i==5){
					System.out.print(Thread.currentThread().getName()+"线程礼让 ");
					Thread.yield();
				}
			}
		}
		
	}
	
	运行结果:
	main 0
	main 1
	main 2
	main 3
	main 4
	main 5
	main线程礼让 Thread-0 0//本该是main线程运行,确由Thread-0去运行
	Thread-0 1
	Thread-0 2
	main 6
	Thread-0 3
	main 7
	main 8
	main 9
	Thread-0 4
	Thread-0 5
	Thread-0线程礼让 Thread-0 6
	Thread-0 7
	Thread-0 8
	Thread-0 9

多线程共享调度问题及解决

在线程多线程调度的时候.会出现在抢占CPU资源的时候导致原本的输出信息错误

	public class SynchronizedTest {
		
		public static void main(String[] args) {
			Piao piao=new Piao();
			Thread tr=new Thread(piao,"张三");
			Thread tr1=new Thread(piao,"李四");
			Thread tr2=new Thread(piao,"王二");
			
			tr.start();
			tr1.start();
			tr2.start();
		}
	}
	
	class Piao implements Runnable{
		//买到票的数量
		public int num=10;
		//剩余票的数量
		public int count=0;
	
		@Override
		public void run() {
			while(true){
				if(num<=0){
					break;
				}
				num--;//没买一次票数量加一
				count++;//没买一次票,票的数目减一
				try {
					Thread.sleep(500);//模拟网络延迟500ms 
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()
						+"抢到第"+count+"张票,剩余"+num+"张票");
			}
		}
	}
	
	运行结果:
	李四抢到第3张票,剩余7张票
	王二抢到第3张票,剩余7张票
	张三抢到第3张票,剩余7张票
	李四抢到第6张票,剩余4张票
	王二抢到第6张票,剩余4张票
	张三抢到第6张票,剩余4张票
	王二抢到第9张票,剩余1张票
	张三抢到第9张票,剩余1张票
	李四抢到第9张票,剩余1张票
	王二抢到第10张票,剩余0张票

 结论:结果可以表面,有人同时抢到了第3张票,剩余的票数也会出现相同,发生就这错误就是因为多线程在抢占CPU资源的时候不考虑到线程的执行是否结束就已经被下一个线程所占用,从而导致原本线程输出的信息发生了偏差

解决方案:

运用synchronized

作用:在线程执行的时候相当于加了一把锁,该线程的运行结果会返回给线程中去,

        而不会被其他线程占用后改变线程的运行结果

1:使用synchronized修饰的方法控制对类成员变量的访问

访问修饰符 synchronized  返回类型 方法名（参数列表）{……}

或者

synchronized 访问修饰符 返回类型 方法名（参数列表）{……

2;使用synchronized关键字修饰的代码块

这里举例了第二种解决方案的代码示例:

			public class SynchronizedTest {
				
				public static void main(String[] args) {
					Piao piao=new Piao();
					Thread tr=new Thread(piao,"张三");
					Thread tr1=new Thread(piao,"李四");
					Thread tr2=new Thread(piao,"王二");
					
					tr.start();
					tr1.start();
					tr2.start();
				}
			}
			
			class Piao implements Runnable{
				//剩余票的数量
				public int num=200;
				//买到票的数量
				public int count=0;
				
				@Override
				public void run() {
					while(true){
						synchronized(this){
							if(num<=0){
								break;
							}
							num--;//没买一次票数量减一
							count++;//没买一次票,票的数目加一
							try {
								Thread.sleep(300);//模拟网络延迟500ms 
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
							System.out.println(Thread.currentThread().getName()
									+"抢到第"+count+"张票,剩余"+num+"张票");
						}
					}
				}
}

面对这种问题,衍生出了线程安全的问题:

方法是否同步

 效率比较

适合场景

线程安全

是

低

多线程并发共享资源

非线程安全

否

高

单线程

 

常见的类型对比:

Hashtable和HashMap

                Hashtable:

                        继承关系

                        实现了Map接口，Hashtable继承Dictionary类

                        线程安全，效率较低

                        键和值都不允许为null

                HashMap:

                        继承关系

                        实现了Map接口，继承AbstractMap类

                        非线程安全，效率较高

                        键和值都允许为null

 

        StringBuffer  &&  StringBuilder

                        前者线程安全，后者非线程安全

忆丶长安
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 13万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程（超详细！）
热门推荐
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
Java多线程详解及示例
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
java多线程
05-02
Java多线程是Java编程中的核心概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：通过实现`Runnable`接口和继承`Thread`类。 1. 实现Runnable接口 当一个类...
Java多线程下载器
09-26
Java多线程下载器是一种利用Java编程语言实现的高效文件下载工具，它通过将大文件分割成多个部分并同时下载，显著提高了下载速度。在Java中实现多线程下载器涉及许多关键概念和技术，包括线程、并发控制、网络I/O...
rabbitmq集群创建admin用户之后，提示can access virtual hosts是No access状态
jiang0615csdn的博客
07-11 82
rabbitmq集群创建admin用户之后，提示can access virtual hosts是No access状态
阶段三：项目开发---大数据开发运行环境搭建:任务8：安装配置Redis
qq_60872637的博客
07-07 1232
安装配置Redis： 安装配置Redis：无Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI编写、支持网络、可基于内存亦可持久化的日志型、Key-Value，并提供多种语言的API。任务主要内容是Redis的下载安装，启动测试以及出现问题的相应解决方法。
kibana连接elasticsearch(版本8.11.3)
最新发布
abments的博客
07-11 454
kibana连接elasticsearch(版本8.11.3)
分布式系统—ELK日志分析系统概述及部署
aran2002的博客
07-08 1508
ELK是Elasticsearch、Logstash、Kibana三大开源框架首字母大写简称，但是filebeat可以用来替代logstash的数据收集功能，比较轻量级。市面上也被称为Elastic Stack。2.ELK组件ElasticSearch：是基于Lucene（一个全文检索引擎的架构）开发的分布式存储检索引擎，用来存储各类日志。Elasticsearch 是用 Java 开发的，可通过 RESTful Web 接口，让用户可以通过浏览器与 Elasticsearch 通信。
【分布式系统】ELK 企业级日志分析系统
F12138X的博客
07-06 1093
纵使黑夜吞噬了一切，太阳还是可以重新回来
RabbitMQ安装使用遇到的问题
清梦的博客
07-08 281
RabbitMQ运行需要Erlang环境，所以需要先安装Erlang。执行Erlang.exe完成Erlang安装，需要在环境变量写上Erlang的位置。，除了环境变量中写错了安装位置外，还有一种可能，环境变量还未起效，需要重启电脑。运行RabbitMQ-server.exe，中途退出，安装失败，弹出。，需要先安装Erlang。
学习小记-Netty
weixin_42029860的博客
07-06 238
Netty是由JBOSS个java开源框架，Netty提供异步的、事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络服务器和客户端程序。
Elasticsearch 多索引/多类型搜索
Dxy1239310216的博客
07-10 731
Elasticsearch的多索引搜索功能为跨多个数据集进行联合查询提供了极大的便利。通过灵活使用索引名、通配符和组合查询等技巧，可以构建出复杂而强大的搜索查询。然而，随着Elasticsearch版本的更新和演进，一些旧的功能（如类型）可能会被废弃或移除，因此在设计和实现多索引/多类型搜索时，需要关注Elasticsearch的最新动态和最佳实践。
阶段三：项目开发---民航功能模块实现：任务18：指挥航空公司架次与延误率占比
qq_60872637的博客
07-08 969
在前面的“使用Spark清洗统计业务数据并保存到数据库”任务中，已经通过Spark Streaming 清洗程序，将Kafka中Topic为“task_Aftn”的报文数据，经过数据清洗后，保存到了MySQL数据库中；本节任务内容，通过统计查询，计算总架次数和延误架次数的一个比例，即指挥航空公司架次与延误率占比。6学时Vue和iView熟悉，内部推送和邮件推送处理熟悉ECharts双Y轴展示，赋值。
Java多线程.pdf
09-28
"这份资料详细介绍了Java多线程编程的相关知识，包括线程的创建、线程安全和锁机制，以及线程池的使用。" 在Java编程中，多线程技术是核心概念之一，它允许程序同时执行多个任务，提高了程序的效率和响应性。Java多...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值