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

Question

设计4个线程对象,2个执行加操作,2个执行减操作这个题是书上的一个习题,但是貌似意思没表示清楚...
本来很简单,但是我想把它完善点
我是这样想的,让线程实现同步,并且加入等待唤醒,要加完了才能减,减完了才能加...
具体运行结果如下:
10
10
9
9
11
11
8
8
.
.
.结果弄一下午不但没弄出来还把我头都搞晕了....求高手们给个完整代码.....
小弟谢过

Answer 1

我写了一个加法减法一次循环打印的双线程。看看对你有没有帮助
/**
 * 多线程运算器
 * @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();
}
}

Answer 2

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();
// }
}
}

Answer 3

我改了一下，现在可以了/**
 * 多线程循环控制器
 * @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();
}
}