0

Java CountDownLatch を使用してスレッドの実行を制御する方法を学びたいと思っています。

私は2つのクラスを持っています。1 つは呼び出されPoller、もう 1 つは ですReferendum。スレッドはReferendumクラスで作成され、そのrun()メソッドはPollerクラスに含まれています。

Poller クラスと Referendum クラスでは、 import を介して Java カウントダウン ラッチをインポートしjava.util.concurrent.CountDownLatchました。

私は主に、*.countDown();and*.await();ステートメントを適用する必要がある理由と場所を理解し、コンストラクター内で countDownLatch を正しく初期化したかどうかを理解しようとしていますPoller。

2 つのクラスの完全なコードは次のとおりです。

import java.util.concurrent.CountDownLatch;

public class Poller extends Thread
{
private String id;                  // pollster id
private int pollSize;               // number of samples
private int numberOfPolls;          // number of times to perform a poll
private Referendum referendum;      // the referendum (implies voting population)
private int sampledVotes[];         // the counts of votes for or against
static CountDownLatch pollsAreComplete; //the CountDownLatch


/**
 * Constructor for polling organisation.
 * @param r A referendum on which the poller is gathering stats
 * @param id The name of this polling organisation
 * @param pollSize The size of the poll this poller will use
 * @param pollTimes The number of times this poller will conduct a poll
 * @param aLatch The coutn down latch that prevents the referendum results from being published
 */

public Poller(Referendum r, String id, int pollSize, int pollTimes, CountDownLatch aLatch)
{
    this.referendum = r;
    this.id = id;
    this.pollSize = pollSize;
    this.numberOfPolls = pollTimes;
    this.pollsAreComplete = aLatch;
    aLatch = new CountDownLatch(3);

    // for and against votes to be counted
    sampledVotes = new int[2];
}


// getter for numberOfPolls
public int getNumberOfPolls()
{
    return numberOfPolls;
}

@Override
//to use the countdown latch
public void run()
{      
    for (int i = 0; i < getNumberOfPolls(); i++)
    {
        resetVotes();
        pollVotes();
        publishPollResults();
    }
}

// make sure all sampledVotes are reset to zero
protected void resetVotes()
{
    // initialise the vote counts in the poll
    for (int i = 0; i < sampledVotes.length; i++)
    {
        sampledVotes[i] = 0;
    }
}

// sampling the way citizens will vote in a referendum
protected void pollVotes()
{
    for (int n = 0; n < pollSize; n++)
    {
        Citizen c = referendum.pickRandomCitizen();

        //As things stand, pickRandomCitizen can return null
        //because we haven't protected access to the collection
        if (c != null)
        {
            sampledVotes[c.voteFor()]++;
        }
    }
}

protected void publishPollResults()
{
    int vfor = 100 * sampledVotes[Referendum.FOR] / pollSize;

    int vagainst = 100 * sampledVotes[Referendum.AGAINST] / pollSize;

    System.out.printf("According to %-20s \t(", this.id + ":");

    System.out.print("FOR " + vfor);

    try
    {
        Thread.sleep(1000);
    } catch (Exception e)
    {
        e.printStackTrace();
    }

    System.out.println(", AGAINST " + vagainst + ")");
 }
}

と

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CountDownLatch;  


public class Referendum
{
private List<Citizen> citizens;         //voters
private List<Poller> pollers;           //vote samplers
public static final int FOR = 0;        //index for votes array
public static final int AGAINST = 1;    //index for votes array
private int votes[];                    //for and against votes counters


public Referendum(int population)
{
    citizens = new LinkedList<Citizen>();
    pollers = new LinkedList<Poller>();

    // initialise the referendum with the population
    for (int i = 0; i < population; i++)
    {
        Citizen c = new Citizen(i % 4); //suppose equal party membership
        citizens.add(c);
    }

    votes = new int[2]; //in this example, only For or Against
}

public void addPoller(Poller np)
{
    pollers.add(np);
}

public Citizen removeCitizen(int i)
{
    return citizens.remove(i);
}

public List<Poller> getPollers()
{
    return pollers;
}

public void startPollsWithLatch()
{
   //create some poller threads that use a latch
    addPoller(new Poller(this, "The Daily Day", 100, 3, Poller.pollsAreComplete));
    addPoller(new Poller(this, "Stats people", 100, 3, Poller.pollsAreComplete));
    addPoller(new Poller(this, "TV Pundits", 100, 3, Poller.pollsAreComplete));

    // start the polls
    for (Poller p : pollers)
    {
        p.start();

    }
}



// pick a citizen randomly - access not controlled yet
public Citizen pickRandomCitizen()
{
    //TODO add code to this method for part (b)

    Citizen randomCitizen;
    // first get a random index
    int index = (int) (Math.random() * getPopulationSize());
    randomCitizen = citizens.remove(index);

    return randomCitizen;
}

// Counting the actual votes cast in the referendum
public void castVotes()
{
    for (int h = 0; h < getPopulationSize(); h++)
    {
        Citizen c = citizens.get(h);

        votes[c.voteFor()]++;
    }
}

// tell the size of population
public int getPopulationSize()
{
    return citizens.size();
}

// display the referendum results
public void revealResults()
{
    System.out.println(" **** The Referendum Results are out! ****");

    System.out.println("FOR");
    System.out.printf("\t %.2f %%\n", 100.0 * votes[FOR] / getPopulationSize());

    System.out.println("AGAINST");
    System.out.printf("\t %.2f %%\n", 100.0 * votes[AGAINST] / getPopulationSize());
}

public static void main(String[] args)
{
    // Initialise referendum. The number of people
    // has been made smaller here to reduce the simulation time.
    Referendum r = new Referendum(50000);


    r.startPollsWithLatch();

    r.castVotes();

    // reveal the results of referendum
    r.revealResults();
 }
}

一言で言えば...すべてのスレッドは、実行されるpublishPollResults();前にステートメントを実行する必要がありrevealResults();ます。

4

2 に答える 2