Day18 学习java（死锁，线程通信，线程池，单例模式）

已于 2022-02-09 11:26:27 修改
阅读量209 收藏
点赞数
文章标签： java 单例模式 开发语言
于 2022-01-25 19:56:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qiyesama1314/article/details/122691100
版权

死锁

概述

双方都持有对方需要的资源，同时双方又不肯主动交出自己拥有的对方所需要的资源

代码实现

public class Thread_01 {

	public static void main(String[] args) {
		Object o1 = new Object();
		Object o2 = new Object();
		Thread t1 = new Thread(new P1(o1, o2));
		Thread t2 = new Thread(new P2(o1, o2));
		t1.setName("t1");
		t2.setName("t2");
		t1.start();
		t2.start();
	}

}

class P1 implements Runnable {
	Object o1;
	Object o2;

	public P1(Object o1, Object o2) {
		this.o1 = o1;
		this.o2 = o2;
	}

	@Override
	public void run() {
		synchronized (o1) {
			try {
				// 睡一下，确保o2被锁
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

			synchronized (o2) {
				System.out.println(Thread.currentThread().getName() + "执行完成");
			}
		}
	}

}

class P2 implements Runnable {
	Object o1;
	Object o2;

	public P2(Object o1, Object o2) {
		this.o1 = o1;
		this.o2 = o2;
	}

	@Override
	public void run() {
		synchronized (o2) {
			try {
				// 睡一下，确保o1被锁
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			synchronized (o1) {
				System.out.println(Thread.currentThread().getName() + "执行完成");
			}
		}
	}

}

在这里插入图片描述
程序永远运行，一直没有想要的输出结果

线程通信

概述

wait 让当前在该对象的线程进入等待状态，会释放持有的锁

无参或者传入0 表示一直等待，不会自动唤醒，只能等着notify唤醒它。也可以传入long类型的值，类似于sleep，时间到了自己唤醒wait和notify的使用时序非常重要，wait执行后原地等待，直到被唤醒之后继续执行（资源足够的时候）

使用方式

需求：打印奇数和偶数
1.有一个业务类，有一个打印奇数和打印偶数的方法
2 有一个变量 count 记录当前的数字
3 两个线程,分别调用打印奇数和打印偶数的方法

public class Thread_02 {

	public static void main(String[] args) {
		Num num = new Num();
		Thread t1 = new PrintE(num);
		Thread t2 = new PrintO(num);
		t1.start();
		t2.start();

	}

}

// 有一个业务类，有一个打印奇数和打印偶数的方法
class Num {
	// 有一个变量 count 记录当前的数字
	private int count = 1;

	public synchronized void printEven() {
		System.out.println("奇数" + count++);
		this.notify();
		try {
			Thread.sleep(1000);
			this.wait();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		// System.out.println("wait" + count);

	}

	public synchronized void printOdd() {
		System.out.println("偶数" + count++);
		this.notify();
		try {
			Thread.sleep(1000);
			this.wait();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	}
}

// 打印奇数
class PrintE extends Thread {
	Num num;

	public PrintE(Num num) {
		super();
		this.num = num;
	}

	@Override
	public void run() {
		while (true) {
			num.printEven();
		}
	}

}

// 打印偶数
class PrintO extends Thread {
	Num num;

	public PrintO(Num num) {
		super();
		this.num = num;
	}

	@Override
	public void run() {
		while (true) {
			num.printOdd();
		}
	}

}

在这里插入图片描述

生产者和消费者

https://blog.csdn.net/qq_39575279/article/details/87940298
小练：
1 一个业务类SynStack其中有一个变量,用来保存已生产的元素个数
2 业务类中有一个char数组,用于保存生产的元素(假如只生产a-z这些字母)
3 业务类中需要有两个方法,一个是生产push，一个消费pop

public class Lwork {
	public static void main(String[] args) {
		SynStack ss = new SynStack();
		Producer pro = new Producer(ss);
		Consumer con = new Consumer(ss);
		Thread t1 = new Thread(pro);
		Thread t2 = new Thread(con);
		t1.setName("t1");
		t2.setName("t2");
		t1.start();
		t2.start();
	}
}

// 1 一个业务类SynStack其中有一个变量,用来保存已生产的元素个数
class SynStack {
	// 2 业务类中有一个char数组,用于保存生产的元素(假如只生产a-z这些字母)
	private char[] chars = new char[10];
	// 容量
	private int full = 10;
	// 个数
	private int empty = 0;

	// 3 业务类中需要有两个方法,一个是生产push，一个消费pop
	public synchronized void push(char c) {
		// push方法主要用于向数组中添加数据。个数要+1，还要判断是否添加满了,满了就挂起进入等待
		if (full == 0) {
			this.notify();
			try {
				System.out.println(Thread.currentThread().getName() + "wait");
				this.wait();
			} catch (Exception e) {
				e.printStackTrace();
			}
		} else {
			System.out.println("生产者添加了一个" + c);
			chars[empty++] = c;
			full--;
			this.notify();
		}
	}

	public synchronized char pop() {
		// pop方法主要用于取出数组中数据。个数要-1，还要判断是否消费完了,完了就挂起进入等待
		if (empty == 0) {
			this.notifyAll();
			try {
				System.out.println(Thread.currentThread().getName() + "wait");
				this.wait();
			} catch (Exception e) {
				e.printStackTrace();
			}
		} else {
			char c = chars[--empty];
			System.out.println("消费者取出了一个" + c);
			full++;
			this.notify();
			return c;
		}
		return 'A';
	}
}

// 负责生产
class Producer implements Runnable {
	SynStack ss;

	public Producer(SynStack ss) {

		this.ss = ss;
	}

	@Override
	public void run() {
		Random r = new Random();
		while (true) {
			try {
				Thread.sleep(1000);
			} catch (Exception e) {
				e.printStackTrace();
			}
			char c = (char) (r.nextInt(26) + 97);
			ss.push(c);
		}
	}

}

// 负责消费
class Consumer implements Runnable {
	SynStack ss;

	public Consumer(SynStack ss) {
		this.ss = ss;
	}

	@Override
	public void run() {
		while (true) {
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			ss.pop();
		}
	}

}

在这里插入图片描述

线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程， 对性能影响很大。

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完 放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交 通工具。
好处：
a) 提高响应速度（减少了创建新线程的时间）
b) 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
c) 便于线程管理
i. corePoolSize：核心池的大小
ii. maximumPoolSize：最大线程数
iii. keepAliveTime：线程没有任务时最多保持多长时间后会终止

线程池API
 JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
 ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
 void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
 Future submit(Callable task)：执行任务，有返回值，一般又来执行Callable
 void shutdown() ：关闭连接池
 Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
 Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
 Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
 Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
 Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

单例模式

让某个类只实例化一个对象，构造方法私有化，静态变量保存对象，公共的静态方法用于获取该类对象
饿汉模式
饿汉模式在多线程环境下没有问题，因为不管多少线程，类只能被加载一次，所以只会被初始化一次，也就意味着只能创建一个对象

public class SingleLeton_01 {
	private static SingleLeton_01 singLeton = new SingleLeton_01();

	public static SingleLeton_01 getInstance() {
		return singLeton;
	}

}

test测试

public class Test_01 {

	public static void main(String[] args) {
		TestPrint t1 = new TestPrint();
		TestPrint t2 = new TestPrint();
		TestPrint t3 = new TestPrint();
		TestPrint t4 = new TestPrint();
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}

}

class TestPrint extends Thread {

	@Override
	public void run() {
		System.out.println(SingleLeton_01.getInstance());
	}

}

在这里插入图片描述
懒汉模式
存在问题

public class SingleLeton_02 {
	private static SingleLeton_02 singLeton = null;

	public static SingleLeton_02 getInstance() {
		if (singLeton == null) {
			singLeton = new SingleLeton_02();
		}
		return singLeton;
	}

}

test测试

public class Test_01 {

	public static void main(String[] args) {
		TestPrint t1 = new TestPrint();
		TestPrint t2 = new TestPrint();
		TestPrint t3 = new TestPrint();
		TestPrint t4 = new TestPrint();
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}

}

class TestPrint extends Thread {

	@Override
	public void run() {
		System.out.println(SingleLeton_02.getInstance());
	}

}

在这里插入图片描述
可以看到出现了不一样的内存地址
第一种方法就是直接把方法加上synchronized，如下
在这里插入图片描述
但是这种每次只允许一个线程判断，效率很低很低
下面提供第二种方法
在这里插入图片描述

薯薯条薯条
关注
day21-多线程下的单例模式；死锁；线程通信；线程池
UNknowmer的博客
04-19 233
文章目录单例模式死锁线程通信生产者和消费者线程池 单例模式 单例模式让某个对象只能实例化对象一次，保证只有一个对象，传统的单例模式写法在多线程中是不想的。 if(s==null){ s = new SingLeton(); } 可能会有多个线程进入判断，导致线程创建多个对象。 如果直接在方法加锁可以避免这个效果，可是这样效率实在太低，为了解决这个问题，我们可以利用两次判断来实现只创建一个对象。 if(s==null){ synchronized(SingLeton.class){ if(s==n
day18+day19:java多线程
卓汶的博客
11-06 720
多线程 1、基本概念：程序、进程、线程的理解 程序( program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码,静态对象。 进程( process) 是程序的一次执行过程,或是正在运行的一个程序。是一个动态的过程:有它自身的正生、存在和消亡的过程。——生命周期 如:运行中的QQ,运行中的MP3播放器 程序是静态的,进程是动态的 进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域 线程( thread) ,进程可进一步细化为线程,是一个程序内部的一条执行路
Day22死锁、线程通信、单例模式
Poissoner的博客
01-25 218
1.死锁 1.1 概述 死锁：就是在执行过程中，都遇到了对方进入加锁的方法中，从而导致大家都访问不了的状态 原理： 1.某一个线程执行完成，需要先后嵌套锁定执行两个对象，并且在这个过程中，先锁定第一个对象 2.另一个线程执行完成，需要先后嵌套锁定执行两个对象，并且在这个过程中，先锁定第二个对象 3.在第一个线程执行到第二个对象的时候，发现已经被锁定，只能等待 4.在第二个线程执行到第一个对象的时候，发现已经被锁定，只能等待 1.2代码实现 public class Thread_01_DeadL
day-22死锁，线程通信，单例模式，线程池
t17246的博客
01-25 263
1死锁 就是在执行过程中，都遇到了对方进入加锁的方法中，从而导致大家都访问不了的状态 死锁原理： 1某一个线程执行完成，需要先后嵌套 锁定，执行俩个对象，并在这个过程中， 先锁定第一个对象 2另外一个线程，执行完成，先后嵌套，锁定 执行俩个对象，并且在这个过程中，先锁定第二个对象 3在第一个线程执行到第二个对象的时候，发现已经被锁定，只能等待 4在第二个线程执行到第一个对象的时候，发现已经被锁定只能等等待 publi...
day_22 死锁、线程通信、单例模式、线程池
d1784722753的博客
01-25 245
死锁、线程通信、单例模式、线程池 1.死锁 1.1 概述 就是在执行过程中，都遇到了对方进入加锁的方法中，从而导致大家都访问不了的状态 原理： 某一个线程执行完成 需要先后 嵌套 锁定执行两个对象，并且在这个过程中，先锁定第一个对象 另一个线程 先锁定第二个对象 在第一个线程执行到第二...
Day21 单例模式、死锁、线程通信、线程池
weixin_46311092的博客
04-22 124
单例模式 多线程下的单例模式 饿汉模式是线程安全的，需要对懒汉模式加锁 可能有多个线程同时进入s==null判断,导致创建多个对象 如果直接对方法加锁是可以的,但是效率低,我们只需要保证创建对象的时候,加锁,只要创建过对象之后,就不加锁即可 public class Thread_01_SingLeton { public static void main(String[] args) { Thread t1 = new Test_01(); Thread t2 = new Test_01();
Day16-Java进阶-线程通信&线程生命周期&线程池&单例设计模式
weixin_68063226的博客
04-24 407
【代码】Day16-Java进阶-线程通信&线程生命周期&线程池&单例设计模式。
Java系列课程第二十一天（单例模式、死锁、线程通信、线程池）
java_YHkaifa的博客
04-19 107
Day21 单例模式、死锁、线程通信、线程池 1. 单例模式 1.1 概述 让某个类只能实例化对象一次,保证只有一个对象，每次用的都是同一个对象 1.2 实现 传统的写法在多线程中是不行的 可能有多个线程同时进入s==null判断,导致创建多个对象 如果直接对方法加锁是可以的,但是效率低,我们只需要保证创建对象的时候,加锁,只要创建过对象之后,就不加锁即可 这样就能保证 创建对象的时候 排队,但是只创建一次 第二次在进行多线程获取对象的时候,就不需要排队了,因为在外面的s==null 就为false了
从新开始学Java JavaSE基础day21(线程安全、死锁、线程通信、线程池)
lion的博客
07-03 122
一、线程同步 1.1 概念 在多个线程同时执行，如果没有关系，则互相不影响无需考虑线程的安全以及同步，但是如果多个线程执行使用相同的变量或其他数据，就可能由于不同线程的运行导致数据不同步，从而产生线程安全问题 线程安全：多个线程同时执行，在同一时间对数据进行操作，可能导致数据的不准确 Java中提供了同步机制 (synchronized)来解决。 1.2 线程同步方式 1.2.1 同步代码块 使用synchronized关键字将代码块中的代码进行同步，当多个线程执行相同代码时，会进行阻塞（等待其他线程执行结
Java自学习day20-多线程总结下（Thread类、线程的同步机制、同步代码块、Lock锁、线程安全的单例模式、死锁问题、线程通信）
加油鸭
05-16 175
Thread类中的常用的方法 * 1. start():启动当前线程；调用当前线程的run() * 2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中 * 3. currentThread():静态方法，返回执行当前代码的线程 * 4. getName():获取当前线程的名字 * 5. setName():设置当前线程的名字 * 6. yield():释放当前cpu的执行权 * 7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直
Java学习路线：day19
01-20
多线程线程的生命周期线程的同步同步代码块处理实现Runnable的线程安全问题同步代码块处理继承Thread类的线程安全...单例模式之懒汉式死锁的问题Lock锁方式解决线程安全问题线程的通信sleep()和wait()的异同经典例题...
day24-多线程-设计模式.7z
06-29
在探索多线程和设计模式的同时，还要关注线程间的通信（如使用`wait()`、`notify()`、`notifyAll()`等）、同步机制（如`synchronized`关键字、`Lock`接口等）、线程池的使用（`ExecutorService`、`...
java 异常包装
最新发布
fdvvg的博客
10-17 211
通过异常包装，可以在Java中有效地处理和传递异常。这样做不仅能保持原始异常的信息，还能为上层调用者提供更多的上下文信息。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 350
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 668
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
qq_57340195的博客
10-17 518
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
Springboot api http并发测试请求
nsa65223的专栏
10-11 352
【代码】Springboot api http并发测试请求。
spring task的使用场景
qq_40603125的博客
10-13 323
spring任务调度框架约定的时间。
【Java 22 | 8】 深入解析Java 22 ：Pattern Matching 特性详解
颜淡慕潇
10-17 1183
Java 22 进一步扩展了模式匹配（Pattern Matching）功能，简化了类型检查和条件表达式的使用。此特性不仅提升了代码的可读性，还减少了常见的错误。以下是对 Java 22 中模式匹配的详细介绍，包括基础概念、增强特性、使用场景、示例代码，以及如何在实际项目中有效利用模式匹配
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值