java复习-线程常用操作方法

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量181 收藏
点赞数
分类专栏： 编程语言与bug 文章标签： java 开发语言 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41168765/article/details/132849669
版权

线程常用操作方法

线程的主要方法都定义在 Thread类 之中，因此此处就是学习Thread中的方法。

一. 线程的命名与取得

  • 构造方法：public Thread(Runnable target, String name)
  • 设置名字：public final synchronized void setName(String name)
  • 取得名字：public final String getName()

范例1：观察线程的名字

class MyThread implements Runnable{
	@Override
	public void run() {
        // MyThread 代表着 Runnable 子类，是一类资源，并不是线程，因此不能使用this.getName() 并且也没有这个方法
        // 因此要使用 Thread 的类方法，获得当前线程
		System.out.println(Thread.currentThread().getName()); 
	}
}
public class ThreadDemo {
	public static void main(String[] args) throws Exception{
	MyThread mt = new MyThread(); // Runnable 子类对象
		new Thread(mt, "线程A").start();
		new Thread(mt).start(); 
		new Thread(mt, "线程B").start();		
	}
}

结果：

线程A
线程B
Thread-0

总结： 说明开发者设置名字的线程返回名字，未设置名字的线程自动分配名字。主要是通过 static 属性来完成的，在 Thread 类中定义有如下操作

    /* For autonumbering anonymous threads. */
    private static int threadInitNumber;
    private static synchronized int nextThreadNum() {
        return threadInitNumber++;
    }

范例2：观察线程的名字

class MyThread implements Runnable{
	@Override
	public void run() {
        // MyThread 代表着 Runnable 子类，是一类资源，并不是线程，因此不能使用this.getName() 并且也没有这个方法
        // 因此要使用 Thread 的类方法，获得当前线程
		System.out.println(Thread.currentThread().getName()); 
	}
}
public class ThreadDemo {
	public static void main(String[] args) throws Exception{
	MyThread mt = new MyThread(); // Runnable 子类对象
		new Thread(mt, "线程A").start();
		mt.run(); // 对象直接调用 run() 方法
	}
}

结果：

main
线程A

总结：

  • 直接在主方法中调用线程类对象的 run() 方法，得到的名称是 “main”，即——主方法也是一个线程；
  • 在任何的开发之中，主线程可以创建若干个子线程，创建子线程的目的是可以将一些复杂逻辑或者比较耗时的逻辑交由子线程处理；
  • 主线程负责处理整体流程，而子线程负责处理耗时操作。

例如，如下程序会在执行任务一之后，发生轻微卡顿。

public class ThreadDemo {
	public static void main(String[] args){
		System.out.println("1. 执行任务一");
		int temp = 0;
		for (int i = 0; i < Integer.MAX_VALUE; i++) {
			temp += i;
		}
		System.out.println("2. 执行任务二");
		System.out.println("3. 执行任务三");
	}
}

将任务一放在子线程中进行，运行情况明显改善

public class ThreadDemo {
	public static void main(String[] args){
		System.out.println("1. 执行任务一");
		new Thread(()->{ // 子线程负责统计
			int temp = 0;
			for (int i = 0; i < Integer.MAX_VALUE; i++) {
				temp += i;
			}
		});

		System.out.println("2. 执行任务二");
		System.out.println("3. 执行任务三");
	}
}

二. 线程休眠(sleep())

目的：希望某一个线程可以暂缓执行，就可以使用休眠处理。

方法：

  • public static native void sleep(long millis) throws InterruptedException;
  • public static void sleep(long millis, int nanos)throws InterruptedException；

范例：

public class ThreadDemo {
	public static void main(String[] args){
		new Thread(()->{ // 子线程负责统计
			for (int i = 0; i < 10 ; i++) {
				System.out.println(Thread.currentThread().getName() + temp);
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}).start();;
	}
}

三. 线程中断(interrupt())

在之前发现线程的休眠里面提供有一个中断异常，实际上就证明线程的休眠是可以被打断的，而这种打断肯定是由其它线程完成的。

方法：

  • 判断线程是否被中断 public boolean isInterrupted()
  • 中断线程 public void interrupt()

范例：

public class ThreadDemo {
	public static void main(String[] args) throws InterruptedException{
		Thread th = new Thread(()->{ 
			System.out.println("休眠中...");
			try {
				Thread.sleep(10000); // 子线程休眠10s
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} 
			System.out.println("休眠结束！");
		});
		
		th.start();
		Thread.sleep(1000);  // 主线程休眠1s后中断子线程
		if (!th.isInterrupted()) { // 判断 th 子线程是否被中断
			th.interrupt();  // 中断 th 子线程
			System.out.println("子线程被主线程所中断。。");
		}
		
		
	}
}

结果：

休眠中...
子线程被主线程所中断。。
java.lang.InterruptedException: sleep interrupted
	at java.base/java.lang.Thread.sleep(Native Method)
	at ThreadDemo.lambda$0(ThreadDemo.java:7)
	at java.base/java.lang.Thread.run(Thread.java:833)
休眠结束！

所有正在执行的线程都是可以被中断的，中断线程必须进行异常的处理。

四. 线程强制执行(join())

定义

强制执行：当满足于某些条件之后，某一个线程对象将可以一直独占资源，一直到该线程的程序执行结束。

正常范例

正常情况下，以主线程和子线程为例，两者都在交替执行着

public class ThreadDemo {
	public static void main(String[] args) throws InterruptedException{
		Thread th = new Thread(() -> {
			for(int i = 0; i < 10; i++) {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "执行，i = " + i);
			}
			
		}, "正常的子线程");
		
		th.start();
		for(int i = 0; i < 10; i++) {
			Thread.sleep(100);
			System.out.println("正常的主线程,执行，i = " + i);
		}
		
		
	}
}

结果：

正常的子线程执行，i = 0
正常的主线程,执行，i = 0
正常的子线程执行，i = 1
正常的主线程,执行，i = 1
正常的子线程执行，i = 2
正常的主线程,执行，i = 2
正常的主线程,执行，i = 3
正常的子线程执行，i = 3

独占范例

但是如果说现在你希望主线程独占执行。那么就可以利用 Thread 类中的方法：

  • public final void join() throws InterruptedException
    需要注意的是：在进行线程强制执行的时候一定要获取强制执行线程对象之后才可以执行 join()调用。
public class ThreadDemo {
	public static void main(String[] args) throws InterruptedException{
		Thread th = new Thread(() -> {
			for(int i = 0; i < 5; i++) {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "执行，i = " + i);
			}
			
		}, "优先的子线程");
		
		th.start();
		for(int i = 0; i < 5; i++) {
			Thread.sleep(100);
			if(i == 1)
				th.join(); // 主线程执行1次后，子线程独占资源，直到执行完毕
			System.out.println("被迫等待的主线程，执行，i = " + i);
		}
		
		
	}
}

结果：

优先的子线程执行，i = 0
被迫等待的主线程，执行，i = 0
优先的子线程执行，i = 1
优先的子线程执行，i = 2
优先的子线程执行，i = 3
优先的子线程执行，i = 4
被迫等待的主线程，执行，i = 1
被迫等待的主线程，执行，i = 2
被迫等待的主线程，执行，i = 3
被迫等待的主线程，执行，i = 4

五. 线程的礼让(yield())

线程的礼让指的是先将资源让出去让别的线程先执行。线程的礼让可以使用 Thread 中提供的方法；

  • public static native void yield(); // 这是一个静态方法
    但与强制执行不同，礼让执行的时候每一次调用 yield() 方法都只会礼让一次当前的资源。

范例：在之前 join() 的基础上，让强占资源的子线程通过 yield() 让出线程

public class ThreadDemo {
	public static void main(String[] args) throws InterruptedException{
		Thread th = new Thread(() -> {
			for(int i = 0; i < 5; i++) {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "执行，i = " + i);
				
				// 当执行到第二次时进行一次礼让
				if(i > 1){
					Thread.yield(); 
					System.out.println("------礼让执行------");
				}
			}
			
		}, "优先的子线程");
		
		
		th.start();
		for(int i = 0; i < 5; i++) {
			Thread.sleep(100);
			if(i == 1)
				th.join(); // 主线程执行1次后，子线程独占资源，直到执行完毕
			System.out.println("被迫等待的主线程，执行，i = " + i);
		}
		
		
	}
}

结果：

被迫等待的主线程，执行，i = 0
优先的子线程执行，i = 0
优先的子线程执行，i = 1
优先的子线程执行，i = 2
------礼让执行------
优先的子线程执行，i = 3
------礼让执行------
优先的子线程执行，i = 4
------礼让执行------
被迫等待的主线程，执行，i = 1
被迫等待的主线程，执行，i = 2
被迫等待的主线程，执行，i = 3
被迫等待的主线程，执行，i = 4

思考（关于 join 和 yield）

通过观察结果我们发现，并没有实现预期的效果：

子线程礼让，被迫等待main线程执行。

通过查阅资料后，我们发现了 join() 和 yield() 方法对应于操作系统的细节：
我们知道操作系统对于进程和线程的调度，有五大状态之分：
在这里插入图片描述

而对于上述的两个方法而言：

  • yield() 是将当前线程从运行状态转换到就绪状态，而不能是等待或者阻塞状态。操作系统会从就绪态中的线程重新调度（当然运气好的话，你刚让出来又被调进去，就会出现礼让无效果的情况）
  • join() 方法在线程实例中被调用，当前运行的线程会被堵塞，当前线程变为堵塞态，直到线程实例运行完成。
    因此，对于被子线程的 join() 所堵塞的main线程，其本身的状态就不在就绪态之中，所以即使子线程使用 yield() 礼让，操作系统也会从就绪态的线程中选择调用，而不会运行处于堵塞态的main线程。

六. 线程优先级(setPriority())

从理论上来讲线程的优先级越高越有可能先执行(越有可能先抢占到资源)。在 Thread 类里面针对于优先级的操作提供有如下的两个处理方法:

  • 设置优先级: public final void setPriority(int new Priority)
  • 获取优先级: public final int getPriority()
    在进行优先级定义的时候都是通过 int 型的数字来完成的，而对于此数字的选择在 Thread 类里面就定义有三个常量：
  • 最高优先级: public static final int MAX PRIORITY;——10
  • 中等优先级: public static final int NORMPRIORITY;——5
  • 最低优先级: public static final int MIN PRIORITY;——1
孤独的马铃薯
关注
专栏目录
Java期末复习-常用类库
08-04
Java 期末复习涉及众多常用的类库，这些类库在日常编程中扮演着重要角色。首先，我们关注StringBuffer类，这是处理字符串时的一个关键选择，特别是在字符串需要频繁修改的情况下。StringBuffer提供了append方法来...
java-java面试题库整理-基础-JVM-线程并发-框架等.zip
02-06
为了在激烈的Java开发者竞争中脱颖而出，深入理解Java基础知识、JVM（Java虚拟机）、线程并发以及常用框架是至关重要的。这份"java-java面试题库整理-基础-JVM-线程并发-框架等.zip"文件提供了一个全面的复习资源，...
java ----多线程题目汇总
qq_38345598的博客
05-03 2121
1、请问 如何控制多线程顺序执行 1、使用join 控制 package com.example.demothread.util; import lombok.extern.slf4j.Slf4j; import org.springframework.web.bind.annotation.PathVariable; /** * @author lenovo * @version 1.0 * @Date 2022/5/3 12:22 * @Description */ @Sl...
Java--常用类APl(复习总结)
Dreamkidya的博客
06-29 1293
Java是一种强大而灵活的编程语言，具有广泛的应用范围，从桌面应用程序到企业级应用程序都能够使用Java进行开发。在Java的编程过程中，使用标准类库是非常重要的，因为标准类库提供了丰富的类和API，可以简化开发过程，提高开发效率。本文将介绍一些常用的Java类库及其API，希望能够帮助开发人员更好地理解和应用Java编程中的常用工具和功能
Java多线程复习
心有—林夕的博客
04-04 1736
hread类位于java.lang包，JDK1.0引入。线程的创建、调度、执行、销毁等由内核进行控制，调度过程通过抢占式策略进行调度。/**// run不能带参数 所以初始化的时候把id初始化成功 MyTask(int id) {System . out . println(name + "即将执行任务：" + id);try {} System . out . println(name + "完成了任务：" + id);} }/**
【Java复习】线程安全的 HashMap --- ConcurrentHashMap
xqs196301的博客
09-30 2931
【Java复习】线程安全的 HashMap --- ConcurrentHashMap
Java多线程-CountDownLatch
weixin_45203607的博客
02-16 2623
介绍 CountDownLatch是一个同步辅助类，它允许一个或多个线程一直等待直到其他线程执行完毕才开始执行。 用给定的计数初始化CountDownLatch，其含义是要被等待执行完的线程个数。 每次调用CountDown()，计数减1 主程序执行到await()函数会阻塞等待线程的执行，直到计数为0 场景 1:多线程读取批量文件, 并且读取完成之后汇总处理 2:多线程读取Excel多个sheet,读取完成之后获取汇总获取的结果 3:多个人一起一起来吃饭,主人等待客人到来,客人一个个从不同地方来到饭店,主
一文带你复习java--java基础知识篇
热门推荐
wuhuanyicheng的博客
04-26 1万+
m字节序是指多字节数据在计算机内存中存储或网络传输时个字节的存储顺序。通常由小端和大端两组方 式。 1. 小端:低位字节存放在内存的低地址端，高位字节存放在内存的高地址端。 2. 大端：高位字节存放在内存的低地址端，低位字节存放在内存的高地址端。 Java语言的字节序是大 端方式。
java复习---基础
suvue
12-29 2372
java面试复习—基础 1.面向对象和面向过程的区别 面向过程：性能较高。面向过程语言大多是可以直接编译成机械码，直接就能在电脑上运行；而面向过程语言在运行时需要进行类的实例化，开销大并且消耗资源；而对于Java语言的性能较差问题，主要原因是它属于半编译语言，最终的执行代码不是可以直接被CPU执行的二进制机械码。 面向对象：易维护，易复用，易拓展。这些优点完全建立在面向对象语言的三大特性之上的，...
Java复习------OOP
qq_45928896的博客
03-03 1391
面向对象编程 什么是面向对象 面向对象 & 面向过程 面向过程： 步骤清晰简单，第一步做什么，第二部做什么… 面向过程适合处理一些较为简单的问题。 面向对象： 物以类聚，适合开发大型软件 整体实现，管理整个软件的开发 本质：以类的方式组织代码，以对象的组织封装数据 总结 1.都是解决问题的思维方式，都是代码组织的方式 2.解决简单问题可以使用面向对象 3.解决复杂问题：宏观上使用面向对象把握，微观处理上仍然是面向过程 方法回顾和加深 方法的定义 访问修饰符 返回值类型 break和return的区
java和线程相关的关键字有哪些,Java 复习 —— 线程相关方法介绍
weixin_35873946的博客
03-21 1132
1、sleep()使当前线程(即调用该方法的线程)暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁(如果是在Synchronized块中的话，他是不会释放锁的)。也就是说如果有synchronized同步块，其他线程仍然不能访问共享数据。注意该方法是个静态方法，但是系统会自动识别具体哪个线程调用了休眠时间。例如有两个线程同时执行(没有synchronized)一个线程优先级为MAX_...
Java --- 期末复习卷
qq_63976098的博客
05-24 3469
Java期末复习资料
01大数据面试复习----Java基础---集合类、多线程、JVM.zip
09-30
在准备大数据面试的过程中，Java基础是必不可少的一部分，尤其聚焦于集合类、多线程和JVM这三大核心领域。下面将分别对这三个方面进行深入探讨。 **一、Java集合类** Java集合框架是处理对象组的重要工具，它包括...
Java期末复习||应用程序设计-多线程和泛型
08-02
2. **线程操作方法** - `start()`: 启动线程，执行`run()`方法。 - `isAlive()`: 检查线程是否还在运行。 - `join()`: 让当前线程等待指定线程完成。 - `sleep()`: 使当前线程睡眠一定时间。 - `interrupt()`: ...
Java期末复习-类集框架
08-06
Java 类集框架是Java编程语言中用于存储和操作对象集合的核心组件。它提供了一系列接口和类，方便开发者处理各种数据结构，如列表、队列、集合、映射等。类集框架的最大父接口是`Collection`，而`Map`接口则是处理...
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 262
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 589
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 563
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 459
spring boot 整合 mybatis
Java多线程复习：线程创建与调度
"E05_多线程复习.pdf 是一份关于Java多线程的复习资料，涵盖了进程、线程的基本概念，线程的创建方式，线程调度，以及线程安全和JUC编程的相关知识点。" 在计算机系统中，**进程**是一个正在执行的应用程序，它拥有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值