0

我制作了一个程序并期待这样的输出：

A 1 A B 2 B C 3 C ...

电子 5 电子

这是我的代码，我认为我遇到了饥饿问题，请帮助我

class Product {
    static boolean flag1, flag2, flag3;

    synchronized void printLwrAlpha(char value) {
        // System.out.println(flag3+": inside lwr_alpha");
        if (!flag3)
            try {
                wait();
            } catch (Exception ex) {
                System.out.println(ex);
            }
        System.out.println(value);
        flag3 = false;
        flag1 = false;
        System.out.println("before notify");
        notify();
        System.out.println("after notify");
    }

    synchronized void printUprAlpha(char n) {
        // System.out.println(flag1+": inside upr_alpha");
        if (flag1)
            try {
                wait();
            } catch (Exception e) {
                System.out.println(e);
            }
        System.out.println(n);
        // System.out.println(num);
        flag1 = true;
        flag2 = true;
        notify();
    }

    synchronized void printNum(int num) {
        // System.out.println(flag2+": inside num");
        if (!flag2)
            try {
                wait();
            } catch (Exception e) {
                System.out.println(e);
            }
        // System.out.println(n);
        System.out.println(num);
        flag2 = false;
        flag3 = true;
        notify();
    }
}

class PrintNum implements Runnable {
    Product p;

    PrintNum(Product p) {
        this.p = p;
        new Thread(this, "Producer").start();
        try {
            Thread.sleep(1000);
        } catch (Exception ex) {
            System.out.println(ex);
        }
    }

    public void run() {
        for (int i = 1; i <= 5; i++)
            p.printNum(i);
    }
}

class PrintLwrAlpha implements Runnable {
    Product p;
    static char ch = 'a';

    PrintLwrAlpha(Product p) {
        this.p = p;
        new Thread(this, "Producer").start();
        try {
            Thread.sleep(1000);
        } catch (Exception ex) {
            System.out.println(ex);
        }
    }

    public void run() {
        for (int i = 1; i <= 5; i++) {
            char c = (char) (ch + (i - 1));
            p.printLwrAlpha(c);
        }
    }

}

class PrintUprAlpha implements Runnable {
    Product p;
    static char ch = 'A';

    PrintUprAlpha(Product p) {
        this.p = p;
        new Thread(this, "Producer").start();
        try {
            Thread.sleep(1000);

        } catch (Exception ex) {
            System.out.println(ex);
        }
    }

    public void run() {
        for (int i = 1; i <= 5; i++) {
            char c = (char) (ch + (i - 1));
            p.printUprAlpha(c);
        }
    }
}

public class MainClass1 {
    public static void main(String ar[]) {
        Product p = new Product();
        new PrintNum(p);
        new PrintUprAlpha(p);
        new PrintLwrAlpha(p);
    }

}

我得到这个输出：

运行： A 1 B 2 C 3 D 4 E 5 a 通知前通知后

我想在这个程序进入饥饿之后

4

2 回答 2

0

替换所有ifs，例如

if (!flag3)

带有while循环

while (!flag3)
于 2013-10-01T06:41:06.983 回答
0

如果我理解正确，您的问题是您正在尝试使用具有多个线程的单个等待对象。等待/通知的常见场景如下：一个线程正在等待资源变得可用，而第二个线程产生资源并通知第一个线程。在代码中它可能看起来像这样：

class ResourceFactory {
     public synchronized void produce()
     {
         // make the resource available
         obj.notify();
     }

     public synchronized void consume()
     {
          if( /* resource is not available */ ) {
              obj.wait();
          }
          // do something with resource
     }
}

当多个线程试图等待单个对象时，问题在于在通知调用之后哪个线程将被唤醒取决于实现。我认为您应该制作 3 个不同的对象并执行以下操作：

// thread 1
obj1.wait();
obj2.notify()

// thread 2
obj2.wait();
obj3.notify()

// thread 3
obj3.wait();
obj1.notify()

小心并尽量不要让你的代码死锁。

最后是你的代码。尽管有标志，前两个线程仍在等待并相互唤醒。当第三个线程被唤醒时，没有线程通知它。所以这是一个经典的僵局。

于 2013-10-01T06:43:23.953 回答