一个关于多线程的问题

Question

/**
 * @(#)文本1.java
 *
 *
 * @author 
 * @version 1.00 2008/10/10
 */
 //创建一个汉堡包盒子类
 //totalmaterial是指所有的能做汉堡包的材料
 //box是一个监视器对象
 //sales是指销售了多少个汉堡包
 //production是指总共有多少个汉堡包class ham
{
static Object box = new Object ();
static int totalmaterial = 10;
static int sales = 0;
static int production = 5;
}//这是一个厨师的线程类
//make方法使用了一个同步块，在这个函数里会不断地生产汉堡包
//run方法就是线程需要运行的内容
//使用循环语句来保证在汉堡包材料用完之前，不断地生产汉堡包
//使用判断语句判断只要有汉堡包，厨师就可以通知营业员可以卖了class hmaker extends Thread
{
public void make ()
{
synchronized (ham.box)
{
(ham.production)++;
try
{
ham.box.notify ();
}
catch (Exception e) {}
}
}

public void run ()
{
while (ham.production < ham.totalmaterial)
{
if (ham.production > 0)
{
System.out.println ("厨师"+";"+"汉堡来了（总共"+(ham.production - ham.sales)+"个）");
}
try
{
sleep (3000);
}
catch (Exception e) {}
make ();
}
}
}//这是一个营业员的线程类
//sell函数是营业员卖汉堡包的方法
//run方法就是线程需要运行的内容
//使用条件判断语句来判断汉堡包盒子里面是否还有汉堡包
//在run方法内使用循环语句来使得营业员在盒子里面有汉堡包的情况下不断地卖class hassistant extends Thread
{
public void sell ()
{
if (ham.production == 0)
{
System.out.println ("营业员:顾客朋友们，请稍等一下，汉堡没了!!");
}
try 
{
ham.box.wait ();
}
catch (Exception e) {}
ham.sales++;
System.out.println ("营业员：顾客好，汉堡上来了。（总共卖了"+ham.sales+"个）");
}
public void run() 
{
while (ham.sales < ham.production)
{
try 
{
sleep (1000);
}
catch (Exception e) {}
sell();
}
}
}public class hmaker1
{
public static void main(String[] args)
{
hmaker  maker = new hmaker();
hassistant assistant = new hassistant();
maker.start ();
assistant.start ();
}
}

Answer 1

线程默认是非守护线程。你得给其中的一声明为守护线程。public static void main(String[] args) 
{ 
hmaker  maker = new hmaker(); 
hassistant assistant = new hassistant(); 
maker.setDaemon(true);
maker.start (); 
assistant.start (); 
} 
试试看？

Answer 2

/**
 * @(#)文本1.java
 *
 *
 * @author 
 * @version 1.00 2008/10/10
 */
 //创建一个汉堡包盒子类
 //totalmaterial是指所有的能做汉堡包的材料
 //box是一个监视器对象
 //sales是指销售了多少个汉堡包
 //production是指总共有多少个汉堡包class ham
{
static Object box = new Object ();
static int totalmaterial = 10;
static int sales = 0;
static int production = 5;
}//这是一个厨师的线程类
//make方法使用了一个同步块，在这个函数里会不断地生产汉堡包
//run方法就是线程需要运行的内容
//使用循环语句来保证在汉堡包材料用完之前，不断地生产汉堡包
//使用判断语句判断只要有汉堡包，厨师就可以通知营业员可以卖了class hmaker extends Thread
{
public void make ()
{
synchronized (ham.box)
{
(ham.production)++;
try
{
ham.box.notify ();
}
catch (Exception e) {}
}
}

public void run ()
{
while (ham.production < ham.totalmaterial)
{
if (ham.production > 0)
{
System.out.println ("厨师"+getName()+":"+"汉堡来了（总共"+(ham.production - ham.sales)+"个）");
}
try
{
sleep (3000);
}
catch (Exception e) {}
make ();
}
}
}//这是一个营业员的线程类
//sell函数是营业员卖汉堡包的方法
//run方法就是线程需要运行的内容
//使用条件判断语句来判断汉堡包盒子里面是否还有汉堡包
//在run方法内使用循环语句来使得营业员在盒子里面有汉堡包的情况下不断地卖class hassistant extends Thread
{
public void sell ()
{
if (ham.production == 0)
{
System.out.println ("营业员:顾客朋友们，请稍等一下，汉堡没了!!");
}
try 
{
ham.box.wait ();
}
catch (Exception e) {}
ham.sales++;
System.out.println ("营业员：顾客好，汉堡上来了。（总共卖了"+ham.sales+"个）");
}
public void run() 
{
while (ham.sales < ham.production)
{
try 
{
sleep (1000);
}
catch (Exception e) {}
sell();
}
}
}public class hmaker1
{
public static void main(String[] args)
{
/*
hmaker  maker = new hmaker();
hassistant assistant = new hassistant();
maker.start ();
assistant.start ();
*/
hmaker  maker = new hmaker(); 
hassistant assistant = new hassistant(); 
maker.setName ("甲");
maker.setDaemon(true); 
maker.start (); 
assistant.start (); 

}
}运行结果:
D:\程序\JAVA\有问题的>java hmaker1
厨师甲:汉堡来了（总共5个）
营业员：顾客好，汉堡上来了。（总共卖了1个）
营业员：顾客好，汉堡上来了。（总共卖了2个）
营业员：顾客好，汉堡上来了。（总共卖了3个）
厨师甲:汉堡来了（总共3个）
营业员：顾客好，汉堡上来了。（总共卖了4个）
营业员：顾客好，汉堡上来了。（总共卖了5个）
营业员：顾客好，汉堡上来了。（总共卖了6个）
厨师甲:汉堡来了（总共1个）
一下子又少了，真是搞不懂

Answer 3

两个线程start后 主线程直接退出了.
应该说你得到的结果 和前两个线程的启动速度有关.
在主程序中join下线程

Answer 4

/**
 * @(#)文本1.java
 * 
 * 
 * @author
 * @version 1.00 2008/10/10
 */
// 创建一个汉堡包盒子类
// totalmaterial是指所有的能做汉堡包的材料
// box是一个监视器对象
// sales是指销售了多少个汉堡包
// production是指总共有多少个汉堡包
class ham {
static Object box = new Object();
static int totalmaterial = 10;
static int sales = 0;
static int production = 5;
}// 这是一个厨师的线程类
// make方法使用了一个同步块，在这个函数里会不断地生产汉堡包
// run方法就是线程需要运行的内容
// 使用循环语句来保证在汉堡包材料用完之前，不断地生产汉堡包
// 使用判断语句判断只要有汉堡包，厨师就可以通知营业员可以卖了class hmaker extends Thread {
public void make() {
synchronized (ham.box) {
while(ham.production==ham.totalmaterial){
try {
ham.box.wait();

} catch (InterruptedException e) {
e.printStackTrace();
}
}
ham.box.notify();
ham.production++;
}
} public void run() {
while (ham.production <ham.totalmaterial) {
if (ham.production > 0) {
System.out.println("厨师" + ";" + "汉堡来了（总共"
+ (ham.production - ham.sales) + "个）");
}
make();
try {
sleep(1000);
} catch (Exception e) {
}

}
}
}// 这是一个营业员的线程类
// sell函数是营业员卖汉堡包的方法
// run方法就是线程需要运行的内容
// 使用条件判断语句来判断汉堡包盒子里面是否还有汉堡包
// 在run方法内使用循环语句来使得营业员在盒子里面有汉堡包的情况下不断地卖class hassistant extends Thread {
public synchronized void sell() {
while (ham.production==ham.sales) {
try {
ham.box.wait();
System.out.println("营业员:顾客朋友们，请稍等一下，汉堡没了!!");
} catch (Exception e) {
}
}
// ham.box.notify();//如果这句不屏蔽掉的话会抛出异常，自己也搞不明白？
ham.sales++;
System.out.println("营业员：顾客好，汉堡上来了。（总共卖了" + ham.sales + "个）");
} public void run() {
while (ham.sales <= ham.production) {
sell();
try {
sleep(500);
} catch (Exception e) { }

}
}
}public class hmaker1 {
public static void main(String[] args) {
hmaker maker = new hmaker();
hassistant assistant = new hassistant();
maker.start();
assistant.start();
}
}
厨师;汉堡来了（总共5个）
营业员：顾客好，汉堡上来了。（总共卖了1个）
营业员：顾客好，汉堡上来了。（总共卖了2个）
营业员：顾客好，汉堡上来了。（总共卖了3个）
厨师;汉堡来了（总共3个）
营业员：顾客好，汉堡上来了。（总共卖了4个）
营业员：顾客好，汉堡上来了。（总共卖了5个）
厨师;汉堡来了（总共2个）
营业员：顾客好，汉堡上来了。（总共卖了6个）
营业员：顾客好，汉堡上来了。（总共卖了7个）
厨师;汉堡来了（总共1个）
营业员：顾客好，汉堡上来了。（总共卖了8个）
营业员：顾客好，汉堡上来了。（总共卖了9个）
厨师;汉堡来了（总共0个）
营业员：顾客好，汉堡上来了。（总共卖了10个）