4

我被要求执行 10 次正确调用“ping”和“pong”的乒乓球游戏（意思是在 ping 之前没有乒乓球）。意思是，控制台中的最终输出应该是：“ping！（1）”，“pong！（1）”，“ping！（2）”，“pong！（2）”等。

需求是实现带有信号量、reetrantlock 和倒计时锁存器的gamepingpongthread。

我的问题是打印顺序并不总是按照要求，我想知道我做错了什么。

这是代码：

// Import the necessary Java synchronization and scheduling classes.
import java.util.concurrent.Semaphore;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;

/**
 * @class PingPongRight
 *
 * @brief This class implements a Java program that creates two
 *        instances of the PlayPingPongThread and start these thread
 *        instances to correctly alternate printing "Ping" and "Pong",
 *        respectively, on the console display.
 */
public class PingPongRight
{
    /**
     * @class SimpleSemaphore
     *
     * @brief This class provides a simple counting semaphore
     *        implementation using Java a ReentrantLock and a
     *        ConditionObject.
     */
    static public class SimpleSemaphore
    {
        private int mPermits;
        private ReentrantLock lock = new ReentrantLock();
        private Condition isZero = lock.newCondition();

        /**
         * Constructor initialize the data members. 
         */
        public SimpleSemaphore (int maxPermits)
        { 
            mPermits = maxPermits;
        }

        /**
         * Acquire one permit from the semaphore.
         */
        public void acquire() throws InterruptedException
        {
            lock.lock();
            while (mPermits == 0)
                isZero.await();
            mPermits--;
            lock.unlock();
        }

        /**
         * Return one permit to the semaphore.
         */
        void release() throws InterruptedException
        {
            lock.lock();
            try {
                mPermits++;
                isZero.signal();
            } finally {
                lock.unlock();
            }
        }
    }

    /**
     * Number of iterations to run the test program.
     */
    public static int mMaxIterations = 10;

    /**
     * Latch that will be decremented each time a thread exits.
     */
    public static CountDownLatch latch = new CountDownLatch(2);

    /**
     * @class PlayPingPongThread
     *
     * @brief This class implements the ping/pong processing algorithm
     *         using the SimpleSemaphore to alternate printing "ping"
     *         and "pong" to the console display.
     */
    public static class PlayPingPongThread extends Thread
    {
        private String message;
        private SimpleSemaphore semaphore;

        /**
         * Constructor initializes the data member.
         */
        public PlayPingPongThread (String msg, SimpleSemaphore pingOrPong)
        {
            message = msg;
            semaphore = pingOrPong;
        }

        /**
         * Main event loop that runs in a separate thread of control
         * and performs the ping/pong algorithm using the
         * SimpleSemaphores.
         */
        public void run () 
        {
            for (int i = 1 ; i <= mMaxIterations ; i++) {
                try {
                    semaphore.acquire();
                    System.out.println(message + "(" + i + ")");
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            latch.countDown();
        }
    }

    /**
     * The main() entry point method into PingPongRight program. 
     */
    public static void main(String[] args) {
        try {         
            // Create the ping and pong SimpleSemaphores that control
            // alternation between threads.
            SimpleSemaphore pingSemaphore = new SimpleSemaphore(mMaxIterations);
            SimpleSemaphore pongSemaphore = new SimpleSemaphore(mMaxIterations);

            System.out.println("Ready...Set...Go!");

            // Create the ping and pong threads, passing in the string
            // to print and the appropriate SimpleSemaphores.
            PlayPingPongThread ping = new PlayPingPongThread("Ping!", pingSemaphore);
            PlayPingPongThread pong = new PlayPingPongThread("Pong!", pongSemaphore);

            // Initiate the ping and pong threads, which will call the run() hook method.
            ping.start();
            pong.start();

            // Use barrier synchronization to wait for both threads to finish.
            latch.await();
        } 
        catch (java.lang.InterruptedException e)
            {}

        System.out.println("Done!");
    }
}

提前致谢

4

2 回答 2

8

我的问题是打印顺序并不总是按照要求，我想知道我做错了什么。

我认为您的问题是 ping 和 pong 线程都在获取和释放它们自己的信号量。我认为您需要将两个信号量都传递给两个线程。每个线程都调用acquire()和。acquireSemaphorerelease()releaseSemaphore

  acquireSemaphore.acquire();
  System.out.println(message + "(" + i + ")");
  releaseSemaphore.release();

线程看起来像：

public PlayPingPongThread (String msg, SimpleSemaphore acquireSemaphore,
        SimpleSemaphore releaseSemaphore)

然后线程被初始化为：

// ping acquires on the ping, releases the pong
PlayPingPongThread ping = new PlayPingPongThread("Ping!", pingSemaphore, pongSemaphore);
// pong acquires on the pong, releases the ping
PlayPingPongThread pong = new PlayPingPongThread("Pong!", pongSemaphore, pingSemaphore);

应该从 1 许可证开始，而pingSemaphore乒乓球应该从 0 开始。

  1. ping首先调用acquire()thepingSemaphore并给出。
  2. ping打印出 ping。
  3. ping呼吁。release()_pongSemaphore
  4. 这会唤醒pong（假设您的信号量代码当然有效）。
  5. pong打印pong。
  6. pong呼吁。release()_pingSemaphore
  7. 重复...
于 2014-04-10T20:06:33.773 回答
0

也可以使用可重入锁条件来实现乒乓球比赛，和wait-notify很相似。

package com.example.thread;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class PingPongUsingReentrantCondition {

    private static ReentrantLock lock = new ReentrantLock(true);
    private Condition conditionMet = lock.newCondition();

    public static void main(String[] args) {
        PingPongUsingReentrantCondition pingPong = new PingPongUsingReentrantCondition();
        int times = 10;
        Thread t1 = new Thread(() -> pingPong.pingpong("Ping!", times));
        Thread t2 = new Thread(() -> pingPong.pingpong("Pong!", times));
        t1.start();
        t2.start();
    }
    
    public void pingpong(String s, int times) {
        int counter = 1;
        while(counter<=times) {             
            run(s, counter);
            counter = counter+1;
        }
    }

    public void run(String s, int counter) {
        lock.lock();
        try {
            conditionMet.await(2, TimeUnit.SECONDS);
            System.out.println(s + "(" + counter + ")");
            conditionMet.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
于 2020-09-26T12:25:45.253 回答