一个线程习题,高手请帮忙

[pd0395]

设计4个线程对象,2个执行加操作,2个执行减操作

这个题是书上的一个习题,但是貌似意思没表示清楚...
本来很简单,但是我想把它完善点
我是这样想的,让线程实现同步,并且加入等待唤醒,要加完了才能减,减完了才能加...
具体运行结果如下:
10
10
9
9
11
11
8
8
.
.
.

结果弄一下午不但没弄出来还把我头都搞晕了....

求高手们给个完整代码.....
小弟谢过

[xiaoguan_Java]

帮顶，线程我也一直弄不太明白

[heartraid86]

我写了一个加法减法一次循环打印的双线程。看看对你有没有帮助

/**
 * 多线程运算器
 * @author heartraid
 * 
 */
class MultiOperator{
	/**当前可执行的运算标志*/
	private String operFlag="add";
	
	public MultiOperator(){

	}
	/**
	 * 加法运算
	 * @param num 数值
	 */
	public synchronized void add(int num){
		for(int i=0;i<100;i++){
			try {
				//如果当前不能执行加法，则让加法线程等待
				if(!this.operFlag.equals("add"))
					this.wait();
				num++;
				System.out.println("执行加法结果："+num);
				//加法完毕，允许减法运行
				operFlag="sub";
				//激活等待线程
				this.notifyAll();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	/**
	 * 减法运算
	 * @param num 数值
	 */
	public synchronized void sub(int num){
		for(int i=0;i<100;i++){
			try {
				if(!this.operFlag.equals("sub"))
					this.wait();	
				num--;
				System.out.println("执行减法结果："+num);
				operFlag="add";
				this.notifyAll();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}
/**
 * 加法线程
 * @author heartraid
 */
class AddRunnable implements Runnable{
	
	private MultiOperator operator=null;
	
	public AddRunnable(MultiOperator operator){
		this.operator=operator;
	}
	
	public void run(){
		operator.add(100);
	}
	
}
/**
 * 减法线程
 * @author heartraid
 */
class SubRunnable implements Runnable{
	
	private MultiOperator operator=null;
	
	public SubRunnable(MultiOperator operator){
		this.operator=operator;
	}
	
	public void run(){
		operator.sub(100);
	}
	
}
/**
 * 测试
 * @author heartraid
 */
public class Test {
	
	public static void main(String[] args) {
		MultiOperator operator=new MultiOperator();
		Thread addThread=new Thread(new AddRunnable(operator));
		Thread subThread=new Thread(new SubRunnable(operator));
		addThread.start();
		subThread.start();
	}
}

[bbb332]

public class TestThread
{
	private int j;
	public synchronized void inc()
	{
		j++;
		System.out.println(Thread.currentThread().getName() + "-inc:" + j);
	}
	public synchronized void dec()
	{
		j--;
		System.out.println(Thread.currentThread().getName() + "-dec:" + j);
	}
	public static void main(String[] args)
	{
		TestThread t=new TestThread();
		for (int i = 0; i < 2; i++)
		{
			Thread inc=new Thread(new Inc(t));
			Thread dec=new Thread(new Dec(t));
			inc.start();
			dec.start();
		}
	}
}
	
	class Inc implements Runnable
	{
		private TestThread obj;
		public Inc(TestThread obj)
		{
			this.obj=obj;
		}
		public void run()
		{
//			for (int i = 0; i < 100; i++)
//			{
				this.obj.inc();
//			}
		}
	}
	class Dec implements Runnable
	{
		private TestThread obj;
		public Dec(TestThread obj)
		{
			this.obj=obj;
		}
		public void run()
		{
//			for (int i = 0; i < 100; i++)
//			{
				this.obj.dec();
//			}
		}
	}

[pd0395]

你在实例2个对象看看,1个加一个减没问题啊,2个加2个减就有问题了...

[heartraid86]

我改了一下，现在可以了

/**
 * 多线程循环控制器
 * @author heartraid
 * 
 */
class OrderController{
	/**当前可执行的线程号*/
	private int threadOrder=1;
	
	private OrderController(){
	}
	/**单例模式*/
	public static OrderController newInstance(){
		return new OrderController();
	}
	/**
	 * 得到线程号
	 */
	public int getOrder(){
		return this.threadOrder;
	}
	/**
	 * 循环控制线程号
	 */
	public void setOrder(){
		threadOrder=((threadOrder!=4)?(++threadOrder):1);
	}
}

/**
 * 加法线程
 * @author heartraid
 */
class AddRunnable implements Runnable{
	
	private int threadNum=0;
	
	private int data=0;
	
	private OrderController controller=null;
	/**
	 * 加法操作构造器
	 * @param num 线程号
	 * @param data 操作数据值
	 * @param ctro 线程号控制器
	 */
	public AddRunnable(int num,int data,OrderController ctro){
		this.threadNum=num;
		this.data=data;
		this.controller=ctro;
	}
	
	public void run(){
		for(int i=0;i<100;i++){
			synchronized(controller)
			{
				try {
					//如果当前不能执行加法，则让加法线程等待
					while(this.threadNum!=controller.getOrder())
						controller.wait();
					System.out.println(this.threadNum+"号线程执行加法结果："+(++data));
					//设置允许下一线程运行的线程号
					controller.setOrder(); 
					//激活等待线程
					controller.notifyAll();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
	
			}
		}
	}
	
}
/**
 * 减法线程
 * @author heartraid
 */
class SubRunnable implements Runnable{
	
	private int threadNum=0;
	
	private int data=0;
	
	private OrderController controller=null;
	/**
	 * 减法操作构造器
	 * @param num 线程号
	 * @param data 操作数据值
	 * @param ctro 线程号控制器
	 */
	public SubRunnable(int num,int data,OrderController ctro){
		this.threadNum=num;
		this.data=data;
		this.controller=ctro;
	}
	
	public void run(){
		for(int i=0;i<100;i++){
			synchronized(controller)
			{
				try {
					while(this.threadNum!=controller.getOrder())
						controller.wait();
					System.out.println(this.threadNum+"号线程执行减法结果："+(--data));
					controller.setOrder();
					controller.notifyAll();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
}
/**
 * 测试
 * @author heartraid
 */
public class Test {
	
	public static void main(String[] args) {
		OrderController controller=OrderController.newInstance();
		Thread addThread1=new Thread(new AddRunnable(1,100,controller));
		Thread addThread2=new Thread(new AddRunnable(2,100,controller));
		Thread subThread1=new Thread(new SubRunnable(3,100,controller));
		Thread subThread2=new Thread(new SubRunnable(4,100,controller));
		addThread1.start();
		addThread2.start();
		subThread1.start();
		subThread2.start();
	}
}

[zxj828282]

top rop top

[huosidun0302]

帮顶
回复内容太短了！
回复内容太短了！
回复内容太短了！

[z070204z]

可以考虑使用wait方法

[pd0395]

5楼修改了后就对了,万分感!