Peterson's Algothrim’算法的Java实现和C++实现

事实上Java实现并没有成功，不知为何总会有似乎是死锁的情况发生，任务并不能执行结束。

我已经再三检查了我的代码实现，也邀请朋友来检查我的代码，但朋友同样也遇到了跟我一样的问题。

Java实现：

public class Solution{

    static int balance = 5000;      // 尝试用两个线程来对余额进行修改
    static int trade_amount = 12;   // 一个线程充值，一个线程取钱，每次操作的额度和操作的次数相同
                                    // 在并发情况下，最后的金额应该还保持原来的数目
    static boolean[] WhoIsRuning = new boolean[] {false, false};
    static int turn = 0;

    public static void main(String[] args) throws InterruptedException {
        long delay = 2; // 控制线程的速度，让线程跑的慢一点

        Thread one = new Thread(new Runnable(){
            @Override
            public void run() {
                int me      = 0;
                int other   = 1;
                for( int i = 0; i < 100; i++ ){
                    /* 进入临界区 */
                    WhoIsRuning[me] = true; turn = other;
                    while( WhoIsRuning[other] && turn == other ) ;
                    /* 访问敏感资源 */
                    balance += trade_amount;
                    System.out.println("#" + i + " one(0) top up 13 yuan.");
                    /* 退出临界区 */
                    WhoIsRuning[me] = false;
                    /* 为了更容易触发似乎是死锁的情形，让线程跑的慢一点*/
                    try{
                        Thread.sleep(delay);
                    }catch( InterruptedException e ){
                        e.printStackTrace();
                    }
                }
            }
        });
        Thread another = new Thread(new Runnable(){
            @Override
            public void run() {
                /* 与线程1相似的代码，但改变了身份和行为 */
                int me      = 1;
                int other   = 0;

                for( int i = 0; i < 100; i++ ){
                    WhoIsRuning[me] = true; turn = other;
                    while( WhoIsRuning[other] && turn == other ) ;

                    balance -= trade_amount;
                    System.out.println("#" + i + " another(1) withdraw up 13 yuan.");

                    WhoIsRuning[me] = false;

                    try{
                        Thread.sleep(delay);
                    }catch( InterruptedException e ){
                        e.printStackTrace();
                    }
                }
            }
        });
        one.start();    another.start();
        another.join(); one.join();

        System.out.println("\nthe balance now is " + balance);
    }
}

C++实现得到了预期的效果：

// PetersonsAlgorithm.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <thread>
#include <stdio.h>
#include <Windows.h>

int balance         = 5000;
int trade_amount    = 13;
int delay           = 0;

/* mutual exclusion contorls */ 
int wantsToAccessBalance[]  = { 0, 0 };
int turn                    = 0;

void TopUpBalance() {

    int me = 0, another = 1;
    for (size_t i = 0; i < 100; i++)
    {
        wantsToAccessBalance[me] = true; turn = another;
        while (wantsToAccessBalance[another] && turn == another);

        balance += trade_amount;
        printf("#%d. top up %d amount, the balance now left %d.\n",
            i, trade_amount, balance);
        Sleep(delay);
        wantsToAccessBalance[me] = false;
    }

}

void WithdrawMoney() {

    int me = 1, another = 0;
    for (size_t i = 0; i < 100; i++)
    {
        wantsToAccessBalance[me] = true; turn = another;
        while (wantsToAccessBalance[another] && turn == another);

        balance -= trade_amount;
        printf("#%d. withdraw %d amount, the balance now left %d.\n",
            i, trade_amount, balance);
        Sleep(delay);
        wantsToAccessBalance[me] = false;
    }
}

int main()
{
    std::thread     topup{ TopUpBalance };
    std::thread     withdraw{ WithdrawMoney };

    topup.join(); withdraw.join();

    printf("\nthe final balance now left %d.\n", balance);
}