【ThinkingInJava】63、哲学家进餐问题

最新推荐文章于 2019-03-26 21:05:50 发布
原创 最新推荐文章于 2019-03-26 21:05:50 发布 · 944 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Java编程思想 #哲学家进餐 #线程 #死锁

本文讨论了哲学家进餐问题，并通过《ThinkingInJava》书籍中的实例，介绍了如何利用Java语言解决该问题。文章详细解释了Chopstick类实现的线程同步和Philosopher类中线程的运行机制，包括思考、获取筷子和进食的过程。同时，提出了避免死锁的方法，通过重新安排线程执行顺序来改进原有代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >


/**
* 书本:《Thinking In Java》
* 功能:哲学家进餐问题
* 		作为哲学家，他们很穷，所以他们只能买五根筷子。他们围坐在桌子周围，每人之间放一根筷子。当一个哲学家要就餐的时候了，这个哲学家必须同时得到左边
* 		和右边的筷子。如果一个哲学家左边或右边的筷子已经有人在使用筷子了，那么这个哲学家就必须等待，直至可以得到必须的筷子
* 文件:Chopstick.java
* 时间:2015年5月9日15:08:21
* 作者:cutter_point
*/
package Lesson21Concurency;

public class Chopstick
{
	private boolean taken = false;		//筷子是否已经被拿起来了
	public synchronized void take() throws InterruptedException
	{
		while(taken)
			this.wait();  //如果筷子被拿起来了，那么就得等待，等待其他进程对他进行唤醒
		taken = true; 	//如果没有拿起来，那么调用这个函数筷子被取起来了
	}
	
	public synchronized void drop()	//这个函数是放下筷子
	{
		taken = false;
		this.notifyAll(); //唤醒别人，这个筷子又可以使用了
	}
}


/**
* 书本:《Thinking In Java》
* 功能:哲学家进餐问题
* 		作为哲学家，他们很穷，所以他们只能买五根筷子。他们围坐在桌子周围，每人之间放一根筷子。当一个哲学家要就餐的时候了，这个哲学家必须同时得到左边
* 		和右边的筷子。如果一个哲学家左边或右边的筷子已经有人在使用筷子了，那么这个哲学家就必须等待，直至可以得到必须的筷子
* 文件:Philosopher.java
* 时间:2015年5月9日15:17:36
* 作者:cutter_point
*/
package Lesson21Concurency;

import java.util.Random;
import java.util.concurrent.TimeUnit;

import static net.mindview.util.Print.*;

public class Philosopher implements Runnable	//一个哲学家线程
{
	//哲学家左右两边有两双筷子，这名哲学家得id号，给一个数据，用来判断哲学家是思考还是进餐
	private Chopstick left;		//左筷子
	private Chopstick right;	//右筷子
	private final int id;		//这名哲学家得id号
	private final int ponderFactor; 		//一个数据用来判定是否会思考还是进餐
	private Random rand = new Random(998);

	public Philosopher(Chopstick left, Chopstick right, int ident, int ponder)
	{
		this.left = left;
		this.right = right;
		this.id = ident;		//哲学家的id号码
		this.ponderFactor = ponder; 		//哲学家思考数据
	}
	
	private void pause() throws InterruptedException
	{
		if(this.ponderFactor == 0)
		{
			//如果哲学家得思考数据是0的话，那么就不用暂停思考了，直接返回
			return;
		}
		//如果哲学家要思考的话，那么我们就要让他暂停一段时间
		TimeUnit.MILLISECONDS.sleep(rand.nextInt(this.ponderFactor * 1500)); 	//思考时间
	}
	
	public String toString()
	{
		return "哲学家：" + this.id + " 号 ";
	}
	
	@Override
	public void run()
	{
		//哲学家的行动模式
		//收先，如果哲学家还在餐桌上，也就是没有被中断
		try
		{
			while(!Thread.interrupted())
			{
				//1、首先哲学家会思考
				print(this + " " + " 在思考");
				this.pause(); 	//思考一段时间
				//2、思考一段时间后觉得饿了，那么哲学家就要进餐了，那么就会拿起来左边和右边的筷子，然后开始进餐，进餐额时间又会有一段
				this.right.take(); 	//拿起筷子
				print(this + " " + "拿起右边的筷子");
				this.left.take();
				print(this + " " + "拿起左边的筷子");
				print(this + " " + "开始吃饭");
				this.pause(); //吃饭花的时间
				//3、吃完之后就会放下左右的筷子
				print(this + " " + "吃完了，放下筷子");
				this.left.drop();
				this.right.drop();
			}
		} 
		catch (InterruptedException e)
		{
			e.printStackTrace();
			print(this + " " + " 被中断了退出了餐桌。");
		}
	}

}


/**
* 书本:《Thinking In Java》
* 功能:哲学家进餐问题
* 		作为哲学家，他们很穷，所以他们只能买五根筷子。他们围坐在桌子周围，每人之间放一根筷子。当一个哲学家要就餐的时候了，这个哲学家必须同时得到左边
* 		和右边的筷子。如果一个哲学家左边或右边的筷子已经有人在使用筷子了，那么这个哲学家就必须等待，直至可以得到必须的筷子
* 文件:DeadlockingDiningPhilosophers.java
* 时间:2015年5月9日15:36:13
* 作者:cutter_point
*/
package Lesson21Concurency;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class DeadlockingDiningPhilosophers
{

	public static void main(String[] args) throws Exception
	{
		int ponder = 5;
		int size = 5;		//哲学家得
		ExecutorService exec = Executors.newCachedThreadPool(); 		//线程连接池
		Chopstick[] sticks = new Chopstick[size];	//创建数组空间
		for(int i = 0; i < size; ++i)
			sticks[i] = new Chopstick();	//初始化数组里面的对象
		for(int i = 0; i < size; ++i)
		{
			exec.execute(new Philosopher(sticks[i], sticks[(i+1) % size], i, ponder));
		}
		
		if(args.length == 3 && args[2].equals("timeout"))
			TimeUnit.SECONDS.sleep(5);
		else
		{
			System.out.println("回车键退出");
			System.in.read();
		}
		exec.shutdownNow();		//停止全部线程
	}

}

输出：
回车键退出
哲学家：4 号   在思考  obj1
哲学家：1 号   在思考  obj1
哲学家：3 号   在思考  obj1
哲学家：2 号   在思考  obj1
哲学家：0 号   在思考  obj1
哲学家：3 号  拿起右边的筷子  obj1
哲学家：2 号  拿起右边的筷子  obj1
哲学家：1 号  拿起右边的筷子  obj1
哲学家：0 号  拿起右边的筷子  obj1
哲学家：4 号  拿起右边的筷子  obj1

java.lang.InterruptedException
哲学家：3 号   被中断了退出了餐桌。  obj1
哲学家：0 号   被中断了退出了餐桌。  obj1
哲学家：1 号   被中断了退出了餐桌。  obj1
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:503)
    at Lesson21Concurency.Chopstick.take(Chopstick.java:18)
    at Lesson21Concurency.Philosopher.run(Philosopher.java:65)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:744)
java.lang.InterruptedException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:503)
    at Lesson21Concurency.Chopstick.take(Chopstick.java:18)
    at Lesson21Concurency.Philosopher.run(Philosopher.java:65)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:744)
java.lang.InterruptedException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:503)
    at Lesson21Concurency.Chopstick.take(Chopstick.java:18)
    at Lesson21Concurency.Philosopher.run(Philosopher.java:65)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:744)
java.lang.InterruptedException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:503)
    at Lesson21Concurency.Chopstick.take(Chopstick.java:18)
    at Lesson21Concurency.Philosopher.run(Philosopher.java:65)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:744)
哲学家：2 号   被中断了退出了餐桌。  obj1
java.lang.InterruptedException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:503)
    at Lesson21Concurency.Chopstick.take(Chopstick.java:18)
    at Lesson21Concurency.Philosopher.run(Philosopher.java:65)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:744)
哲学家：4 号   被中断了退出了餐桌。  obj1




这个会导致死锁，也就是共享的有限资源不够，被多个线程争抢的时候的情况


改进：

/**
* 书本:《Thinking In Java》
* 功能:哲学家进餐问题
* 		作为哲学家，他们很穷，所以他们只能买五根筷子。他们围坐在桌子周围，每人之间放一根筷子。当一个哲学家要就餐的时候了，这个哲学家必须同时得到左边
* 		和右边的筷子。如果一个哲学家左边或右边的筷子已经有人在使用筷子了，那么这个哲学家就必须等待，直至可以得到必须的筷子
* 文件:FixedDiningPhilosophers.java
* 时间:2015年5月9日15:36:13
* 作者:cutter_point
*/
package Lesson21Concurency;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class FixedDiningPhilosophers
{

	public static void main(String[] args) throws Exception
	{
		int ponder = 5;
		int size = 5;		//哲学家得
		ExecutorService exec = Executors.newCachedThreadPool(); 		//线程连接池
		Chopstick[] sticks = new Chopstick[size];		//创建数组空间
		for(int i = 0; i < size; ++i)
			sticks[i] = new Chopstick();	//初始化数组里面的对象
		for(int i = 0; i < size; ++i)
		{
//			exec.execute(new Philosopher(sticks[i], sticks[(i+1) % size], i, ponder));
			if(i < (size - 1))
				exec.execute(new Philosopher(sticks[0], sticks[i+1], i, ponder));
			else
				exec.execute(new Philosopher(sticks[0], sticks[i], i, ponder));
		}
		
		if(args.length == 3 && args[2].equals("timeout"))
			TimeUnit.SECONDS.sleep(5);
		else
		{
			System.out.println("回车键退出");
			System.in.read();
		}
		exec.shutdownNow();		//停止全部线程
	}

}

输出：

回车键退出
哲学家：2 号   在思考  obj1
哲学家：0 号   在思考  obj1
哲学家：4 号   在思考  obj1
哲学家：1 号   在思考  obj1
哲学家：3 号   在思考  obj1
哲学家：2 号  拿起右边的筷子  obj1
哲学家：2 号  拿起左边的筷子  obj1
哲学家：2 号  开始吃饭  obj1
哲学家：4 号  拿起右边的筷子  obj1
哲学家：1 号  拿起右边的筷子  obj1
哲学家：0 号  拿起右边的筷子  obj1
哲学家：2 号  吃完了，放下筷子  obj1
哲学家：2 号   在思考  obj1
哲学家：0 号  拿起左边的筷子  obj1
哲学家：0 号  开始吃饭  obj1
哲学家：0 号  吃完了，放下筷子  obj1
哲学家：0 号   在思考  obj1
哲学家：4 号  拿起左边的筷子  obj1
哲学家：4 号  开始吃饭  obj1
哲学家：4 号  吃完了，放下筷子  obj1
哲学家：4 号   在思考  obj1
哲学家：1 号  拿起左边的筷子  obj1
哲学家：3 号  拿起右边的筷子  obj1
哲学家：1 号  开始吃饭  obj1
哲学家：1 号  吃完了，放下筷子  obj1
哲学家：1 号   在思考  obj1
哲学家：3 号  拿起左边的筷子  obj1
哲学家：3 号  开始吃饭  obj1
哲学家：3 号  吃完了，放下筷子  obj1
哲学家：3 号   在思考  obj1
哲学家：2 号  拿起右边的筷子  obj1
哲学家：2 号  拿起左边的筷子  obj1
哲学家：2 号  开始吃饭  obj1
哲学家：0 号  拿起右边的筷子  obj1
哲学家：4 号  拿起右边的筷子  obj1
哲学家：1 号  拿起右边的筷子  obj1
哲学家：2 号  吃完了，放下筷子  obj1
哲学家：2 号   在思考  obj1
哲学家：1 号  拿起左边的筷子  obj1
哲学家：1 号  开始吃饭  obj1
哲学家：2 号  拿起右边的筷子  obj1
哲学家：1 号  吃完了，放下筷子  obj1
哲学家：1 号   在思考  obj1
哲学家：2 号  拿起左边的筷子  obj1
哲学家：2 号  开始吃饭  obj1
哲学家：1 号  拿起右边的筷子  obj1
哲学家：2 号  吃完了，放下筷子  obj1
哲学家：2 号   在思考  obj1
哲学家：1 号  拿起左边的筷子  obj1
哲学家：1 号  开始吃饭  obj1
哲学家：2 号  拿起右边的筷子  obj1
哲学家：1 号  吃完了，放下筷子  obj1
哲学家：1 号   在思考  obj1
哲学家：2 号  拿起左边的筷子  obj1
哲学家：2 号  开始吃饭  obj1
哲学家：1 号  拿起右边的筷子  obj1

java.lang.InterruptedException
哲学家：3 号   被中断了退出了餐桌。  obj1
哲学家：0 号   被中断了退出了餐桌。  obj1
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:503)
    at Lesson21Concurency.Chopstick.take(Chopstick.java:18)
    at Lesson21Concurency.Philosopher.run(Philosopher.java:63)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:744)
java.lang.InterruptedException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:503)
    at Lesson21Concurency.Chopstick.take(Chopstick.java:18)
    at Lesson21Concurency.Philosopher.run(Philosopher.java:65)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:744)
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at java.lang.Thread.sleep(Thread.java:340)
    at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:360)
    at Lesson21Concurency.Philosopher.pause(Philosopher.java:42)
    at Lesson21Concurency.Philosopher.run(Philosopher.java:68)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:744)
哲学家：2 号   被中断了退出了餐桌。  obj1
java.lang.InterruptedException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:503)
    at Lesson21Concurency.Chopstick.take(Chopstick.java:18)
    at Lesson21Concurency.Philosopher.run(Philosopher.java:65)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:744)
java.lang.InterruptedException哲学家：4 号   被中断了退出了餐桌。  obj1

    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:503)
    at Lesson21Concurency.Chopstick.take(Chopstick.java:18)
    at Lesson21Concurency.Philosopher.run(Philosopher.java:65)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:744)
哲学家：1 号   被中断了退出了餐桌。  obj1

这个不会死锁，只要当你回车的时候才会结束各个线程之间的配合






































java 多线程 死锁 哲学家就餐问题
成功需要努力
12-28 4001
现在你理解了，一个对象可以有synchronized方法或其他形式的加锁机制来防止别的任务在互斥还没有释放的时候就访问这个对象。你已经学习过，任务可以变成阻塞状态，所以就可能出现两种情况：某个惹我怒在等待另一个任务，而后者又等待别的任务，这样一直下去，直到这个链条上的任务又在等待第一个任务释放锁。这得到了一个任务之间相互等待的连续循环，没有哪个线程恩给你继续。这被称之为  死锁 。     如果
Thinking in Java---从哲学家就餐问题看死锁现象
荒野孤鹰
02-03 6286
我们知道一个对象可以有synchronized方法或其他形式的加锁机制来防止别的线程在互斥还没释放的时候就访问这个对象。而且我们知道线程是会变成阻塞状态的(挂起)，所以有时候就会发生死锁的情况：某个任务在等待另一个任务，而后者又在等待其它任务，这样一直下去，知道这个链条下的任务又在等待第一个任务释放锁，这样就形成了一个任务之间相互等待的连续循环，没有任务可以继续的情况。死锁的最大问题在于它发生的几率
[ThinkingInJava]多态
wdw87的博客
03-26 141
8. 多态 8.1 绑定 将一个方法调用同一个方法主体关联起来被称为绑定 前期绑定：在程序执行前进行绑定 后期绑定（动态绑定）：在运行时根据对象的类型进行绑定 Java中除了static方法和final方法**（private方法属于final）**之外，其他方法都是动态绑定 8.1.1 缺陷：“覆盖私有方法” 只有非private方法才能够被覆盖 基类中的private方法对于导出类既...
[ThinkingInJava]复用类
wdw87的博客
03-26 176
7.复用类 7.1 组合 在类中new另外一个对象，以添加该对象的属性 public class Computer { public Computer() { CPU cpu=new CPU(); RAM ram=new RAM(); Disk disk=new Disk(); } } class CPU{ } class ...
【ThinkingInJava】笔记
零昔无浪
01-20 2274
参考文献(References) [1] Bruce Eckel.Java编程思想(ThinkingJava FourEdition)第四版[M].陈昊鹏,北京：机械出版社,2007.6(2014.11重印)
ThinkingInJava——并发之Thread,Executor,Callable
xiaowang627的博客
03-25 546
一 Thread类 将Runnable对象转换为工作任务的传统方式是把它提交给一个Thread构造器，调用Thread对象的start()方法为该线程执行必需的初始化操作，然后调用Runnable的run()方法，以便在这个新线程中启动任务。start()方法调用后会立即返回当前线程，而由其它线程去执行run()方法。 练习1：实现一个Runnable。在run()内部打印一个消息，然
ThinkingInJava_5
weixin_33739627的博客
10-27 166
为什么80%的码农都做不了架构师？>>> ...
第五章ThinkingInJava
weixin_34179762的博客
08-17 108
为什么80%的码农都做不了架构师？>>> ...
ThinkingInJava 学习 之 0000006 复用类
10-15 104
　　1. 组合语法 　　　　将对象引用置于新类中。 　　2. 继承语法 　　　　衍生类自动获得基类中所有的域和方法 　　　　super关键字表示基类。 　　　　1. 初始化基类 　　　　　　当创建一个衍生类的对象时，该对象创建一个基类的子对象并包含子对象。 　　　　　　衍生类实例化时，首先实例化基类，然后在实例化衍生类。 　　　　　　Java 会自动在衍生类的构造器中插入...
thinkinginjava
03-08
14. **设计模式**：在"thinkinginjava-master"中，可能会包含对23种经典设计模式的实践示例，如工厂模式、单例模式、观察者模式等，这些都是解决常见问题的模板。 以上只是《Thinking in Java》中部分关键知识点的...
ThinkinginJava
04-18
ThinkinginJava cn.chm
ThinkingInJava
05-23
ThinkingInJava
【ThinkingInJava】8、对象的初始化为null，基本类型默认初始化为0
cutter_point的专栏
04-14 1626
/** * 书本:《Thinking In Java》 * 功能:对象的初始化为null，基本类型默认初始化为0 * 1、在定义对象的地方。 * 2、在类的构造器中 * 3、在使用这些对象之前，这个叫惰性初始化 * 4、使用实例初始化 * 文件:Bath.java * 时间:2014年10月12日15:21:17 * 作者:cutter_point */ package Lesso
【ThinkingInJava】32、递归计数
cutter_point的专栏
05-17 1410
/** * 书本:《Thinking In Java》 * 功能:为了对pet进行计数，我们做一个能跟踪各种不同类型的Pet的数量的工具，用map。这里使用动态instanceof（） * 我们可以使用Class.isAssignableFrom(),创建一个不局限于Pet的计数通用工具 * 文件:PetCount3.java * 时间:2015年4月14日09:56:41 * 作者:cutt
【ThinkingInJava】10、完全解耦，策略设计模式
cutter_point的专栏
04-17 1334
/** * 书本:《Thinking In Java》 * 功能:完全解耦，策略设计模式 * 这里apply.process()方法可以接受任何类型的processor，并将其应用到一个Object对象上，然后打印结果 * 文件:Apply.java * 时间:2015年4月2日16:50:55 * 作者:cutter_point */ package Lesson9Interfaces.c
【ThinkingInJava】64、银行出纳员仿真
cutter_point的专栏
05-23 1312
/** * 书本:《Thinking In Java》 * 功能:对象随机地出现，并且要求由数量有限的服务器提供随机数量的服务时间。 * 每个银行顾客要求一定数量的服务时间，这是出纳员必须花费在顾客身上，以服务顾客需求的时间单位的数量。服务时间的数量对每个顾客来说都是不同的，并且是随机确定的。 * 另外，你不知道在每个时间间隔内有多少顾客会到达，因此这也是随机确定的： * 文件:BankT
【ThinkingInJava】23、反向迭代器
cutter_point的专栏
05-03 1219
/** * 书本:《Thinking In Java》 * 功能:我们希望在默认的向前迭代器的基础上，添加产生反向迭代器的能力。 * 文件:AdapterMethodIdiom.java * 时间:2015年4月8日19:59:01 * 作者:cutter_point */ package Lesson11holdingyourobjects; import java.util.*; cla
【ThinkingInJava】41、捕获转换
cutter_point的专栏
05-19 1036
/** * 书本:《Thinking In Java》 * 功能:捕获转换 * 文件:CaptureConversion.java * 时间:2015年5月19日07:52:43 * 作者:cutter_point */ package Lesson15_generices; public class CaptureConversion { static void f1(Holder hol
【ThinkingInJava】44、数据生成器
cutter_point的专栏
05-19 1017
//: net/mindview/util/Generator.java // A generic interface. package net.mindview.util; public interface Generator { T next(); } ///:~ /** * 书本:《Thinking In Java》 * 功能:数据生成器--策略设计模式 * 文件:CountingG
《ThinkingInJava》中文版：面向对象编程经典指南
《ThinkingInJava》中文版是由知名编程作者Bruce Eckel撰写的一本经典著作，第四版专为理解和学习Java语言设计。本书不仅适合初学者，也对有一定经验的开发者具有启发性。Bruce Eckel以其流畅的笔触和简洁的代码示例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值