综合实战：生产者-消费者

最新推荐文章于 2024-07-02 00:52:04 发布
最新推荐文章于 2024-07-02 00:52:04 发布
阅读量132 收藏
点赞数
分类专栏： Java_基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27906715/article/details/105180685
版权

生产者与消费者基本程序模型

在多线程开发过程之中最为著名的案例就是生产者与消费者操作，该操作的主要流程如下：
生产者负责信息内容的生产；
每当生产者生产完成一项完整的信息之后消费者要从这里面取走信息；
如果生产者没有生产者则消费者要等待它生产完成，如果消费者还没有对信息进行消费，则生产者应该等到消费处理完成之后再继续生产。
程序的基本实现
可以将生产者与消费者定义为两个独立的线程类对象，但是对于现在生产的数据，可以使用如下的组成：
数据一：title = 王建、content = 宇宙大帅哥；
数据二：title = 小高、content = 猥琐第一人；
既然生产者与消费者是两个独立的线程，那么这个两个独立的线程之间就需要有一个数据的保存集中点，那么可以单独定义一个Message类实现数据的保存。
在这里插入图片描述
范例：程序基本结构

package cn.mldn.demo ;
public class DeadLock {
	public static void main(String[] args) throws Exception {
		Message msg = new Message();
		new Thread(new Producer(msg)).start();	// 启动生产者线程
		new Thread(new Consumer(msg)).start();	// 启动消费者线程
	}
}
class Producer implements Runnable {
	private Message msg ;
	public Producer(Message msg) {
		this.msg = msg ;
	}
	@Override
	public void run() {
		for (int x = 0; x < 100; x ++) {
			if (x % 2 == 0) {
				this.msg.setTitle("王建");
				this.msg.setContent("宇宙大帅哥");
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} else {
				this.msg.setTitle("小高");
				this.msg.setContent("猥琐第一人，常态保持");
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}
class Consumer implements Runnable {
	private Message msg ;
	public Consumer(Message msg) {
		this.msg = msg ;
	}
	@Override
	public void run() {
		for (int x = 0; x < 100; x ++) {
			System.out.println(this.msg.getTitle() + " - " + this.msg.getContent()) ;
		}
	}
	
	
}
class Message {
	private String title ;
	private String content ;
	public void setContent(String content) {
		this.content = content ;
	}
	public void setTitle(String title) {
		this.title = title ;
	}
	public String getContent() {
		return content ;
	}
	public String getTitle() {
		return title ;
	}
}

通过整个代码的执行你会发现此时有两个主要的问题：
问题一：数据不同步了；
问题二：生产一个取走一个，但是发现有了重复生产和重复取出问题。

解决生产者-消费者同步问题

如果要解决问题，首先解决的就是数据同步的处理问题，如果要想解决数据同步最简单的做法是使用synchronized关键字定义同步代码块或同步方法，于是这个时候对于同步的处理就可以直接在Message类中完成。
范例：解决同步操作

package cn.mldn.demo ;
class Message {
	private String title ;
	private String content ;
	public synchronized void set(String title, String content) {
		this.title = title ;
		this.content = content ;
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public synchronized String get() {
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return this.title + " - " + this.content ;
	}
}
public class DeadLock {
	public static void main(String[] args) throws Exception {
		Message msg = new Message();
		new Thread(new Producer(msg)).start();	// 启动生产者线程
		new Thread(new Consumer(msg)).start();	// 启动消费者线程
	}
}
class Producer implements Runnable {
	private Message msg ;
	public Producer(Message msg) {
		this.msg = msg ;
	}
	@Override
	public void run() {
		for (int x = 0; x < 100; x ++) {
			if (x % 2 == 0) {
				this.msg.set("王建","宇宙大帅哥");
				
			} else {
				this.msg.set("小高","猥琐第一人，常态保持");
			}
		}
	}
}
class Consumer implements Runnable {
	private Message msg ;
	public Consumer(Message msg) {
		this.msg = msg ;
	}
	@Override
	public void run() {
		for (int x = 0; x < 100; x ++) {
			System.out.println(this.msg.get()) ;
		}
	}
}

在进行同步处理的时候肯定需要有一个同步的处理对象，那么此时肯定要将同步操作交由Message类处理。这个发现数据已经可以保持一致了，但是对于重复操作的问题依然存在。

王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持
小高 - 猥琐第一人，常态保持

利用Object类解决重复操作

如果说现在要想解决生产者与消费者的问题，那么最好的解决方案就是使用等待与唤醒机制。而对于等待与唤醒的操作机制主要依靠的是Object类中提供的方法处理的。
等待机制：
死等：public final void wait() throws InterruptedException;
设置等待时间：public final void wait(long timeout) throws InterruptedException;
设置等待时间：public final void wait(long timeout, int nanos) throws InterruptedException;
唤醒第一个等待线程：public final void notify();
唤醒全部的等待线程：public final void notifyAll() ;
如果此时有若干个等待线程的话，那么notify（）表示的是唤醒第一个等待的，而其他的线程继续等待，而notifyAll（）表示会唤醒所有等待的线程，哪个线程的优先级高就有可能先执行。
对于当前的问题主要的解决应该通过Message类完成处理。
范例：修改Message类

package cn.mldn.demo ;
class Message {
	private String title ;
	private String content ;
	private boolean flag = true; // 表示生产或消费的形式
	// flag = true:允许生产， 但是不允许消费
	// flag = false:允许消费，不允许生产
	public synchronized void set(String title, String content) {
		if (!this.flag) {	// 无法进行生产，应该等待被消费
			try {
				super.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		this.title = title ;
		this.content = content ;
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		this.flag = false ;	// 已经生产过了
		super.notify();// 唤醒等待的线程
	}
	public synchronized String get() {
		if (this.flag == true) {	// 还未生产，需要等待
			try {
				super.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			return this.title + " - " + this.content ;
		} finally {	// 不管如何都要执行
			this.flag = true ;	// 继续生产
			super.notify(); // 唤醒等待线程
		}
		
	}
}
public class DeadLock {
	public static void main(String[] args) throws Exception {
		Message msg = new Message();
		new Thread(new Producer(msg)).start();	// 启动生产者线程
		new Thread(new Consumer(msg)).start();	// 启动消费者线程
	}
}
class Producer implements Runnable {
	private Message msg ;
	public Producer(Message msg) {
		this.msg = msg ;
	}
	@Override
	public void run() {
		for (int x = 0; x < 100; x ++) {
			if (x % 2 == 0) {
				this.msg.set("王建","宇宙大帅哥");
				
			} else {
				this.msg.set("小高","猥琐第一人，常态保持");
			}
		}
	}
}
class Consumer implements Runnable {
	private Message msg ;
	public Consumer(Message msg) {
		this.msg = msg ;
	}
	@Override
	public void run() {
		for (int x = 0; x < 100; x ++) {
			System.out.println(this.msg.get()) ;
		}
	}
	
	
}


王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持
王建 - 宇宙大帅哥
小高 - 猥琐第一人，常态保持

这种处理形式就是在进行多线程开发过程之中最原始的处理方案，整个的等待、同步、唤醒机制都由开发者自行通过原生代码实现控制。

班德尔第一小法
关注
专栏目录
生产者消费者模型
bjzxlyh的博客
06-06 158
分析： 1.生产者每生产一个放到公共区域，消费者在满足一定条件时，才在公共区域消费，如果条件不满足，则堵塞，调动pthread_cond_wait()函数。 2.生产者生产完需要唤醒消费者去公共区域消费，此时调用pthread_cond_signal()或pthread_cond_broadcast()，唤醒堵塞在条件变量上的线程。 3.消费者需要： ①创建锁 pthread_mutex_t mutex ②初始化锁 pthread_mutex_init(&mutex,NULL) ③加锁 pthre.
生产者消费者模式例子实现
qq_28286027的博客
08-07 658
class Consumer(threading.Thread): def __init__(self, queue): threading.Thread.__init__(self) self._queue = queue def run(self): while True: msg = self._queue.get() if isinstance(msg, str) and msg =...
34-综合实战：“生产者-消费者模型”
MARVEL_3000的博客
12-22 164
综合实战：“生产者-消费者模型”   在多线程开发中最著名的案例就是生产者-消费者模型，该操作的主要流程如下： 生产者负责信息内容的生产 每当生产者完成一项完整的信息之后消费者要从这里面取走信息 如果生产者没有生产完没有生产完成则消费者要等待它生产完成，如果消费者还没有对信息进行消费，则生产者应等待消费者完成信息消费后在进行生产。 生产者与消费者基本程序模型   可将生产者和消费者定义为两个独立的线程类对象，但是对于现在生产的数据可以使用如下组成： 数据一：title = lyz、content=无敌
第四章：综合实战：“生产者-消费者”模型
a66798159267880的博客
07-22 143
生产者与消费者基本程序 在多线程的开发过程之中最为著名的案例就是生产者与消费者操作，该操作的主要流程如下： 　　生产者负责信息内容的生产 　　每当生产者生产完成一项完整的信息之后消费者要从这里面取走信息； 　　如果生产者没有生成者则消费者要等待它生产完成，如果消费者还没有对信息进行消费，则生产者应该等待消费者处理完成后再继续生成 可以将生产者与消费者定义为两个独立的线程类对象，...
综合实战：“生产者-消费者”模型
L.
09-11 212
一、问题引出 本程序的核心结构如下：首先定义两个类，一个是生产者线程，另外一个消费者线程类，生产者每生产完一个数据之后，消费者要取走这些数据，那么假设现在的数据有两种： title = 小动物，content = 草泥马； title = 小金子，content = 不是好孩子。 范例：代码基本模型 class Message { private String title; pri...
Java多线程开发--综合实战：“生产者-消费者”模型
xzzz2020的博客
01-15 248
1. 生产者与消费者基本模型   在多线程的开发过程之中最为著名的案例就是生产者与消费者操作，该操作的主要流程如下: 生产者负责信息内容的生产: 每当生产者生产完成一项完整的信息之后消费者要从这里面取走信息; 如果生产者没有生产则消费者要等待它生产完成，如果消费者还没有对信息进行消费，则生产者应该等待消费处理完成后再继续生产。   可以将生产者与消费者定义为两个独立的线程类对象，但是对于现在生...
00 03Java高级之综合实战：“生产者-消费者”模型
weixin_43762330的博客
03-10 110
文章目录1 生产者与消费者基本程序模型2 解决生产者-消费者同步问题3 利用Object类解决重复操作 1 生产者与消费者基本程序模型 2 解决生产者-消费者同步问题 3 利用Object类解决重复操作 ...
阿里Java学习路线：阶段 1：Java语言基础－Java语言高级特性：第4章：综合实战：“生产者-消费者”模型：课时17：生产者与消费者基本程序模型
Kenny C
08-19 135
在多线程的开发过程之中最为著名的案例就是生产者与消费者操作，该操作的主要流程如下： 生产者负责信息内容的生产； 每当生产者生产完成一项完整的信息之后消费者要从这里面取走信息； 如果 生产者没有生产完则消费者要等待它生产完成，如果消费者还没有对信息进行消费，同生产者应该等待消费处理完成后再继续生产。 程序的基本实现 可以将生产者与消费者定义为两个独立的线程类对象，但是对于现在生产的数据，可以使用如下的组成： 1.数据一：titile = 王建、content = 宇宙大帅哥； 2.数据二：title = 小高
java多线程四：综合实战“生产者-消费者”模型
YKWNDY的博客
03-03 263
文章出处 https://www.jianshu.com/p/9a9fffe5ad66 文章对应视频出处：https://developer.aliyun.com/course/1012?spm=5176.10731542.0.0.6ef2d290hxQ4g0  在多线程的开发过程之中最为著名的案例就是生产者和消费者操作，该操作的主要流程如下： 生产者负责信息内容的生产； 每当生产者生产完...
Java 综合实战：生产者与消费者（问题引出）
Java软贱攻城狮
05-05 200
假设生产数据如下：·第一组数据：title=蜡笔小新，content=好学生；·第二组数据：title=小白，content=好狗狗；范例：class Info { private String title; private String content; public void setTitle(String title) { this.title = title; } pub...
开放平台架构设计原理与实战：构建持续开放的开放平台开发流程
AI天才研究院
11-05 262
近年来，互联网经济蓬勃发展，人们越来越重视对自己信息的掌控权，希望在不受限制地分享自己的知识、经验和创造力。而早已开始普及的微信、微博、知乎等社交媒体则成为人们获取信息、沟通感情、表达观点的主要渠道。如此开放的网络空间也给平台创作者提供了巨大的想象空间。然而，当平台创作者构建自己的平台时，也面临着更复杂的技术难题——如何构建可持续、可扩展、安全的开放平台？如何让平台上的用户持续地提供新的价值？更重要的是，如何将平台上生成的数据产生价值，并且持续地推动平台运营？
Python数据分析实战：物流业数据分析
AI天才研究院
02-19 793
在当今快速发展的全球经济中，物流业作为连接生产和消费的重要纽带，正面临着前所未有的机遇与挑战。随着电子商务的蓬勃发展和消费者对快速、高效配送的需求不断增长，物流公司需要更智能、更精准的决策支持系统来优化其运营流程、提高服务质量并降低成本。然而，物流业每天产生的海量数据往往未被充分利用，其中蕴含的巨大价值尚待挖掘。这些数据包括但不限于订单信息、配送路线、车辆状态、仓储管理等各个环节的详细记录。如何有效地收集、处理、分析这些数据，并从中提取有价值的洞察，成为了物流业亟待解决的关键问题。
AIGC从入门到实战：AI 2.0 向多领域全场景应用迈进
AI天才研究院
05-28 484
人工智能(Artificial Intelligence, AI) 的概念最早可以追溯到上世纪50年代，图灵在1950年发表的论文《计算机器与智能》中提出了著名的“图灵测试”，被认为是人工智能的开山之作。此后，人工智能经历了几十年的发展，经历了符号主义、连接主义、专家系统等阶段，但始终未能突破理论和应用的瓶颈。20世纪80年代末，机器学习开始兴起，并在90年代取得了突破性进展，例如支持向量机(SVM)和决策树等算法的提出。
AIGC从入门到实战：AIGC 的发展历程
最新发布
AI天才研究院
07-02 815
AIGC从入门到实战：AIGC 的发展历程0 1. 背景介绍 1.1 问题的由来 AIGC（AI-Generated Content，人工智能生成内容）是近年来人工智能领域的一个热门话题。随着深度学习、自然语言处理、计算机视觉等技术
整型类型
铁塔
12-15 2482
整型数据一共有四种，按照保存的范围由小到大：byte、short、int、long，那么在Java里面任何的一个整型常量那么其默认的类型都是int型（只要是整数就是int类型的数据）。 任何的数据类型都是有其可以保存的数据范围的（正常使用下你很少会出现超过此范围的数据），那么如果真的超过了呢？ 范例：观察超过了int型的范围 可以发现，这些数字在进行数据处理的时候，如果超过了其最大的保存范围，那...
链表的定义与使用
铁塔
03-22 1683
链表实现简介 链表的本质是一个动态的对象数组，它可以实现若干个对象的存储。 链表的基本定义： 在实际的开发之中对象数组是一项非常实用的技术，并且利用其可以描述出“多”方的概念，例如：一个人有多本书，则在人的类里面一定要提供有一个对象数组保存书的信息，但是传统的对象数组依赖于数组的概念，所以数组里面最大的缺点在于：长度是固定的，正是因为如此所以在实际的开发之中，传统的数组应用是非常有限的（数组的接收...
布尔型
铁塔
12-16 1542
布尔是一位数学家的名字，不二主要描述的主要是一种逻辑的处理结果，在java中使用boolean来进行布尔类型的定义，那么需要注意的是布尔类型的取值范围只有两个数据：true、false 但是需要说明有一点，像有一些语言由于没有提供有尔类型，所以会使用0表示false，或者使用非0表示true，而这样的逻辑在Java之中是不存在的。 ...
浮点型数据
铁塔
12-15 1328
浮点型数据描述的是小数，而在Java里面任意的一个小数常量其对应的类型为double，所以在以后描述小数的时候直接使用double来进行定义 所有的数据类型进行自动转型的时候都是由小类型到大类型进行自动转换处理。默认的类型为double，但是也可以定义位数相对较少的float变量，此时从赋值的时候就必须采用强制类型转换。 范例：float变量 因此可以编写为 float x = （float）...
综合案例：抽象类与接口应用
铁塔
03-13 1219
案例分析一：获取类信息 抽象类与接口是Java里面最为核心的概念，也是所有设计模式的综合体现，包括在日后学习的过程之中会接触到许多的系统提供的接口和抽象类。接口与抽象类在都可以使用的情况下，一定优先使用接口，因为接口可以避免单继承的局限。 案例分析一： 定义一个ClassName接口，接口中只有一个抽象方法getClassName（）；设计一个类Company，该类实现接口ClassName中的方...
操作系统课程设计实战指南：生产者-消费者与文件系统
同步程序设计包括经典的生产者和消费者问题，以及读者-写者问题的实现，这些都是并发控制和同步机制的基础实践。其余八个任务主要聚焦于文件管理系统，具体包括子目录管理、目录项结构、文件分配表（FAT）的功能、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值