终于完成了一个小小的java多线程

对多线程方面一直只限概念，感觉用到的不多，所以没深入去了解。但发现面试时却经常会问到，于是便想了一个简单的题目，亲自实践下。题目如下：
由2个线程控制主线程的一个变量，一个调用加的方法，一个调用减的方法，要求变量值不能小于0（如果等于0，则减的方法必须等待）。一个典型的有货才卖的类型 ，由于新手，所以捣鼓了好久，终于成功了，下面是代码，不知道有什么能改进的。
*以下是经过修改的代码：

public class ThreadTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		ThreadTest t = new ThreadTest();
		Thread t3 = new Thread(new MinusThread(t));
		Thread t2 = new Thread(new MinusThread(t));
		Thread t1 = new Thread(new AddThread(t));
		t1.start();
		t2.start();
		t3.start();
	}
	
	
	static int num = 0;
	public synchronized void add() {
		while(num >= 10)
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		num++;
		System.out.println("num+1="+num);
	}
	
	public synchronized void minus() {
		while(num <= 0)
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		num--;
		System.out.println("num-1="+num);
	}
	
	public synchronized void change(int type) {
		if(type==0) {
			num++;
			System.out.println("num+1="+num);
		} else {
			while(num <= 0)
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			num--;
			System.out.println("num-1="+num);
		}
	}
}

class AddThread implements Runnable {
	ThreadTest t;
	public AddThread (ThreadTest t) {
		this.t = t;
	}
	public void run() {
		int i = 100;
		while(i-->0) {
			synchronized (t) {
				t.add();
				t.notify();
			}
		}
	}
}

class MinusThread implements Runnable {
	ThreadTest t;
	public MinusThread (ThreadTest t) {
		this.t = t;
	}
	public void run() {
		int i = 100;
		while(i-->0) {
			synchronized (t) {
				t.minus();
				t.notify();
			}
		}
	}
}

评论

22 楼 mengqingyu 2013-06-21  

可以看看这个 http://mengqingyu.iteye.com/blog/1840675

21 楼 wuchsh2013 2013-06-20  

太复杂，看不懂

20 楼 406657836 2013-06-20  

chen3975 写道

gegewuqin9 写道

chen3975 写道

你写的和我的差不多，就是sysout这个换了地方，但你把这个写在外面是不对的，因为getSum()时sum的值可能已经被另一个线程改变了，我测试了一下很乱..

我觉的和你的不一样,虽然都是有两个线程和一个主线程.但是我的同步代码是放在主线程类中的,而你的和我的不一样,显的很乱.

显然，更喜欢你的这个风格，看起来很清晰，面向对象的思想也有了。不错！

19 楼 chen3975 2013-06-20  

gegewuqin9 写道

chen3975 写道

你写的和我的差不多，就是sysout这个换了地方，但你把这个写在外面是不对的，因为getSum()时sum的值可能已经被另一个线程改变了，我测试了一下很乱..

我觉的和你的不一样,虽然都是有两个线程和一个主线程.但是我的同步代码是放在主线程类中的,而你的和我的不一样,显的很乱.

18 楼 chen3975 2013-06-20  

gegewuqin9 写道

chen3975 写道

你写的和我的差不多，就是sysout这个换了地方，但你把这个写在外面是不对的，因为getSum()时sum的值可能已经被另一个线程改变了，我测试了一下很乱..

放哪里都一样,都可能被别的线程修改访问,因为minus和add不是互斥操作.如果他们是互斥操作的话放在各自的方法里就保证获得sum值是当时的

17 楼 406657836 2013-06-20  

gegewuqin9 写道

406657836 写道

大神，可是我测试的时候是可以实现的，是不是取巧了··· 
我现在把notify()放到加的线程里激活了，你能帮忙看看怎么样么？

嗯 你这个程序暂时可能没有什么线程安全的问题了。但是 你这个代码真的很难看，而且一点面向对象的思想都没有。还有你可以尝试启动两个减的线程，你会发现有些时候 num的值会小于0。你现在只有一个减的线程 所以不会出现。

16 楼 gegewuqin9 2013-06-20  

406657836 写道

大神，可是我测试的时候是可以实现的，是不是取巧了··· 
我现在把notify()放到加的线程里激活了，你能帮忙看看怎么样么？

15 楼 gegewuqin9 2013-06-20  

chen3975 写道

你写的和我的差不多，就是sysout这个换了地方，但你把这个写在外面是不对的，因为getSum()时sum的值可能已经被另一个线程改变了，我测试了一下很乱..

14 楼 chen3975 2013-06-20  

/**
 * 减线程
 */
public class MinusRunnable implements Runnable {
	private MinusAndAdd minusAndAdd;
	public MinusRunnable(MinusAndAdd minusAndAdd){
		this.minusAndAdd = minusAndAdd;
	}
	@Override
	public void run() {
		while(true){
			minusAndAdd.minus();
			System.out.println("minus->"+minusAndAdd.getSum());
		}
	}
}

/**
 * 加线程
 */
public class AddRunnable implements Runnable {
	private MinusAndAdd minusAndAdd;
	public AddRunnable(MinusAndAdd minusAndAdd){
		this.minusAndAdd = minusAndAdd;
	}
	@Override
	public void run() {
		while(true){
			minusAndAdd.add();
			System.out.println("add->"+minusAndAdd.getSum());
		}
	}
}
/**
 * 主线程
 */
public class MinusAndAdd {
	private int sum;
	
	public int getSum() {
		return sum;
	}

	public synchronized void minus(){
		while(sum<=0){
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		sum--;
		notifyAll();
	}
	
	public synchronized void add(){
		while(sum>3){
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		sum++;
		notifyAll();
	}
	public static void main(String[] args){
		MinusAndAdd minusAndAdd = new MinusAndAdd();
		Thread minus = new Thread(new MinusRunnable(minusAndAdd));
		Thread add = new Thread(new AddRunnable(minusAndAdd));
		minus.start();
		add.start();
	}
}

13 楼 406657836 2013-06-20  

gao_xianglong 写道

提个建议，写线程不要直接继承Thread，去实现Runnable，除了更灵活，还能实现资源共享。

回答的很牵强呵！实现Runnable的理由主要是Runnable很轻，它只需要实现run方法，而Thread还要继承过来一堆方法，一堆变量，而这些变量，方法都是后面不需要用的。所以选择实现Runnable。
至于资源 共享 没有明白你的意思。但是可以肯定的是Runnable能做到的Thread就一定能做到。

12 楼 406657836 2013-06-20  

406657836 写道

gegewuqin9 写道

406657836 写道

406657836 写道

gegewuqin9 写道

406657836 写道

程序结构太乱了。
而且notifyAll没有唤醒任何等待的线程，因为就没有线程等待。
不知道楼主理解notify和wait么？他们是需要获得同一把锁才能等待唤醒的。否则是会抛异常的。
楼主应该先把程序结构，然后再重新设计下线程。虽然是学习学习，但是要有个好习惯。
加油！

去掉notifyAll试了下，确实也能达到效果。只是不太明白这是什么原理哦，当num<=0的时候，t2就处于了wait状态了，那到底是什么把它唤醒的呢?

你的t2不是被唤醒了，而是被中断了， 然后你只是自己处理了中断异常，这个程序看起来太乱了。真没法看，你重新整理下把！

t2.interrupted() 中断 并复位！

有点了解了，wait是等待，让下一个在等待的线程先运行，下一个线程运行完成后再运行。但如果是同一个方法的话就需要notify。就像我上面的change()方法.

兄弟 看来是我误导你了！你这个wait是不能自己醒的因为没有加过期时间。wait通常是可以被其他线程唤醒(需要两个线程持有同一个锁)。你这里之所以wait了其他线程执行，是因为wait会释放已经获得的锁。

还有 你的change方法的wait和notify完全用错了。wait和notify通常是在两个线程里调用的，而不是同一个。你现在的问题比你改之前更大了，罪过呀！

11 楼 406657836 2013-06-20  

gegewuqin9 写道

406657836 写道

406657836 写道

gegewuqin9 写道

406657836 写道

程序结构太乱了。
而且notifyAll没有唤醒任何等待的线程，因为就没有线程等待。
不知道楼主理解notify和wait么？他们是需要获得同一把锁才能等待唤醒的。否则是会抛异常的。
楼主应该先把程序结构，然后再重新设计下线程。虽然是学习学习，但是要有个好习惯。
加油！

去掉notifyAll试了下，确实也能达到效果。只是不太明白这是什么原理哦，当num<=0的时候，t2就处于了wait状态了，那到底是什么把它唤醒的呢?

你的t2不是被唤醒了，而是被中断了， 然后你只是自己处理了中断异常，这个程序看起来太乱了。真没法看，你重新整理下把！

t2.interrupted() 中断 并复位！

有点了解了，wait是等待，让下一个在等待的线程先运行，下一个线程运行完成后再运行。但如果是同一个方法的话就需要notify。就像我上面的change()方法.

兄弟 看来是我误导你了！你这个wait是不能自己醒的因为没有加过期时间。wait通常是可以被其他线程唤醒(需要两个线程持有同一个锁)。你这里之所以wait了其他线程执行，是因为wait会释放已经获得的锁。

10 楼 gegewuqin9 2013-06-20  

406657836 写道

406657836 写道

gegewuqin9 写道

406657836 写道

程序结构太乱了。
而且notifyAll没有唤醒任何等待的线程，因为就没有线程等待。
不知道楼主理解notify和wait么？他们是需要获得同一把锁才能等待唤醒的。否则是会抛异常的。
楼主应该先把程序结构，然后再重新设计下线程。虽然是学习学习，但是要有个好习惯。
加油！

去掉notifyAll试了下，确实也能达到效果。只是不太明白这是什么原理哦，当num<=0的时候，t2就处于了wait状态了，那到底是什么把它唤醒的呢?

你的t2不是被唤醒了，而是被中断了， 然后你只是自己处理了中断异常，这个程序看起来太乱了。真没法看，你重新整理下把！

t2.interrupted() 中断 并复位！

有点了解了，wait是等待，让下一个在等待的线程先运行，下一个线程运行完成后再运行。但如果是同一个方法的话就需要notify。就像我上面的change()方法.

9 楼 406657836 2013-06-20  

406657836 写道

gegewuqin9 写道

406657836 写道

程序结构太乱了。
而且notifyAll没有唤醒任何等待的线程，因为就没有线程等待。
不知道楼主理解notify和wait么？他们是需要获得同一把锁才能等待唤醒的。否则是会抛异常的。
楼主应该先把程序结构，然后再重新设计下线程。虽然是学习学习，但是要有个好习惯。
加油！

去掉notifyAll试了下，确实也能达到效果。只是不太明白这是什么原理哦，当num<=0的时候，t2就处于了wait状态了，那到底是什么把它唤醒的呢?

你的t2不是被唤醒了，而是被中断了， 然后你只是自己处理了中断异常，这个程序看起来太乱了。真没法看，你重新整理下把！

t2.interrupted() 中断 并复位！

8 楼 406657836 2013-06-20  

gegewuqin9 写道

406657836 写道

程序结构太乱了。
而且notifyAll没有唤醒任何等待的线程，因为就没有线程等待。
不知道楼主理解notify和wait么？他们是需要获得同一把锁才能等待唤醒的。否则是会抛异常的。
楼主应该先把程序结构，然后再重新设计下线程。虽然是学习学习，但是要有个好习惯。
加油！

去掉notifyAll试了下，确实也能达到效果。只是不太明白这是什么原理哦，当num<=0的时候，t2就处于了wait状态了，那到底是什么把它唤醒的呢?

你的t2不是被唤醒了，而是被中断了， 然后你只是自己处理了中断异常，这个程序看起来太乱了。真没法看，你重新整理下把！

7 楼 gegewuqin9 2013-06-20  

406657836 写道

程序结构太乱了。
而且notifyAll没有唤醒任何等待的线程，因为就没有线程等待。
不知道楼主理解notify和wait么？他们是需要获得同一把锁才能等待唤醒的。否则是会抛异常的。
楼主应该先把程序结构，然后再重新设计下线程。虽然是学习学习，但是要有个好习惯。
加油！

去掉notifyAll试了下，确实也能达到效果。只是不太明白这是什么原理哦，当num<=0的时候，t2就处于了wait状态了，那到底是什么把它唤醒的呢?

6 楼 gegewuqin9 2013-06-20  

hardPass 写道

你要感谢iteye的鼓励，你的程序上了首页

是的呢，iteye还是比较关心新人的，我第一次在iteye写博客~

5 楼 gegewuqin9 2013-06-20  

gao_xianglong 写道

提个建议，写线程不要直接继承Thread，去实现Runnable，除了更灵活，还能实现资源共享。

好的，多谢了，以后我会注意的。

4 楼 406657836 2013-06-19  

程序结构太乱了。
而且notifyAll没有唤醒任何等待的线程，因为就没有线程等待。
不知道楼主理解notify和wait么？他们是需要获得同一把锁才能等待唤醒的。否则是会抛异常的。
楼主应该先把程序结构，然后再重新设计下线程。虽然是学习学习，但是要有个好习惯。
加油！

3 楼 hardPass 2013-06-19  

你要感谢iteye的鼓励，你的程序上了首页