Java学习笔记day19

已于 2022-10-20 22:49:57 修改
阅读量122 收藏
点赞数
分类专栏： Java学习记录 文章标签： java 学习 jvm
于 2022-10-19 21:37:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kouzai8880/article/details/127416163
版权

线程安全问题

原因

多个线程同时操作同一个数据就会出现线程安全问题

解决思想

多个线程同时只能有一个线程对数据进行操作

解决方案

方案1: 同步代码块
语法: 
	synchronized(锁对象){
		要同步的代码
	}
上锁与开锁: 
	当某一个线程进入synchronized代码块中，其锁对象就会上锁，此时别的线程就无法进入，只能在外面等待开锁
	当一个线程执行完synchronized代码块中的代码，此时锁对象就会开锁
注意: 
	所有的对象都可以作为锁对象
	要保证多个线程的锁对象是同一个对象
方案2: 同步方法
语法: 
	访问权限修饰符 synchronized 返回值类型 方法名(形参列表){
		方法体(要同步的代码)
	}
注意: 
	同步方法的锁对象是调用该方法的对象(同步方法的锁对象就是this)
方案3: 同步静态方法
语法: 
	访问权限修饰符 synchronized static 返回值类型 方法名(形参列表){
		方法体(要同步的代码)
	}
注意: 
	同步静态方法的锁对象是该方法所属类的类对象
类对象: 一个类被JVM加载时会产生一个类对象，该对象包含该类的所有信息，如该类的包名，类名，父类名，实现的接口名，属性数量，属性名，方法数量，方法名等信息
	因为一个类只会被加载一次，所以一个类只有一个类对象

死锁(了解)

目的

了解死锁产生的原因

原因

多个线程相互持有对方所需的锁资源

如何避免

尽量不要在同步中使用同步

线程间通讯

方法: 
	唤醒
		锁对象.notify();
			作用: 随机唤醒一个正在休眠的线程
		锁对象.notifyAll();
			作用: 唤醒所有正在休眠的线程
		注意: 只能唤醒使用该锁对象使其休眠的线程
	休眠
		锁对象.wait();
			作用: 让当前线程进入无限期休眠
		锁对象.wait(timeout);
			作用: 让当前线程有限期休眠，参数为休眠时间，单位毫秒
		锁对象.wait(timeout, nanos);
			作用: 让当前线程有限期休眠，休眠时间毫秒 + 纳秒
			参数1休眠时间，单位毫秒
			参数2休眠时间，单位纳秒
		
		wait()与sleep()的区别: 
			wait(): 
				由Object类提供的普通方法
				只能在同步中使用
				休眠期间会释放持有的锁对象
			sleep(): 
				由Thread类提供的静态方法
				可以在同步中，也可以在同步外使用
				休眠期间不会释放持有的锁对象
注意: 
	1.该方法是由Object类提供的
	2.只能在同步代码块或同步方法中使用
	3.必须使用该同步代码块或同步方法的锁对象调用
	
案例: 
	龟兔百米赛跑
	注意: 
		乌龟每秒跑1米
		兔子每秒跑10米
		总共跑了100米
	兔子跑到80米后睡觉了，乌龟跑完后，被兔子听到，兔子才跑完剩余的20米
	分析: 
		乌龟线程
			任务: 跑100米，跑完通知兔子
			速度: 1秒1米
		兔子线程
			任务: 跑100米，跑到80米进入无限期休眠
			速度: 1秒10米

生产者与消费者模式

目的: 模拟工厂生产与销售的情况
分析: 
	销售人员类
		属性: 
			工厂
		方法: 
			销售
				无限使用工厂对象调用销售方法
	生产人员类
		属性: 
			工厂
		方法: 
			生产
				无限使用工厂对象调用生产方法
	工厂类
		属性: 
			商品数量
			最大商品数量
		方法: 
			生产的方法: 同步方法
				判断商品数量 < 最大商品数量
					true: 继续生产
						商品数量 + 1
						打印xxx生产了一个商品，目前库存xxx个商品
						唤醒销售者线程
					false 
						停止当前生产，等待销售
						打印库存已满，xxx停止生产
			销售的方法: 同步方法
				判断商品数量 > 0
					true: 可以销售
						商品数量 - 1
						打印xxx销售了一个商品，目前库存xxx个商品
						唤醒生产者线程
					false: 无货
						停止销售，等待生产
						打印无货，xxx停止销售
	环境类
		创建一个工厂
		创建几个生产者
		创建几个销售者
		启动生产者与销售者

练习

1.四个窗口各自销售100张票
2.四个窗口共同销售1000张票
3.写一个死锁
4.完成龟兔赛跑
5.完成生产者与消费者
6.使用两个线程
	1个线程打印1~26
	1个线程打印a~z
	要求:打印输出结果为1a2b3c4d5e6f....26z
7.使用两个线程
	1个线程打印1~52
	1个线程打印a~z
	要求:打印输出结果为12a34b56c78d910e1112f....5152z

package test01;

public class MyRunnable implements Runnable{
	private int count = 100;
	
	@Override
	public void run() {
		while(count > 0) {
			count--;
			String name = Thread.currentThread().getName();
			System.out.println(name + "卖了1张票, 还剩余" + count + "张票");
		}
	}

}

package test01;

public class Test {
	public static void main(String[] args) {
		new Thread(new MyRunnable(), "窗口一").start();
		new Thread(new MyRunnable(), "窗口二").start();
		new Thread(new MyRunnable(), "窗口三").start();
		new Thread(new MyRunnable(), "窗口四").start();
	}
}

运行结果

package test02;

public class MyRunnable implements Runnable{
	private int count = 1000;
	private final Object LOCK = new Object();
	
	@Override
	public void run() {
		while(count > 0) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (LOCK) {
				if(count <= 0) {
					return;
				}
				count--;
				String name = Thread.currentThread().getName();
				System.out.println(name + "卖了1张票, 还剩余" + count + "张票");
			}
		}
	}

}

package test02;

public class Test {
	public static void main(String[] args) {
		MyRunnable runnable = new MyRunnable();
		new Thread(runnable, "窗口一").start();
		new Thread(runnable, "窗口二").start();
		new Thread(runnable, "窗口三").start();
		new Thread(runnable, "窗口四").start();
	}
}

运行结果

package test03;

public class Test {
	public static void main(String[] args) {
		Object lock01 = new Object();
		Object lock02 = new Object();
		
		Thread thread01 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("线程一开始");
				synchronized (lock01) {
					System.out.println("进入线程一锁一");
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					synchronized (lock02) {
						System.out.println("进入线程一锁二");
					}					
				}
				System.out.println("线程一结束");
			}
		});
		
		Thread thread02 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("线程二开始");
				synchronized (lock02) {
					System.out.println("进入线程二锁二");
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					synchronized (lock01) {
						System.out.println("进入线程二锁一");
					}					
				}
				System.out.println("线程二结束");
			}
		});
		
		thread01.start();
		thread02.start();
	}
}

运行结果

package test04;

public interface LockInterface {
	public static final Object LOCK = new Object();
}

package test04;

public class WGRunnable implements Runnable{

	@Override
	public void run() {
		for(int i = 1; i <= 100; i++) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("乌龟跑了" + i + "米");
		}
		System.out.println("乌龟跑完100米了, 乌龟赢了");
		synchronized (LockInterface.LOCK) {
			LockInterface.LOCK.notify();
		}
	}

}

package test04;

public class TZRunnable implements Runnable{

	@Override
	public void run() {
		for(int i = 10; i <= 100; i+=10) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("兔子跑了" + i + "米");
			
			if(i == 80) {
				System.out.println("兔子睡着了");
				synchronized (LockInterface.LOCK) {
					try {
						LockInterface.LOCK.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}
		System.out.println("兔子跑完100米了");
	}

}

package test04;

public class Test {
	public static void main(String[] args) {
		new Thread(new WGRunnable()).start();
		new Thread(new TZRunnable()).start();
	}
}

运行结果


package test05;

public class Factory {
	private int num = 0; //商品数量
	private final int MAX_NUM = 100; //商品最大数量
	
	public synchronized void product() {
		String name = Thread.currentThread().getName();
		if(num < MAX_NUM) {
			num++;
			System.out.println(name + "生产了1件商品, 现有商品" + num +"件");
			this.notifyAll();
		}
		else {
			System.out.println("库房已满, " + name + "停止生产");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public synchronized void sell() {
		String name = Thread.currentThread().getName();
		if(num > 0) {
			num--;			
			System.out.println(name + "销售了1件商品, 现有商品" + num +"件");
			this.notifyAll();
		}
		else {
			System.out.println("库房无货, " + name + "停止销售");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

package test05;

import java.util.Random;

public class ProductRunnable implements Runnable{
	private Factory factory;
	
	public ProductRunnable(Factory factory) {
		this.factory = factory;
	}
	
	@Override
	public void run() {
		Random random = new Random();
		while(true) {
			int num = random.nextInt(10) + 1;
			try {
				Thread.sleep(num * 100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			factory.product();
		}
	}

}

package test05;

import java.util.Random;

public class SellRunnable implements Runnable{
	private Factory factory;
	
	public SellRunnable(Factory factory) {
		this.factory = factory;
	}
	
	@Override
	public void run() {
		Random random = new Random();
		while(true) {
			int num = random.nextInt(10) + 1;
			try {
				Thread.sleep(num * 100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			factory.sell();
		}
	}
}

package test05;

public class Test {
	public static void main(String[] args) {
		Factory factory = new Factory();
		ProductRunnable pr = new ProductRunnable(factory);
		SellRunnable sr = new SellRunnable(factory);
		
		new Thread(pr, "生产人员一").start();
		new Thread(pr, "生产人员二").start();
		new Thread(pr, "生产人员三").start();
		
		new Thread(sr, "销售人员一").start();
		new Thread(sr, "销售人员二").start();
		new Thread(sr, "销售人员三").start();
	}
}

运行结果

package test06;

public class Test02 {
	public static void main(String[] args) {
		Object lock = new Object();
		
		//打印数字
		Thread thread01 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for(int i = 1; i < 27; i++) {
					System.out.print(i);
					synchronized (lock) {
						lock.notify();
						if(i != 26) {
							try {
								lock.wait();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}						
					}
				}				
			}
		});
		
		//打印字母
		Thread thread02 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				for(int i = 97; i < 123; i++) {
					char c = (char)i;
					System.out.print(c);
					synchronized (lock) {
						lock.notify();
						if(i != 122) {
							try {
								lock.wait();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}						
					}
				}				
			}
		});
		
		thread01.start();
		thread02.start();
	}
}

运行结果

package test07;

public class Test02 {
	public static void main(String[] args) {
		Object lock = new Object();
		
		//打印数字
		Thread thread01 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for(int i = 1; i < 53; i++) {
					System.out.print(i);
					if(i % 2 == 0) {
						synchronized (lock) {
							lock.notify();
							if(i != 52) {
								try {								
									lock.wait();
								} catch (InterruptedException e) {
									e.printStackTrace();
								}
							}							
						}
					}
				}
			}
		});
		
		//打印字母
		Thread thread02 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				for(int i = 97; i < 123; i++) {
					char c = (char)i;
					System.out.print(c);
					synchronized (lock) {
						lock.notify();
						if(i != 122) {
							try {								
								lock.wait();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}							
					}
				}
			}
		});
		
		thread01.start();
		thread02.start();
	}
}

运行结果

新手小白6
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day3 java 学习笔记
01-13
day3 java 笔记
Java学习笔记整理
05-21
这些学习笔记将带你深入了解Java的核心概念，特别是面向对象编程和集合框架。以下是对每个文件内容的详细阐述： 1. **Day0804_HashMap的基本使用.docx**：HashMap是Java集合框架中的一个重要组件，它提供了键值对的...
Java学习笔记 day1
Tang_Qie的博客
04-15 247
.java 编译 -> .class ->JVM(java虚拟机) 运行JDK （java 开发工具包）JRE (java 运行环境)Java转义字符\t 制表位 对齐\n 换行\\ 一个\\" 一个"\' 一个'\r 一个回车\\ 注释\* *\ 多行注释
JAVA学习笔记 day1
salad_oil的博客
11-06 114
java基础
Java学习笔记Day1.1
qq_43559559的博客
09-18 264
安装软件最好新建一个文件夹，方便统一与管理。 到Oracle官网下载jdk 版本8，接着傻瓜式安装 1. 配置jdk环境变量： 步骤（window10） 右击此电脑–>属性–>高级系统设置–>环境变量–>分别在用户变量一框新建以下三个变量： 1.java_home (jdk的安装目录) C:\Program Files\Java\jdk1.8.0_201 2.path（jd...
JAVA学习笔记DAY3——菜鸟教程Java基础
weixin_47227105的博客
06-09 1101
菜鸟教程面向对象之前的部分都走马观花看了一遍。用于突击学习和复习。
java_day3学习笔记
m0_73857800的博客
07-12 799
title: Java_Day_3学习笔记tags: Java。
java自学笔记day2
02-12
Java自学笔记Day2主要涉及了两个核心主题：二进制的使用和运算符，特别是算术运算符。在深入理解这些概念之前，首先要明白Java是一种广泛使用的后端开发语言，它构建于Apache等开源基础设施之上，因此掌握这些基础...
java学习笔记markdown
12-22
Java学习笔记Markdown版包含了多个章节，涵盖了Java编程的多个核心概念。这些笔记是学习Java时进行知识总结的理想资源，尤其适合初学者或正在巩固基础知识的开发者。以下是对这些笔记内容的详细解读： 1. **继承** ...
springboot学习笔记day13.xmind
04-21
springboot学习笔记day13.xmind
JAVA进阶补充
2301_80150315的博客
08-15 879
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 570
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1043
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 349
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 570
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
旅游网站
weixin_43213064的博客
08-16 636
【代码】springboot旅游网站
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 991
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
Mybatis XML 数据源为 Oracle 之批量插入或更新 Merge Into 的具体介绍与使用
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
08-12 742
由于近期在所开发的项目中，对于数据入库，有存在即更新，不存在则插入的需求，因此发现了 Oracle中的 MergeInto 命令。本文将对MergeInto的用法进行介绍并将 MergeInto 和批量插入进行结合，同时还会对在 MergeInto 开发中遇到的问题进行总结。MergeInto 命令是 Oracle9i 中新增的命令，有了 MergeInto 语句，我们对数据能够不仅仅只做单一的插入或单一的更新，而是可以将更新与插入一起操作。
构造方法，JavaBean，对象内存图，基础数据类型和引用数据类型
qq_63126439的博客
08-14 285
栈内存处理完数据之后会退出，指向推内存的箭头都会消失，当没有人指向他的时候，堆内存中的数据也会被移除。带参构造方法和无参数构造方法，两者方法名相同，但参数不同，这叫做构造方法的重载。方法区，新增元空间，把原来的方法区的多种功能进行了拆分。创造对象的时候，虚拟机会自动调用构造方法，作用是给成员变量进行初始化的。只要是看见new就会在堆内存创建新的空间，两个空间是独立的，互不影响。基础数据类型，在变量当中存储真实的数据值，和其他空间没有任何关系。使用其他空间的数值，自己的空间存储的是地址值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值