Java day18

最新推荐文章于 2024-09-16 21:37:07 发布
最新推荐文章于 2024-09-16 21:37:07 发布
阅读量216 收藏
点赞数
分类专栏： 笔记 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46091824/article/details/115185480
版权
本文探讨了Java中线程的创建方式，包括继承Thread和实现Runnable接口，并通过实例演示了售票场景中的线程安全问题及其解决方案，如同步代码块、同步方法和静态同步方法。此外，还介绍了死锁、唤醒机制和生产者消费者模型，帮助理解多线程并发控制的关键概念。
摘要由CSDN通过智能技术生成

文章目录

多线程

进程：在内存中正在执行的程序。一个应用程序如果想要被执行必须跑在内存中。
线程：是进程的执行单元，用来负责进程中代码的执行。进程中可以一条线程，也可以有多条线程。一个进程至少需要一个线程。
Java中线程使用抢占式调度：县城具有优先级，线程高的抢到的概率大，如果线程优先级相同，那么会随机选择一个线程执行。
CPU资源在多个线程之间进行高速的切换，对于人类感觉到多个线程在同时进行操作。但是在同一 时刻，只有一条线程被执行。
当线程和计算机硬件进行交互时，会暂时空置CPU。多条线程就能够提高CPU的利用率。假设一条线程CPU空闲时间是40%，那么利用率是60%，那么两条线程空闲时间是 40% * 40%，利用 率是1 - 40% * 40% = 84%
多线程并没有提高运行速度，但是提高了CPU的利用率
主线程：程序在JVM启动时，会自动分配一条线程在执行main方法，这条线程称之为主线程。

创建方式一

  1. 定义一个类继承Thread。
  2. 重写run方法。
  3. 创建子类对象，就是创建线程对象。
  4. 调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。
public class MyThread extends Thread{
	
	// 重写run方法
	@Override
	public void run() {
		// TODO Auto-generated method stub
		// 在run方法中填写需要被其他线程执行的代码
		for (int i = 0;i < 100;i++){
			System.out.println("i = " + i);
		}
	}
}

创建方式二

  1. 定义类实现Runnable接口。
  2. 覆盖接口中的run方法。。
  3. 创建Thread类的对象
  4. 将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
  5. 调用Thread类的start方法开启线程。
public class MyRunnable implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0;i < 100;i++){
			System.out.println("子线程的i = " + i);
		}
	}
}

public static void main(String[] args) {
		// 创建Runnable的实现类对象
		MyRunnable my = new MyRunnable();
		// 创建对象
		Thread t = new Thread(my);
		// 开启线程并且调用run方法
		t.start();
			
		for (int i = 0;i < 100;i++){
			System.out.println("主线程的i = " + i);
		}
	}

售票案例

public class Practice01 {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();
        Thread thread1 = new Thread(st, "窗口一");
        Thread thread2 = new Thread(st, "窗口二");
        Thread thread3 = new Thread(st, "窗口三");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class SellTicket implements Runnable {
    int ticket = 100;

    @Override
    public void run() {
        while (true) {    
                if (ticket <= 0) {
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "卖票" + ticket);
                ticket--;
        }
    }
}

出现重票，0票，-1票问题，存在线程安全问题。

线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
这里明显出了问题，就是线程安全隐患。
解决思路：保证核心代码同一时刻只能有一条线程在执行。

方式一：同步代码块

  • 格式
    synchronized (锁对象) {
    可能会产生线程安全问题的代码
    }
  • 作用:能够保证在代码块中的代码同一时刻最多只有一条线程。
  • 同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。
  • 方法区的内容是被线程共享的，所以"abc" Math.class 都可以当做同步代码块的锁资源
  • 同步代码块会影响多线程的效率，所以只加核心可能出现隐患的代码。
// 模拟票数
public class Ticket implements Runnable{
	int ticket = 100;
	// 当做同步代码块的锁资源
	Object obj = new Object();
	@Override
	public void run() {
		// TODO Auto-generated method stub
			
		while (true){
			// 让当前线程休眠 单位是毫秒
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
//			// 同步代码块
			synchronized (obj) {
				// 说明票卖光了
				if (ticket <= 0){
					break;
				}
				
				System.out.println(Thread.currentThread().getName() + "正在卖" + ticket--);
			}
		}
	}
}

方式二：同步方法

同步方法：被synchronized 修饰的方法，可以保证方法中同一时刻只能有一条线程在执行。
同步方法的锁资源是this

方式三：静态同步方法

静态同步方法：被synchronized和static修饰的方法，可以保证方法中同一时刻只能有一条线程在 执行。
静态同步方法的锁资源是 类名.class

// 模拟票数
public class Ticket implements Runnable{
	int ticket = 100;
	// 当做同步代码块的锁资源
	Object obj = new Object();
	@Override
	public void run() {
		// TODO Auto-generated method stub
//		synchronized (obj) {
			
		while (true){
			// 让当前线程休眠 单位是毫秒
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
//			// 同步代码块
			synchronized (obj) {
				// 说明票卖光了
				if (ticket <= 0){
					break;
				}
				
				System.out.println(Thread.currentThread().getName() + "正在卖" + ticket--);
			}
//			method();
		}
//		}
	}
	// 同步方法
	// 可以保证同步方法中的代码同一时刻只能有一条线程在执行
	// 同步方法的锁资源就是this
	public synchronized void method(){
		// 说明票卖光了
		if (ticket <= 0){
			return;
		}
		
		System.out.println(Thread.currentThread().getName() + "正在卖" + ticket--);
	}
	// 静态同步方法的锁资源是类名.class
//	public static synchronized void method1(){
//		// 说明票卖光了
//		if (ticket <= 0){
//			return;
//		}
//		
//		System.out.println(Thread.currentThread().getName() + "正在卖" + ticket--);
//	}
	
}

同步：只允许一个线程执行。
异步: 允许多条线程同时执行。
同步一定是线程安全的。
Hashtable是同步线程安全的
HashMap是异步线程不安全的
ConcurrentHashMap异步线程安全的

死锁

所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。

// 全公司共享的仪器
	static Printer p = new Printer();
	static Scan s = new Scan();
	public static void main(String[] args) {
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				synchronized (p) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					// 先使用打印机
					p.print();
					synchronized (s) {
						// 使用扫描仪
						s.scan();
					}
				}
			}
		}).start();
		
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				synchronized (s) {
					s.scan();
					// 打印内容
					synchronized (p) {
						p.print();
					}
				}
			}
		}).start();
	}
}
// 打印机
class Printer{
	public void print(){
		System.out.println("打印机正在吱吱吱的打印东西~");
	}
}

// 扫描仪
class Scan{
	public void scan(){
		System.out.println("扫描仪正在扫描文件~~");
	}
}

等待唤醒机制

案例：学生提问

package com.kaer.threaddemo;

public class Practice03 {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("张三");
        s.setGender("男");
        new Thread(new Ask(s)).start();
        new Thread(new Change(s)).start();
    }
}
class Student{
    private String name;
    private String gender;
    boolean flag = true;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}
class Ask implements Runnable{

    private Student s;
    public Ask(Student s){
        this.s = s;
    }
    @Override
    public void run() {
        while (true){
            synchronized (s){
                if (!s.flag){
                    try {
                        s.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("我是" + s.getName() + "," + s.getGender() + "生");
                s.flag = false;
                s.notify();
            }
        }
    }
}
class Change implements Runnable{

    Student s;
    public Change(Student s){
        this.s = s;
    }
    @Override
    public void run() {
        while (true){
            synchronized (s){
                if (s.flag){
                    try {
                        s.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if ("张三".equals(s.getName())){
                    s.setName("李四");
                    s.setGender("女");
                }else{
                    s.setName("张三");
                    s.setGender("男");
                }
                s.flag = true;
                s.notify();
            }
        }
    }
}

生产者消费者模型

package com.kaer.threaddemo;

/*
生产消费模式
一个线程作为消费者，一个线程作为生产者。生产者每生产一次，消费者就消费一次。
         生产者每次生产的商品数量以及消费者每次消费的数量用随机数产生即可。
         每一次的生产的商品数量和上一次剩余的商品数量之和不能超过1000。
 */
public class Practice02 {
    public static void main(String[] args) {
        Product p = new Product();
        new Thread(new Productor(p)).start();
        new Thread(new Productor(p)).start();
        new Thread(new Customer(p)).start();
        new Thread(new Customer(p)).start();
    }
}

class Product {
    private int count;
    public boolean flag = true;

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}

//生产
class Productor implements Runnable {

    private Product p;

    public Productor(Product p) {
        this.p = p;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (p) {
                while (!p.flag) {
                    try {
                        p.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //计算本次所能生产的最大数量
                int max = 1000 - p.getCount();
                //计算本次生产的实际数量
                int count = (int) (Math.random() * (max + 1));
                //计算本次所能提供的商品数量
                p.setCount(p.getCount() + count);
                System.out.println("生产的数量为：" + count + ",提供的数量为：" + p.getCount());
                p.flag = false;
                p.notifyAll();
            }
        }
    }
}

//消费
class Customer implements Runnable {

    private Product p;

    public Customer(Product p) {
        this.p = p;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (p) {
                while (p.flag) {
                    try {
                        p.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //计算本次消费的商品数量
                int count = (int) (Math.random() * (p.getCount() + 1));
                //计算本次剩余的商品数量
                p.setCount(p.getCount() - count);
                System.out.println("消费数量为：" + count + ",剩余数量为：" + p.getCount());
                p.flag = true;
                p.notifyAll();
            }
        }
    }
}
weixin_46091824
关注
专栏目录
Javaday02训练
02-08
Java Day02训练是针对Java初学者或有一定基础的学习者设计的一次深入学习活动，旨在强化和巩固Java编程的基础知识。在这个训练中，你将接触到一系列关键的Java编程概念和技术，包括但不限于变量、数据类型、控制流程...
day18 java
11-11
在Java中，`File`类主要用于封装文件系统中文件和目录的信息，提供了许多用于操作文件和目录的方法。尽管`File`类不直接用于读取或写入数据，但它对于处理文件路径、获取文件属性以及进行基本文件管理任务至关重要。...
day05集合 java
06-11
day05集合 java
java practice day by day
11-14
【Java实践日积月累】 Java是一门广泛使用的编程语言，尤其在企业级应用开发中占据主导地位。本文将从Scanner、BufferedReader、ASCII码、StringBuffer、continue语句、for循环、位移操作以及两数之和问题等方面...
Java_Day06
02-22
在本课程"Java_Day06"中，我们将深入探讨Java编程语言的更多核心概念和高级特性。这个压缩包文件包含的是第六天的学习材料，旨在帮助学员巩固已学知识并进一步提升技能。以下是对其中涉及知识点的详细说明： 1. **...
Java-网络
2301_81543552的博客
09-14 687
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 596
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 271
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1128
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 181
");
基于SpringBoot的考研资讯平台设计与实现
linzhongshu的专栏
09-13 910
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 940
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 353
spirng security中的几大组件的差异和执行顺序
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1231
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-16 1152
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1086
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
07_Python数据类型_集合
最新发布
fx_yzjy101的专栏
09-16 509
可以使用大括号 {} 或者 set() 函数来创建集合。如果使用大括号，则至少需要包含一个元素；如果使用 set()，则可以创建一个空集合。# 创建一个空集合# 创建一个包含一个元素的集合# 创建一个包含几个元素的集合。
JAVA开源项目 在线视频教育平台 计算机毕业设计
as230627的博客
09-14 1059
基于Vue.js和SpringBoot的在线视频教育平台是一个功能丰富的系统，它包括管理后台和用户网页端，为管理员、普通用户和教师角色提供了不同的功能。在管理后台，管理员可以进行用户管理，包括用户信息的增删改查。
JAVA——方法重载
bengbeng2345的博客
09-12 214
返回值不能作为重载条件。
Java MBeanInstantiator 0day 漏洞分析
"Java 0day Analysis - MBeanInstantiator.findClass 漏洞解析" 在2013年1月，Java社区面临了一个新的重大安全威胁：Java MBeanInstantiator.findClass 0day漏洞。这个漏洞的影响广泛，因为Java在当时已经广泛应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值