Java个人学习之旅(第十八天)

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

多线程

1. 常用方法:

  1. start():启动当前线程；调用当前线程的run()

  2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中

  3. currentThread():静态方法，返回执行当前代码的线程

  4. getName():获取当前线程的名字

  5. setName():设置当前线程的名字

  6. yield():释放当前cpu的执行权

  7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。

  8. stop():已过时。当执行此方法时，强制结束当前线程。

  9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。

  10. isAlive():判断当前线程是否存活

代码示例:

  1. 匿名内部实现Runnable接口
@Test
	public void test01() {
		Runnable r = new Runnable() {

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

		for (int i = 0; i < 50; i++) {
			if (i % 5 == 0) {
				new Thread(r, "线程1").start();
				new Thread(r, "线程2").start();
			}
		}
	}

运行结果:
在这里插入图片描述

  1. sleep()方法:
class MyThread extends Thread{

	@Override
	public void run() {
		for(int i=0;i < 50;i++){
			if (i%5 == 0) {
				try {
					System.out.println("睡眠开始");
					MyThread.sleep(1000);
					System.out.println("睡眠结束");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(this.getName() + " : " + i);
			}
		}
	}
}

public class SleepT {
	public static void main(String[] args) {
		new MyThread().start();
		new MyThread().start();
	}
}

运行结果:
在这里插入图片描述
每打印一次都会等待1S以上

  1. join()方法的使用:
class MyThread1 extends Thread{

	@Override
	public void run() {
		for(int i=0;i < 50;i++){
			System.out.println(this.getName() + " : " + i);
		}
	}
}

public class JoinT {
	public static void main(String[] args) throws InterruptedException {
		
		MyThread1 mt = new MyThread1();
		mt.start();
		mt.join();
		
		for(int i=0;i < 20;i++){
			System.out.println("--------------当前线程----------------" + Thread.currentThread().getName());
		}
	}
}

运行结果:
在这里插入图片描述
可以看到,Thread-0线程结束后main线程才开始执行

  1. yield()方法得使用
public class YThread {
	public static void main(String[] args) {
		
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for(int i=0;i < 100;i++){
					if (i == 20) {
						System.out.println("线程让步");
						Thread.currentThread().yield();
						System.out.println("线程回来");
					}else {
						System.out.println("线程1" + " : " + i);
					}
				}
			}
		});
		
		Thread t2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for(int i=0;i < 100;i++){
					System.out.println("线程2" + " : " + i);
				}
			}
		});
		
		t1.start();
		t2.start();
	}
}

运行结果:
在这里插入图片描述

可以看到,让步后的线程暂时会失去CPU时间片的争夺权

2. 线程的分类:

守护线程

  • 最后执行的线程,一般用于JVM的垃圾回收机制

用户线程

  • 用户线程就是普通线程

守护线程

class D1 extends Thread{

	@Override
	public void run() {
		for(int i=0;i < 2000;i++){
			System.out.println("-----------守护线程执行------------" + this.getName() + ":" + i);
		}
	}	
}
class D2 extends Thread{

	@Override
	public void run() {
		for(int i=0;i < 1000;i++){
			System.out.println("-----------------------" + this.getName() + ":" + i);
		}
	}
	
}

public class DThread {
	
	public static void main(String[] args) {

		for(int i=0;i < 100;i++){
			System.out.println("------当前线程执行" + Thread.currentThread().getName());
		}
		
		D1 d1 = new D1();
		//在启动线程之前设置为守护线程
		d1.setDaemon(true);
		d1.setName("守护线程");
		d1.start();
		
		D2 d2 = new D2();
		d2.setName("普通线程");
		d2.start();
	}
}

运行结果:
在这里插入图片描述
可以看到,守护线程都是最后执行的且不一定需要执行完毕的,要根据是否还有用户线程在运行来判断自身是否要提早结束
同时,守护线程的执行周期要比其他所有普通线程要长,确保最后执行,且能够对普通线程的执行结果做处理

3. 线程的优先级：

线程的优先级分为10个等级:1-10

最高等级:MAX_PRIORITY：10

最低等级:MIN _PRIORITY：1

默认等级:NORM_PRIORITY：5

优先级越高,线程分到时间片的概率也就越大,但这并不是说优先级高的线程一定比优先级低的线程先执行完

两个方法:

  1. getPriority() ：返回线程优先值

  2. setPriority(int newPriority) ：改变线程的优先级

说明:

  • 线程创建时继承父线程的优先级

  • 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

代码示例:

class T1 extends Thread{

	String name;

	public T1(String name) {
		super();
		this.name = name;
	}
	
	@Override
	public void run() {
		for(int i=0;i < 50;i++){
			System.out.println(name + " : " + i);
		}
	}
}

public class PThread {

	public static void main(String[] args) {		
		T1 t1 = new T1("大佬");
		T1 t2 = new T1("小弟");
		
		//设置大佬的优先级为10
		t1.setPriority(10);
		//设置大佬的优先级为1
		t2.setPriority(1);
		
		t1.start();
		t2.start();
	}
}

运行结果:

在这里插入图片描述
可以看到,"大佬"占用的时间片比较多

4. 线程的生命周期:

  1. 新建
    当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建 状态

  2. 就绪
    处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已 具备了运行的条件，只是没分配到CPU资源

  3. 运行
    当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线 程的操作和功能

  4. 阻塞
    在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中 止自己的执行，进入阻塞状态

  5. 死亡
    线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

5. 同步机制：

当多条线程并发执行时,可能会发生两条线程都要处理同一个数据的情况,就比如两个人同时上网去买火车票,火车票只有一张了,如果没有同步机制,那么两个人都会买到火车票,但是其实火车票只有一张,这样就会闹出乌龙

synchronized是JDK为多线程提供的一种同步锁,如果多条线程需要处理同一个对象,就需要用到线程同步

synchronized说明:

  • 既可以同步对象,也可以同步方法

  • 先解锁方法,再解锁对象

代码示例:

public class Test4 {
	public static void main(String[] args) {
		Shower s = new Shower();
		
		new Thread() {

			@Override
			public void run() {
				//调用方法一
				s.show();
			}
		}.start();
		
		new Thread() {

			@Override
			public void run() {
				//调用方法二
				s.show2();
			}
		}.start();
	}
	
}

//先解锁方法再解锁对象
class Shower {
	//锁方法
	public synchronized void show() {
		System.out.print("长");
		System.out.print("恨");
		System.out.print("人");
		System.out.print("心");
		System.out.print("不");
		System.out.print("如");
		System.out.print("水");
	}
	//锁对象
	public void show2() {
		synchronized (this){	
		System.out.print("等");
		System.out.print("闲");
		System.out.print("平");
		System.out.print("地");
		System.out.print("起");
		System.out.print("波");
		System.out.print("澜");
		}
	}
}

运行结果:
在这里插入图片描述
当然,上面提到的买票也可以加锁:

class Tickets2 implements Runnable {

	private int ticket = 100;

	@Override
	public void run() {
		while (true) {
			//注意锁一定要加在判断的外面
			synchronized (Tickets2.class) {
				if (ticket > 0) {
					System.out.println(Thread.currentThread().getName() + "开始售票");
					System.out.println(Thread.currentThread().getName() + "正在售票,票号为" + (ticket--));
					System.out.println(Thread.currentThread().getName() + "已售票");
				} else {
					break;
				}
			}
		}
	}
}

public class Test3 {
	public static void main(String[] args) {
		Tickets2 t = new Tickets2();

		Thread t1 = new Thread(t, "线程1");
		Thread t2 = new Thread(t, "线程2");
		Thread t3 = new Thread(t, "线程3");

		t1.start();
		t2.start();
		t3.start();
	}
}

运行结果:
在这里插入图片描述
可以看到,每个线程都是等待其他线程执行完才开始执行的

Lock(锁)

ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和
内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以
显式加锁、释放锁。

代码格式:

public class Test7 {
	private final ReentrantLock lock = new ReentrantLock();
	
	public void m() {
		//加锁
		lock.lock();
		try {
			//保证线程安全的代码
		} catch (Exception e) {
			// 异常处理
			e.printStackTrace();
		}finally {
			//关锁,一定要关锁!!!
			lock.unlock();
		}
	}
}

synchronized 与 Lock 的对比

  1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是
    隐式锁，出了作用域自动释放

  2. Lock只有代码块锁，synchronized有代码块锁和方法锁

  3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有
    更好的扩展性（提供更多的子类）

优先使用顺序：
Lock -> 同步代码块（已经进入了方法体，分配了相应资源）  同步方法
（在方法体之外）

代码示例:

public class Test7 {

	public static void main(String[] args) {

		ReentrantLock lock = new ReentrantLock();

		new Thread(new Runnable() {

			@Override
			public void run() {
				//同步锁
				lock.lock();
				try {
					// 保证线程安全的代码
					System.out.println("第1次获得锁" + lock);
					int count = 1;

					while (true) {
						try {
							//上一个锁需要等待这个锁解锁
							lock.lock();
							System.out.println("第" + (++count) + "次得锁" + lock);
							Thread.sleep(1000);
						} catch (Exception e) {
							// TODO: handle exception
							e.printStackTrace();
						} finally {
							lock.unlock();
						}
						if (count == 10) {
							break;
						}
					}
				} catch (Exception e) {
					// TODO: handle exception
					e.printStackTrace();
				} finally {
					lock.unlock();
				}

			}
		}).start();
	}
}

运行结果:
在这里插入图片描述
多线程这一块还得多研究…

吉薇艾尔
关注
穿越编程 - Java学习之旅
weixin_47371330的博客
05-30 161
穿越Java 助力学习 目录 《穿越 Java 第一章 - 快速入门篇》 《穿越 Java 第十三章 - Spring 基础篇》 《穿越 Java 第二章 - 安装配置篇》 《穿越 Java 第十四章 - Spring 核心篇》 《穿越 Java 第三章 - 基础语法篇》 《穿越 Java 第十五章 - Spring 集成篇》 《穿越 Java 第四章 - 核心语法篇》 《穿越 Java 第十六章 - Spring Mvc篇》 《穿越 Jav
java学习资料整理(开发必备)
m0_67537062的博客
03-30 1万+
收集的java学习资料整理了下，里面包含了计算机基础、算法和数据结构、常用工具、java核心知识、性能优化、基础框架、数据库、消息队列、缓存中间件、搜索引擎、大数据、RPC、网关、容器、面试等知识
Java学习之旅（三十）：包装类之 Integer
jiaomubai的博客
12-06 865
java.lang 包中的 Integer 类、Long 类和 Short 类，可将基本类型 int、long 和 short 封装成一个类。这些类都是 Number 的子类，区别就是封装了不同的数据类型。以 Integer 类为例，Integer 类在对象中包装了一个基本类型 int 的值。该类的对象包含一个 int 类型的字段。此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，同时还提供了其他一些处理 int 类型时非常有用的常量和方法。 构造方法 Integer 提供
java+ElementUI前后端分离旅游项目第五天 移动端开发上
fegus的博客
06-08 1万+
了解常见的移动端开发方式随着移动互联网的兴起和手机的普及，目前移动端应用变得愈发重要，成为了各个商家的必争之地。例如，我们可以使用手机购物、支付、打车、玩游戏、订酒店、购票等，以前只能通过PC端完成的事情，现在通过手机都能够实现，而且更加方便，而这些都需要移动端开发进行支持，那如何进行移动端开发呢？移动端开发主要有三种方式：1、基于手机API开发（原生APP）2、基于手机浏览器开发（移动web）3、混合开发（混合APP）手机端使用手机API，例如使用Android、ios 等进行开发，服务端只是一个数据提供
Java · PTA探险之旅
摸鱼大师丶苏晓辉
05-13 1万+
极光 · Java · 常用书写学习 package ASRC; import java.util.Scanner; import java.lang.Math; public class Core { public static void main(String[] args) {//内层main可以小写 Scanner input = new Scanner(System.in);//输入启动前置 //double a = input.nextDouble
Java修仙之路，十万字吐血整理全网最完整Java学习笔记（基础篇）
vincewm的博客
01-05 5821
从Java环境的搭建到实际代码的编写，从基本用法的讲解到底层原理的剖析，深度解析Java基础知识。本文是《Java学习路线》专栏的起始文章，旨在提供一套完整的Java学习路线，覆盖Java基础知识、数据库、SSM/SpringBoot等框架、Redis/MQ等中间件、设计模式、架构设计、性能调优、源码解读、核心面试题等全面的知识点，并在未来不断更新和完善，帮助Java从业者在更短的时间内成长为高级开发。
Java 零基础入门学习（小白也能看懂！）
热门推荐
QQ3447387928的博客
01-18 2万+
📚博客主页：爱敲代码的小杨.✨专栏：《Java SE语法》❤️感谢大家点赞👍🏻收藏⭐评论✍🏻，您的三连就是我持续更新的动力❤️ Java是一种优秀的程序设计语言，它具有令人赏心悦目的语法和易于理解的语义。不仅如此，Java还是一个有一系列计算机软件和规范形成的技术体系，这个技术体系提供了完整的用于软件开发和跨平台部署的支持环境，并广泛应用于嵌入式系统、移动终端、企业服务器、大型机等各种场合。以下 Java 特性来自 Java 白皮书因此：Java不仅仅是一门编程语言，也是一个由一些列计算机软件和规
【Java毕业设计】基于JavaWeb的旅游论坛管理系统
Zhangsama1的博客
06-06 8827
随着社会的进步、服务行业的服务水平不断发展与提高，宾馆、酒店、旅游等服务行业的信息量和工作量日益变大，而传统的人工管理方式已经远远不能满足现在旅游的服务方式[1]。21世纪以来，随着科学技术的飞速发展，计算机及其相关软件已经成为人们日常生活与工作中不可或缺的重要工具。在这个信息时代，人们对信息的要求日益增高，传统的信息处理方式已难以满足现代社会的需求。
穿越 Java 学习之旅
weixin_47371330的博客
07-21 360
目录 Java中的继承
突破性能瓶颈： Java 22的性能提升之旅
青云交的博客
05-16 468
本文深入探讨 Java 22 对实时系统的性能提升。包括 G1 垃圾回收器优化减少停顿时间，平均性能提升约 5%，特定场景可达 15%。API 和工具优化及增强的 Stream API 也为实时系统带来诸多好处。文中通过金融交易、工业自动化等多个实际案例及代码示例阐述其优势，还探讨了与响应式编程框架的结合。结尾鼓励读者分享经验，为实时系统开发提供参考。
通向架构师的道路（第二十四天）之Oracle性能调优-朝拜先知之旅.docx
10-27
Oracle性能调优-朝拜先知之旅 本文主要介绍了在 Linux 环境下安装 Oracle 10g 的方法，并对 Oracle 性能调优进行了详细的说明。下面是本文的知识点总结： 一、Oracle 基本概念 * Oracle 是一种关系型数据库管理...
毕业设计: Java项目之基于springboot基于SpringBoot的旅游网站的设计与实现（源码 + 数据库 + 论文）
04-02
论文目录: 第二章 系统开发关键技术 6 ...第五章 系统的实现 18 5.1登录界面 18 5.2管理员功能模块 18 5.3用户功能模块 20 第六章 系统测试 25 6.1系统测试的目的 25 6.2测试方法 25 6.3系统测试模块 25
Linux下编译Eclipse Paho库采用MQTT协议连接MQTT服务器
10-09 735
Eclipse Paho 是一个开源项目，由 Eclipse Foundation 主持，提供可靠的开源实现来处理 MQTT（Message Queuing Telemetry Transport）协议以及其他与物联网 (IoT) 相关的协议。MQTT 是一种轻量级的发布/订阅消息传输协议，专为具有低带宽和不可靠网络连接的设备设计。Paho 提供了多种语言的客户端库，使得开发者可以在各种平台上开发基于 MQTT 协议的应用程序。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1235
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 937
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
FoolRabbit的专栏
10-06 365
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 706
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Java中的break、continue和return语句
weixin_73230994的博客
10-05 379
break语句用于终止某个语句块的执行，一般使用在switch或者循环【for, while ,do-while】（提前退出或结束循环不是终止程序）1.continue语句用于结束本次循环，继续执行下一次循环2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。
Netty 相比原生IO模型的优势
最新发布
lssffy的博客
10-09 367
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
掌握Java，开启Android应用开发之旅
第十一章讲解了文件和输入/输出操作，这对于数据持久化和数据交换是必不可少的。 最后一章"Accessing Networks"涉及网络编程，包括HTTP、HTTPS、Socket编程等，这对于那些需要与服务器交互或获取远程数据的Android...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值