Day17学习Java

最新推荐文章于 2024-08-26 10:41:03 发布
最新推荐文章于 2024-08-26 10:41:03 发布
阅读量570 收藏
点赞数 15
文章标签： 学习 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45621552/article/details/139100896
版权

仓储模型

需求：
生产者线程不断的生产面包放入仓库
消费者线程不断的从仓库中取出面包
做到先生产的面包先卖出

分析：
生产者线程、消费者线程、面包类、仓库类
先生产的面包先卖出 – 队列模式（LinkedList）

场景：一个生产者，一个消费者

public static void main(String[] args) {
		
	Store store = new Store();
		
	Producer p = new Producer(store);
	Consumer c = new Consumer(store);
		
	p.start();
	c.start();
}

public class Store {
	这里赋予仓库最大的限度为20
	private static final int MAX_INIT_CAPACITY = 20;

	private int curCapacity;//初始容量
	private int maxCapacity;//最大容量
	private LinkedList<Cake> list;
	
	public Store() {
		this(MAX_INIT_CAPACITY);
	}

	public Store(int maxCapacity) {
		this.maxCapacity = maxCapacity;
		list = new LinkedList<>();
	}
	
	//入库 - 生产者线程不断的调用
	public synchronized void push(Cake cake){
		if(curCapacity >= maxCapacity){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		curCapacity++;
		list.add(cake);
		System.out.println("入库，当前容量为：" + curCapacity);
		
		notify();
	}
	
	//出库 - 消费者线程不断的调用
	public synchronized Cake pop(){
		if(curCapacity <= 0){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		curCapacity--;
		Cake cake = list.removeFirst();
		System.out.println("出库，当前容量为：" + curCapacity + " -- " + cake);
		notify();
		return cake;
	}
}

public class Cake {

	private String brand;//品牌
	private String datetime;//日期时间
	
	public Cake(String brand, String datetime) {
		this.brand = brand;
		this.datetime = datetime;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public String getDatetime() {
		return datetime;
	}

	public void setDatetime(String datetime) {
		this.datetime = datetime;
	}

	@Override
	public String toString() {
		return brand + " -- " + datetime;
	}
}

public class Producer extends Thread{//生产者继承Thread
	
	private Store store;//定义了一个名为 store 的变量，该变量是一个 Store 类型的对象,并且是私有的。
	
	public Producer(Store store) {
		this.store = store;
	}

	@Override
	public void run() {
		while(true){
			Cake cake = new Cake("好利来", LocalDateTime.now().toString());
			store.push(cake);
		}
	}
}

public class Consumer extends Thread{
	//消费者继承Thread
	private Store store;
	
	public Consumer(Store store) {
		this.store = store;
	}

	@Override
	public void run() {
		while(true){
			store.pop();
		}
	}
}

场景：多个生产者，多个消费者

public static void main(String[] args) {
		
	Store store = new Store();
		
	Producer p1 = new Producer(store);		
	Producer p2 = new Producer(store);
	Consumer c1 = new Consumer(store);
	Consumer c2 = new Consumer(store);
		
	p1.start();
	p2.start();
	c1.start();
	c2.start();
}

public class Store {
	
	private static final int MAX_INIT_CAPACITY = 20;

	private int curCapacity;
	private int maxCapacity;
	private LinkedList<Cake> list;
	
	public Store() {
		this(MAX_INIT_CAPACITY);
	}

	public Store(int maxCapacity) {
		this.maxCapacity = maxCapacity;
		list = new LinkedList<>();
	}
	
	//入库 - 生产者线程不断的调用
	public synchronized void push(Cake cake){
		while(curCapacity >= maxCapacity){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		curCapacity++;
		list.add(cake);
		System.out.println("入库，当前容量为：" + curCapacity);
		
		notifyAll();
	}
	
	//出库 - 消费者线程不断的调用
	public synchronized Cake pop(){
		while(curCapacity <= 0){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		curCapacity--;
		Cake cake = list.removeFirst();
		System.out.println("出库，当前容量为：" + curCapacity + " -- " + cake);
		notifyAll();
		return cake;
	}
}

public class Cake {

	private String brand;
	private String datetime;
	
	public Cake(String brand, String datetime) {
		this.brand = brand;
		this.datetime = datetime;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public String getDatetime() {
		return datetime;
	}

	public void setDatetime(String datetime) {
		this.datetime = datetime;
	}

	@Override
	public String toString() {
		return brand + " -- " + datetime;
	}
}

public class Producer extends Thread{
	
	private Store store;
	
	public Producer(Store store) {
		this.store = store;
	}

	@Override
	public void run() {
		while(true){
			Cake cake = new Cake("好利来", LocalDateTime.now().toString());
			store.push(cake);
		}
	}
}

public class Consumer extends Thread{
	
	private Store store;
	
	public Consumer(Store store) {
		this.store = store;
	}

	@Override
	public void run() {
		while(true){
			store.pop();
		}
	}
}

使用Java自带的线程池

Executors：线程池的工具类
ExecutorService：线程池的接口

public static void main(String[] args) {
		
	//创建单个线程的线程池
	ExecutorService pool = Executors.newSingleThreadExecutor();
		
	for (int i = 1; i <= 100; i++) {
		//提交任务
		pool.execute(new Task(i));
	}
		
	//关闭线程池
	pool.shutdown();
}

public static void main(String[] args) {

	//创建指定线程个数的线程池
	ExecutorService pool = Executors.newFixedThreadPool(3);
	
	for (int i = 1; i <= 100; i++) {
		//提交任务
		pool.execute(new Task(i));
	}
	
	//关闭线程池
	pool.shutdown();
}

public static void main(String[] args) {
		
	//创建可缓存的线程池（该线程池里有0个线程，任务等待就会创建新的线程去服务他，60秒没有工作的线程认为是闲置线程会被回收）
	ExecutorService pool = Executors.newCachedThreadPool();
		
	for (int i = 1; i <= 100; i++) {
		//提交任务
		pool.execute(new Task(i));
	}
		
	//关闭线程池
	pool.shutdown();
}

public static void main(String[] args) throws InterruptedException {
		
	//创建延迟任务的线程池
	ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);
	
	//设置延迟时间
	pool.awaitTermination(5, TimeUnit.SECONDS);
		
	for (int i = 1; i <= 100; i++) {
		//提交任务
		pool.execute(new Task(i));
	}
		
	//关闭线程池
	pool.shutdown();
}

线程

需求：计算任务，一个包含了2万个整数的数组，分拆了多个线程来进行并行计算，最后汇总出计算的结果。

注意：

​ 1.使用带返回值的任务类方式解决该需求

​ 2.带有返回值的任务类和线程池联合使用

public static void main(String[] args) throws InterruptedException, ExecutionException {
		
	//创建数组，并初始化数据
	int[] arr = new int[20000];
	for (int i = 0; i < arr.length; i++) {
		arr[i] = i+1;
	}
		
	//创建线程池
	FastThreadPool pool = new FastThreadPool(4, 4, 60, TimeUnit.SECONDS, 20);
		
	//创建任务
	Task task1 = new Task(arr, 0, 5000);
	Task task2 = new Task(arr, 5000, 10000);
	Task task3 = new Task(arr, 10000, 15000);
	Task task4 = new Task(arr, 15000, 20000);
		
	//提交任务，并返回Future对象（带有返回值的任务类返回的数据就存在Future对象）
	Future<Integer> f1 = pool.submit(task1);
	Future<Integer> f2 = pool.submit(task2);
	Future<Integer> f3 = pool.submit(task3);
	Future<Integer> f4 = pool.submit(task4);
		
	//合并线程结果
	System.out.println(f1.get() + f2.get() + f3.get() + f4.get());
		
	pool.shutdown();	
}

public class Task implements Callable<Integer>{

	private int[] arr;
	private int startIndex;
	private int endIndex;
	
	public Task(int[] arr, int startIndex, int endIndex) {
		this.arr = arr;
		this.startIndex = startIndex;
		this.endIndex = endIndex;
	}
	
	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (int i = startIndex; i < endIndex; i++) {
			sum += arr[i];
		}
		return sum;
	}
}

自定义线程池

public static void main(String[] args) {
		
	ThreadPoolExecutor pool = new ThreadPoolExecutor(
			5, //核心线程数
			20, //最大线程数
			60, //闲置时间
			TimeUnit.SECONDS,//时间单位 
			new ArrayBlockingQueue<>(20),//任务队列 - 有界队列 
			new ThreadFactory() {//自定义线程工厂(可以给线程定义名称和优先级...)
				private int count = 1;
				@Override
				public Thread newThread(Runnable r) {
					Thread t = new Thread(r, "线程" + count);
					t.setPriority(Thread.MAX_PRIORITY);
					count++;
					return t;
				}
			}, 
			new RejectedExecutionHandler() {
					
				@Override
				public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
					System.out.println("任务被拒绝了...");
				}
			});
		
	//闲置时间到后，核心线程和普通线程都会被销毁
	//不设置该方法，闲置时间到后只会销毁普通线程
	//经验：不用该方法，因为把所有的线程都销毁，就没有线程复用率这个概念了
	//pool.allowCoreThreadTimeOut(true);
		
	for (int i = 1; i <= 100; i++) {
		//提交任务
		pool.execute(new Task(i));
	}
		
	//关闭线程池
	pool.shutdown();
		
}

public class Task implements Runnable{

	private int num;
	
	public Task(int num) {
		this.num = num;
	}

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + "线程被执行了任务" + num);
	}
}
阿船·
关注
  • 15
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java学习day10
qq_54406795的博客
04-02 236
java学习day10： TPDO 自动生成的构造函数存根 1、访问本类的成员变量 2、在本类的成员方法中，访问另一个成员方法 3、在构造函数中调用this方法 抽象方法 加上Aabstract 关键字，去掉大括号，直接分号结束 1、抽象类不能直接使用，不能直接实例化 2、必须用一个子类来继承抽象的父类 3、子类必须覆盖抽象父类中的所有抽象方法 4、一个抽象类不一定含有抽象方法 5、但是一个有抽象方法的类一定是抽象类 package com.hg.day.demo03; public abstract c
学习Java day3
xiaofanfan1125的博客
11-29 293
练习：输出50个hello world！ class ForTest { public static void main(String[] args) { for(int i = 1; i <= 50; i++){ System.out.println("Hello World!"); } } } 练习： int num =1 ; for(System.out.print("a");num <= 3;System.out.print("c"),num++){
JAVA学习DAY1
weixin_47848121的博客
04-22 342
1.数据库SQL语言学习（3h）4.计算机网络（0.8h）2.华为测评（1h）
java后端学习DAY04
2302_76786736的博客
04-12 360
JAVAGUIDE：java基础常见面试总结（上）
Java后端学习DAY06
2302_76786736的博客
04-16 322
湖科大计网第3章。
Day17 学习java（多线程）
Qiyesama1314的博客
01-24 179
多线程 程序，进程，线程 程序 : 一组命令的集合,为了完成指定的功能,程序是静态概念,一般保存在硬盘当中 进程 : 正在运行的程序,是一个动态概念,需要保存在内存当中,操作系统会分配对应的PID,当我们直接关闭某个进程的时候,该进行会在运行内存中被销毁 线程 : 一个程序中,不同的执行分支,如果同一个时间节点允许多个线程同时执行的时候,我们称为支持多线程 在Java中,main方法开始执行,就是一个线程,称为主线程 并行和并发 并行 : 多个CPU,同时执行多个任务 并发 : 一个CPU,同时执行多个任务
Java学习day01-day15学习资料
04-05
这份资料包括了day01至day15的学习内容，主要围绕Java编程的核心概念展开。以下是对每个子文件名中涉及知识点的详细解释： 1. **day02**: 这部分可能涉及Java的基础语法，如变量、数据类型、运算符、流程控制语句...
Java_day17上课资料.zip
04-01
在这个压缩包“Java_day17上课资料.zip”中，我们可以期待找到与Java相关的各种学习材料，如课件、示例代码和练习题，帮助我们巩固和提升Java技能。 首先，Java的核心特性之一是它的平台独立性，这得益于Java虚拟机...
学习JavaEE的day17
03-03
在“学习JavaEE的day17”这个主题中，我们主要关注的是Java企业级应用开发的相关知识。JavaEE，全称Java Platform, Enterprise Edition，是一个用于构建和部署分布式企业级应用的平台。它提供了丰富的API和服务，...
day38-栈和队列理论学习【python】
canGfly的博客
08-21 476
栈（Stack）: 使用 Python 的list实现。主要操作有pushpoppeek, 和is_empty。队列（Queue）: 使用实现。主要操作有enqueuedequeuepeek, 和is_empty。这两种数据结构可以通过这些操作灵活地处理和存储数据。在实际应用中，选择使用哪种数据结构取决于具体的需求和场景。ok了，就到这里叭～～～​​​。
数据结构（邓俊辉）学习笔记】优先级队列 08——左式堆：结构
weixin_44399845的博客
08-23 953
学习左式堆的结构
vue.js学习步骤
m0_63178019的博客
08-23 717
Vue.js 从一个简单的实验性项目成长为一个功能强大、社区活跃的前端框架，其发展历程展示了它对前端开发的持续创新和改进。通过引入先进的功能和不断扩展的生态系统，Vue.js 为开发者提供了一个高效、灵活的工具，满足了不同规模和复杂度应用的需求。
学习大数据DAY44 帆软 report 配置
shh2000424的博客
08-23 1085
署，并设置服务器开机自启动，并请实操演示 得分点（完成得满分，未完成得。服务器容器的端口修改，并将内存调大，请实操演示 得分点（完成得。2 部署 tomcat web 服务。1 安装帆软 report v11。配置环境变量 推荐用自己的名字。等几秒查看下进程或者端口。3 显示 帆软 报表平台。分 服务器开机自启动。初始化设置下用户和密码。在它的第二行上面添加。
Golang学习笔记-Golang中的锁
qq_24428851的博客
08-25 611
Go标准库的中的sync.Cond是一个条件变量，它可以让一系列的goroutine都在满足特定条件下时候被唤醒，每一个 sync.Cond 结构体在初始化时都需要传入一个互斥锁，我们可以通过下面的例子了解它的使用方法。因为请求的哈希在业务上一般表示相同的请求，所以上述代码使用它作为请求的键。这个是Go语言的扩展包中提供的另外一个信号量，它能够在一个服务中抑制对下游的多次重复请求，比如在redis的缓存雪崩中，能够限制对同一个 Key 的多次重复请求，减少对下游的瞬时流量。上述两个加起来，只占用8个字节。
快速学习“堆“排序（C语言数据结构）
m0_75235246的博客
08-26 296
堆的实现其实并不难，难的是要用堆实现排序，也就是堆的运用。下面需要探究一下堆的排序是怎样的。如何利用堆进行升序或者降序的排序。
先从路径优化开始学习FastPlanner之B样条曲线平滑路径（一）：从拉格朗日插值到B样条曲线
qq_51013517的博客
08-25 705
B样条学习整理，易错点和关键点。我会列出学习他人的博客，但我不涉及具体推导，原理讲解，旨在于理解必须概念后写代码出效果和使用。
Python 爬虫爬取豆瓣电影列表信息，爬虫的原理，应用领域介绍学习
最新发布
m0_50641264的博客
08-26 1139
Python 爬虫爬取豆瓣电影列表信息，爬虫的原理，应用领域介绍学习
你是如何克服编程学习中的挫折感的？
刘念卿的博客
08-24 735
记得有一次，我在一个项目中遇到了一个顽固的Bug，连续几天都无法解决，感觉自己被困在了Bug的迷宫中。同时，在实践过程中，定期进行反思，思考哪些方法有效，哪些步骤可以改进，有助于不断提高编程水平，减少挫折感。例如，在解决一个难题之后，花点时间总结成功的经验和过程中学到的新知识，能够增强自信心并为未来的挑战做好准备。但后来，我决定从最基本的概念入手，逐步理解算法的每一个步骤，并尝试用自己的语言解释每个环节。每一次的挑战都是一次成长的机会，通过不断尝试和坚持，你将发现编程学习的乐趣，并在这个过程中不断进步。
Java JDBC与XML技术 DAY03
Java JDBC/XML-Day03知识点总结 一、Java JDBC/XML概述 Java JDBC/XML是一种Java标准的数据库连接API，允许开发者使用Java语言与各种数据库管理系统（DBMS）进行交互。JDBC/XML提供了一种通用的数据库连接方式，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值