Java SE day 23 多线程（二）

最新推荐文章于 2024-08-03 23:50:53 发布
最新推荐文章于 2024-08-03 23:50:53 发布
阅读量92 收藏
点赞数
分类专栏： 笔记 文章标签： eclipse intellij-idea java ide
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zhangxiangyiyi/article/details/125734952
版权

多线程二

1. 线程的常用方法

Thread.sleep(毫秒数),让线程休眠,时间到，自动唤醒并继续执行

Thread.currentThread():表示获取当前正在执行的线程对象

public finalboolean isAlive():测试线程是否处于活动状态

getName():获取线程名字

优先级：可以给线程设置优先级，范围是1-10，10优先级最高

setPriority(数字):给线程设置优先级,这里优先级高，并不代表一定先执行，只是增加了抢占到资源的机会

getPriority():获取线程的优先级,

Thread提供了三个优先级常量:

Thread.MAX_PRIORITY=10

NORM_PRIORITY = 5

MIN_PRIORITY = 1

Main方法的优先级，是5

yield():当前线程暂停执行,与其他线程同时抢占资源,如果还是自己抢占到,则继续执行后续的代码,如果是其他线程抢占到,则其他线程先执行.

join():当前线程暂停执行，新加入的线程开始执行，当新线程执行完之后，再执行当前线程

yield()方法使用如下,

先准备一个A线程，在执行A线程过程中准备B线程，并让B线程就绪，然后A线程执行到一半之后，A线程礼让，此时A和B都就绪，然后各自抢占资源，谁抢到资源谁执行，如下：

A线程代码如下：

package cn.sz.gl.test02;
​
public class MyRunA implements Runnable {
​
    @Override
    public void run() {
        MyRunB b = new MyRunB();
        Thread tb = new Thread(b,"B");
        tb.start();
        System.out.println("线程A启动..");
        Thread.currentThread().yield();
​
        System.out.println("线程A结束..");
    }
​
}

B线程如下：

package cn.sz.gl.test02;
​
public class MyRunB implements Runnable {
​
    @Override
    public void run() {
        System.out.println("线程B启动..");
        System.out.println("线程B结束...");
    }
​
}

测试方法如下：

package cn.sz.gl.test02;
​
public class Test {
​
    public static void main(String[] args) {
        MyRunA a = new MyRunA();
        Thread ta = new Thread(a,"A");
        ta.start();
    }
}

join()方法使用如下：

先准备一个A线程，在执行A线程过程中准备B线程，并让B线程就绪，然后A线程执行到一半之后,让B线程调用join方法，此时A线程阻塞，B 线程启动执行，当B线程执行完毕后，A线程再继续执行

A线程代码如下：

package cn.sz.gl.test02;
​
public class MyRunA implements Runnable {
​
    @Override
    public void run() {
        MyRunB b = new MyRunB();
        Thread tb = new Thread(b);
        tb.start();
        System.out.println("线程A启动..");
        try {
            tb.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
​
        System.out.println("线程A结束..");
    }
​
}

B 线程代码如下：

package cn.sz.gl.test02;
​
public class MyRunB implements Runnable {
​
    @Override
    public void run() {
        System.out.println("线程B启动..");
        System.out.println("线程B结束...");
    }
​
}

测试代码如下：

package cn.sz.gl.test02;
​
public class Test {
​
    public static void main(String[] args) {
        MyRunA a = new MyRunA();
        Thread ta = new Thread(a,"A");
        ta.start();
    }
}

2. 线程的终止

第一种，通过给定属性,然后通过控制属性值来破坏继续执行的条件

线程代码如下：

package cn.sz.gl.test03;
​
public class MyRun implements Runnable {
​
    private boolean flag = true;
​
    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println("执行线程_" + i);
            i++;
        }
    }
​
    public void changeFlag() {
        flag = false;
    }
}

测试代码如下：

package cn.sz.gl.test03;
​
public class Test {
​
    public static void main(String[] args) {
        MyRun mr = new MyRun();
        new Thread(mr).start();
​
​
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
​
        mr.changeFlag();
    }
}

第二种,对于正在执行的线程,interrupt（）是给线程设置中断标志；interrupted（）是检测中断并清除中断状态；isInterrupted（）只检测中断。还有重要的⼀点就是interrupted（）作⽤于当前线程，interrupt（）和isInterrupted（）作⽤于此线程，即代码中调⽤此⽅法的线程

线程代码如下：

package cn.sz.gl.test03;

public class MyRun2 implements Runnable {

	@Override
	public void run() {
		int i = 0;

		while(!Thread.interrupted()){
			System.out.println("我的线程_"+i);
			i++;
		}

	}

}

测试代码如下：

package cn.sz.gl.test03;

public class Test2 {

	public static void main(String[] args) {
		//System.out.println(Thread.interrupted());//默认为false

		MyRun2 mr = new MyRun2();
		Thread th = new Thread(mr);
		th.start();


		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		th.interrupt();

	}
}

第三种，如果线程因为执行join(),sleep()或是wait()而进入了阻塞状态，此时要想停止它，可以让它调用interrupt()，程序会抛出InterruptedException异常而被catch()子句捕获,进行处理

线程代码如下：

package cn.sz.gl.test03;

public class MyRun3 implements Runnable {

	@Override
	public void run() {
		int i = 0;
		while(true){
			System.out.println("线程_"+i);
			i++;
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				break;
			}
		}
	}

}

测试代码如下：

package cn.sz.gl.test03;

public class Test3 {

	public static void main(String[] args) {
		MyRun3 mr = new MyRun3();
		Thread th = new Thread(mr);
		th.start();


		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		//当调用interrupt方法时，可以改变interrupted的值
		//当th线程中有处理InterruptedException异常的时候，如果该线程调用了interrupt方法，那么该线程会抛出InterruptedException异常
		th.interrupt();
	}
}

3. 线程的同步

在Java语言中，引入对象互斥锁的概念，保证共享数据操作的完整性;

每个对象都对应于一个可称为"互斥锁"的标记，这个标记保证在任一时刻，只能有一个线程访问对象;

用关键字synchronized给对象加互斥锁.

3.1 同步代码块

synchronized放在对象前面限制一段代码的执行,其语法如下：

Object obj = new Object();
...
synchronized(this){//this被加锁,任何其他要锁this的方法和代码块被阻塞.
 需要同步的代码;
}
...
synchronized(obj){//obj被加锁,任何其他要锁obj的代码块被阻塞.
 需要同步的代码;
}

3.2 同步方法

同步非静态方法：synchronized放在方法声明中，表示整个方法为同步方法,锁定this对象,如果有一个线程进入了该方法,其他线程要想使用当前this对象的任何同步方法,都必须等待前一个线程执行完该同步方法之后

如下：

public synchronized void method1(){
 …
}
public synchronized void method2(){
 …
}
public synchronized void method3(){
 …
}

同步static方法： synchronized放在static方法声明中,表示锁定该类的class对象(xxx.class,是Class类型的,是描述一个类的信息的对象)

如果有一个线程进入了该方法,其他线程要想使用当前类中的任何同步静态方法,都必须等待前一个线程执行完该同步方法之后;其他非同步方法及非静态的同步方法的执行不受影响

如下：

public synchronized static void method1(){
 …
}
public synchronized static void method2(){
 …
}

注意：

当前线程调用本同步方法时，其他线程是不允许调用本对象中其他同步方法

当前线程在调用本同步静态方法时，其他线程是不能够调用本类中的其他同步静态方法的,但是可以调用本类中的其他非同步方法或者非静态同步方法

对于同步静态方法，此时锁定的是对应的类型（类名.class）,所有属于该类型的对象，都在其锁定范围内，此时可以实现方法的同步调用

4. 线程阻塞

  1. 同步阻塞

  2. 调用sleep()，join（）方法的时候,sleep()转为休眠，时间到自动唤醒

  3. wait(),notify()方法配套,转为等待，同时释放资源,通过notify()方法唤醒

  1. yield(),释放资源，与其他线程重新抢占资源，抢到就执行

  2. suspend（）和resume()，由jdk1.0提供，jdk1.2之后就被放弃了，它也是让线程暂停，但是它不释放资源,导致死锁出现

5. 线程死锁

死锁产生的必要条件:

1> 互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用

2> 不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。

3> 请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占用。

4> 循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路

在我们的项目中，我们不希望看到死锁的发生，为了避免，以上四个条件，破坏其中任意一个，死锁就结束了

注意：过多的同步会导致死锁

死锁示例如下：

package cn.sz.gl.no5;

public class MyRun implements Runnable {

	private static Object a = new Object();
	private static Object b = new Object();

	private boolean flag = true;

	public void changeFlag(){
		flag = false;
	}

	@Override
	public void run() {
		if(flag){
			synchronized (a) {
				System.out.println(Thread.currentThread().getName()+"锁定了资源a");
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (b) {
					System.out.println(Thread.currentThread().getName()+"锁定资源b");
				}
			}
		}else{
			synchronized (b) {
				System.out.println(Thread.currentThread().getName()+"锁定了资源b");
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (a) {
					System.out.println(Thread.currentThread().getName()+"锁定资源a");
				}
			}
		}
	}

}

测试如下：

package cn.sz.gl.no5;

public class Test {

	public static void main(String[] args) {
		MyRun mra = new MyRun();
		new Thread(mra,"线程1").start();

		MyRun mrb = new MyRun();
		mrb.changeFlag();
		new Thread(mrb,"线程2").start();

	}
}
在下张仙人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java基础day01
07-20
深入学习Java还需要掌握集合框架、多线程、I/O流、网络编程、反射机制、泛型、Lambda表达式等进阶概念。同时，熟悉Java SE中的标准库，如java.util和java.io，能够极大地提升开发效率。 总的来说，Java是一门强大且...
java基础(se)练习手册部分讲解
06-28
总的来说，这份"Java基础(SE)练习手册"是全面而系统的Java入门教程，它将帮助初学者逐步建立Java编程思维，理解并掌握编程基础，为进一步学习Java的高级特性，如集合框架、多线程、网络编程等打下坚实的基础。...
传智播客java教程里面的三套卷子
11-13
6. **多线程**：Java内置对多线程的支持，学生需要理解线程的创建、同步和通信，如synchronized关键字和wait/notify机制。 7. **反射机制**：Java的反射机制允许在运行时检查类的信息，动态创建对象和调用方法，是...
day5exam
02-21
6. **多线程**：Java内置对多线程的支持，理解线程的基本概念，如同步、互斥和死锁，以及如何创建和管理线程，对于编写并发程序非常重要。 7. **泛型**：泛型引入了类型参数，提高了代码的类型安全性和重用性。理解...
day01_video.zip
01-21
9. **多线程**：Java内置了对多线程的支持，可以创建Thread对象或实现Runnable接口来实现并发执行。 10. **Java Swing和JavaFX**：这是Java的图形用户界面（GUI）库，用于创建桌面应用程序。 11. **Java EE**：...
eclipse制作绿色版的配置步骤
最新发布
svygh123的专栏
08-03 436
是无效的，打开eclipse后不会被识别到，需要使用到eclipse内置的工作空间绝对路径变量${workspace_loc}，修改后如下。配置时，选择9.0，Tomcat installation directory直接输入apache-tomcat-9.0.33。把mysql/bin下的a-startup.bat复制到eclipse目录下，在eclipse目录下创建workspace文件夹，作为默认的工作空间，放在eclipse目录下，然后打开eclipse，
idea个人常用快捷键设置
pp的博客
08-03 364
代码生成快捷键 Ctrl + Enter / Alert + Insert，没错就是你想要的那个神奇快捷键，可以自动生成get/set/ovrride/construct/toString/test等方法的强大快捷键，最常用的场景就是快速生成test测试类。在快捷键配置keymap中搜索“show context actions”，如果没有配置快捷键加上“Alt + Enter”的快捷键就可以了。如果有一天你的快速补全快捷键不好用了，请一定记得看这篇文章。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 631
1.导入hutool的maven依赖。2.复制一下代码执行。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 672
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 558
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 496
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
JavaSE面向对象进阶
qq_45348840的博客
07-30 503
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 384
1.导入hutool的maven依赖。2.直接复制一下代码运行。
花几千上万学习Java，真没必要！（三十五）
wehpd的博客
07-30 671
集合之Map
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 993
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
Java并发（十一）一文搞懂Java并发各种容器
m0_58466443的博客
07-29 856
同步容器将所有对容器状态的访问都串行化，以保证线程安全性，这种策略会严重降低并发性。Java 1.5 后提供了多种并发容器，使用并发容器来替代同步容器，可以极大地提高伸缩性并降低风险。并发容器对应的普通容器描述HashMapJava 1.8 之前采用分段锁机制细化锁粒度，降低阻塞，从而提高并发性；Java 1.8 之后基于 CAS 实现。SortedMap基于跳表实现的ArrayListSet基于实现。SortedSet基于实现。Queue线程安全的无界队列。底层采用单链表。支持 FIFO。
javaweb_03：在ide中配置tomcat
qq_52200849的博客
08-01 175
④创建artifact。②点击加号创建，选择。
Spring-包扫描
Promise_J_Z
08-03 164
二次判断类是否可独立实例化对象，内部类或者接口，抽象类都会对应生成一个.class文件，但是这些文件部分是不能够实例化的，不可以生成bean，所以在生成BeanDefinition之前需要进行过滤判断。对扫描到的BeanDefinition进行赋值，但是此时只是将className赋值到BeanDefinition中，因为还没有创建该类。spring在启动的时候就会往includeFilters中加入component注解。判断当前类是否需要当作bean进行处理。
安装ElasticSearch
diffiii
07-31 622
(1).使用WinSCP工具拷贝下载好的安装文件jdk-8u121-linux-x64.gz到建的es文件夹下。(5).修改配置文件elasticsearch-5.2.0/Configs/elasticsearch.yml。plugins—这里存放一些常用的插件，如果有一切额外的插件，可以放在这里使用。(2).切换到elasticsearch根目录，启动elasticsearch。data—这里是ES得当前节点的分片的数据，可以直接拷贝到其他的节点进行使用。1.1.1.6 维护elastic。
Java多线程详解：概念、实现与应用
Java中的"day11 java"教程提供了关于线程概念、多线程优势与弊端、以及多线程实现的深入讲解。首先，进程被定义为正在运行的程序，它拥有独立的内存空间，而线程则是进程内的执行单元，负责执行特定的任务。多线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

在下张仙人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值