求大师傅帮看一个程序的编写

Question

线程javathread

Answer 1

你这4个线程没有共享一个Food的实例，而是各自都带了一个。
你的问题就在这，你先试着改改

Answer 2

public class TestFood implements Runnable{

private static final Food food = new Food();

@Override
public void run() {
food.sumNumber();
  }

public static void main(String[] args) {
Runnable testFood1 = new TestFood();
Runnable testFood2 = new TestFood();
Runnable testFood3 = new TestFood();
Runnable testFood4 = new TestFood();
new Thread(testFood1,"线程1").start();
new Thread(testFood2,"线程2").start();
new Thread(testFood3,"线程3").start();
new Thread(testFood4,"线程4").start();
}
}
运行结果是：
Thread[线程1,5,main]
食物的数量：2
Thread[线程4,5,main]
食物的数量：3
Thread[线程3,5,main]
食物的数量：4
Thread[线程2,5,main]
食物的数量：5这样改对了么

Answer 3

多个线程要同时操作同一个对象，那这个时候你在线程的run方法中去创建这个对象会导致每个线程每运行一次都会各自去创建一个对象，那么为了共用这个对象，你需要在线程开始前就创建好这个对象，然后在创建线程的时候把这个对象传递给线程。这样就对了，代码如下：
Food food = new Food();
Runnable testFood1 = new TestFood( food);
        Runnable testFood2 = new TestFood( food);
        Runnable testFood3 = new TestFood( food);
        Runnable testFood4 = new TestFood( food);
        new Thread(testFood1,"线程1").start();
        new Thread(testFood2,"线程2").start();
        new Thread(testFood3,"线程3").start();
        new Thread(testFood4,"线程4").start();根据我的思路，你还需要为TestFood类建立一个带参数的构造方法，这样在TestFood内部就含有Food类的引用，那用这个引用去操作Food类的时候才没有问题。

Answer 4

首先你对final理解有误区，以为用了final就new的是同一个实例，可以用单例模式解决 你 new 的Food不是同一个实例的问题，但是有点大材小用。
所以直接这样：
private Food food;

public TestFood(Food food){
this.food = food;
}

public void run() {  
this.food.sumNumber();
     }
     
    public static void main(String[] args) {
     Food food = new Food();
        Runnable testFood1 = new TestFood(food);
        Runnable testFood2 = new TestFood(food);
        Runnable testFood3 = new TestFood(food);
        Runnable testFood4 = new TestFood(food);
        new Thread(testFood1,"线程1").start();
        new Thread(testFood2,"线程2").start();
        new Thread(testFood3,"线程3").start();
        new Thread(testFood4,"线程4").start();

Answer 5

public class TestFood implements Runnable{

private static final Food food = new Food();

@Override
public void run() {
food.sumNumber();
  }

public static void main(String[] args) {
Runnable testFood1 = new TestFood();
Runnable testFood2 = new TestFood();
Runnable testFood3 = new TestFood();
Runnable testFood4 = new TestFood();
new Thread(testFood1,"线程1").start();
new Thread(testFood2,"线程2").start();
new Thread(testFood3,"线程3").start();
new Thread(testFood4,"线程4").start();
}
}
运行结果是：
Thread[线程1,5,main]
食物的数量：2
Thread[线程4,5,main]
食物的数量：3
Thread[线程3,5,main]
食物的数量：4
Thread[线程2,5,main]
食物的数量：5这样改对了么你这样是可以，因为你
private static final Food food = new Food();
这个food变量是static变量
其实你可以只生成一个Runnable实例
这个Runnable实例里维护一个food实例
最后4个线程都使用这个Runnable的实例

Answer 6

final要不要无所谓.........已经OK了...

Answer 7

其实重点就在于这个STATIC .整个进程共享一个参数!!!!唯一,在方法区存在.

Answer 8

你好，我理解你的意思，确实更简便也更直观。 但我刚试着改了下程序：public class Food {

private int number = 1; public Food() {
System.out.println("ahahahaha");
}

public synchronized void sumNumber() {
Thread thread = Thread.currentThread();
number++; 
System.out.println(thread + "食物的数量：" + number);
}
}public class TestFood implements Runnable{

private static final Food food = new Food();
//private Food food;

/*public TestFood(Food food) {
this.food = food;
}*/

@Override
public void run() {
food.sumNumber();
  }

public static void main(String[] args) {
Runnable testFood1 = new TestFood();
Runnable testFood2 = new TestFood();
Runnable testFood3 = new TestFood();
Runnable testFood4 = new TestFood();
new Thread(testFood1,"线程1").start();
new Thread(testFood2,"线程2").start();
new Thread(testFood3,"线程3").start();
new Thread(testFood4,"线程4").start();
}
}用final的方式，我new了4个，但最后的构造器里的打印语句，只显示了1次。
结果：
ahahahaha
Thread[线程1,5,main]食物的数量：2
Thread[线程3,5,main]食物的数量：3
Thread[线程2,5,main]食物的数量：4
Thread[线程4,5,main]食物的数量：5我不理解为什么你说的final new的不是同一个实例。  能讲下原因么，十分感谢！

Answer 9

嗯，了解了，我把final和static的意思给曲解了，感谢！

Answer 10

参数加了final的意思是这个值不可以再改变.永远是这样,然而不同线程每个人都有一个 final Food food = new Food();!他们虽然名字一样.但是没有任务关系................线程与线程互不影响,除STATIC修饰除外.........其它值互不干扰

Answer 11

打错字!重发一次!
参数加了final的意思是这个值不可以再改变.永远是这样,然而不同线程每个人都有一个 final Food food = new Food();!他们虽然名字一样.但是没有任何关系.......线程与线程之间是互相独立的.........线程与线程互不影响,除STATIC修饰除外.........其它值互不干扰 

Answer 12

我还想问下，如果我之前的Food类不使用同步方法，还能否，我的第一个问题的要求，多线程互不影响的累加呢？

Answer 13

你意思是不是说不使用STATIC,还有别的方法实现你原题需求么?

Answer 14

不是static，我是说，如果Food类里的addNumber方法如果不用synchronized修饰，还能不能有别的方式，实现多线程互不影响累加结果。

Answer 15

有....不只一种,但是在这里很难一点一点说清楚了..挺多的,,,,给个传送门给你吧!你自己去看看
http://www.iteye.com/topic/806990

Answer 16

各自有各自的number，互不影响.设置成static的
private static int number;

Answer 17

需要共享同一个Food
方法一：public class Food {
    
    static private int number = 1;
     
    public static synchronized void sumNumber() {
        Thread thread = Thread.currentThread();
        System.out.println(thread);
        number++; 
        System.out.println("食物的数量：" + number);
    }
}
方法二：public class TestFood implements Runnable{

Food food = new Food();
    public void run() {
        food.sumNumber();
     }
     
    public static void main(String[] args) {
        Runnable testFood1 = new TestFood();
        new Thread(testFood1,"线程1").start();
        new Thread(testFood1,"线程2").start();
        new Thread(testFood1,"线程3").start();
        new Thread(testFood1,"线程4").start();
        new Thread(testFood1,"线程5").start();
    }
}
像楼主private static final Food food = new Food();这个加上static没啥意义

Answer 18

还有一点不太明白
Thread testFood1= new Thread(new TestFood());
new Thread(testFood1,"线程1").start();和Runnable testFood1 = new TestFood();
new Thread(testFood1,"线程1").start();有啥区别 好像执行起来是一样的

Answer 19

一种是继承Thread.既是设计师也是工人.
一种是实现了Runnable.再交于Thread去启动.就像Runnable是设计师只负责设计.Thread是工人,去做事.
第一段代码
Thread testFood1= new Thread(new TestFood());
new Thread(testFood1,"线程1").start();
这段代码多NEW了一个Thread类,重复啰嗦了,可以改成
Thread testFood1= new Thread(new TestFood(),"线程1");
testFood1.start();