public void Run(NumberReader reader)
{
var results = new List<long>();
var numbersToCheck = new Queue<long>();
StartComputationThreads(results, numbersToCheck);
var progressMonitor = new ProgressMonitor(results);
new Thread(progressMonitor.Run) {IsBackground = true}.Start();
reader.ReadIntegers(numbersToCheck);
//foreach (var value in reader.ReadIntegers())
//{
// lock (IsNumberPrimeCalculator.LockQueue)
// {
// numbersToCheck.Enqueue(value);
// }
//}
while (true) {
bool keepGoing = true;
lock (IsNumberPrimeCalculator.LockQueue)
{
keepGoing = numbersToCheck.Count > 0;
}
if (keepGoing == false)
{
break;
}
Thread.Sleep(100); // wait for the computation to complete.
}
Console.WriteLine("{0} of the numbers were prime", progressMonitor.TotalCount);
}
public void Run(NumberReader reader)
{
var results = new List <long>();
var numbersToCheck = new Queue <long>();
StartComputationThreads(results, numbersToCheck);
var progressMonitor = new ProgressMonitor(results);
new Thread(progressMonitor.Run)
{
IsBackground = true
}.Start();
reader.ReadIntegers(numbersToCheck);
while (true)
{
bool continuing = true;
lock (IsNumberPrimeCalculator.LockQueue)
{
continuing = numbersToCheck.Count > 0;
}
if (continuing == false)
{
break;
}
Thread.Sleep(100); // wait for the computation to complete.
}
Console.WriteLine("{0} of the numbers were prime", progressMonitor.TotalCount);
}
public void Run(NumberReader reader)
{
var results = new lockedList(new List <long>()); //Create a list wrapped in an object thats a little more threadsafe.
var entries = new Queue <long>();
foreach (var value in reader.ReadIntegers())
{
entries.Enqueue(value); //Enqueue before to avoid lock contention
}
var numbersToCheck = new lockedQueue(entries, entries.Count); //Wrap the queue in a threadsafe structure.
StartComputationThreads(results, numbersToCheck);
var progressMonitor = new ProgressMonitor(results);
new Thread(progressMonitor.Run)
{
IsBackground = true
}.Start();
while (!numbersToCheck.Done() || !progressMonitor.Clean())
{
Thread.Sleep(100); // wait for the computation to complete. Signaled by a clean progmon and empty completed queue.
}
//I thought about changing sleep to depend on how many numbers are left in the queue... but nah too much work.
//The order of these is deliberate, since the first check will most usually be the concerning one.
Console.WriteLine("{0} of the numbers were prime", progressMonitor.TotalCount);
}
public void Run(NumberReader reader)
{
lock (synclock)
{
var results = new List<long>();
var numbersToCheck = new Queue<long>();
StartComputationThreads(results, numbersToCheck);
var progressMonitor = new ProgressMonitor(results);
new Thread(progressMonitor.Run) { IsBackground = true }.Start();
foreach (var value in reader.ReadIntegers())
{
numbersToCheck.Enqueue(value);
}
while (numbersToCheck.Count > 0)
{
Thread.Sleep(100); // wait for the computation to complete.
}
Console.WriteLine("{0} of the numbers were prime", progressMonitor.TotalCount);
}
}
public void Run(NumberReader reader)
{
var results = new List <long>();
var numbersToCheck = new BoundBuffer <long>();
RwLock _wlock = new RwLock();
StartComputationThreads(results, numbersToCheck);
var progressMonitor = new ProgressMonitor(results);
new Thread(progressMonitor.Run)
{
IsBackground = true
}.Start();
_wlock.WriteLock();
foreach (var value in reader.ReadIntegers())
{
numbersToCheck.Enqueue(value); //critical section
}
while (numbersToCheck.Count() > 0)
{
Thread.Sleep(100); // wait for the computation to complete. New Lock?
}
Console.WriteLine("{0} of the numbers were prime", progressMonitor.TotalCount);
_wlock.WriteUnLock();
}
public void Run(NumberReader reader)
{
var results = new List <long>();
var numbersToCheck = new Boundbuffer <long>();
StartComputationThreads(results, numbersToCheck);
var progressMonitor = new ProgressMonitor(results);
new Thread(progressMonitor.Run)
{
IsBackground = true
}.Start();
foreach (var value in reader.ReadIntegers())
{
numbersToCheck.Enqueue(value);
}
bool wait = true;
while (wait)
{
Thread.Sleep(1000); // wait for the computation to complete.
wait = false;
}
Console.WriteLine("{0} of the numbers were prime first", progressMonitor.TotalCount);
}
public void Run(NumberReader reader)
{
var results = new List <long>();
var numbersToCheck = new Queue <long>();
StartComputationThreads(results, numbersToCheck);
var progressMonitor = new ProgressMonitor(results);
new Thread(progressMonitor.Run)
{
IsBackground = true
}.Start();
//lock (tart) {
foreach (var value in reader.ReadIntegers())
{
numbersToCheck.Enqueue(value);
}
// }
lock (tart)
{
while (numbersToCheck.Count > 0)
{
Thread.Sleep(100); // wait for the computation to complete.
}
}
Console.WriteLine("{0} of the numbers were prime", progressMonitor.TotalCount);
}
public void Run(NumberReader reader)
{
//Start Threads.
StartComputationThreads(CalculatorboundBuffer.getResultList(), CalculatorboundBuffer.getQueueForNumbersToCheck());
//Start Progress Monitor.
var progressMonitor = new ProgressMonitor(CalculatorboundBuffer.getResultList());
//Run background threads.
new Thread(progressMonitor.Run) { IsBackground = true }.Start();
//Read in numbers from notepad.
reader.ReadIntegers(CalculatorboundBuffer.getQueueForNumbersToCheck());
while (CalculatorboundBuffer.getQueueForNumbersToCheck().Count > 0)
{
Thread.Sleep(100);
}
Console.WriteLine("{0} of the numbers were prime", progressMonitor.TotalCount);
}
public void Run(NumberReader reader)
{
BoundBuff = new BoundBuffer<long>();
StartComputationThreads(BoundBuff.GetList(), BoundBuff.GetQueue());
var progressMonitor = new ProgressMonitor(BoundBuff.GetList());
new Thread(progressMonitor.Run) {IsBackground = true}.Start();
foreach (var value in reader.ReadIntegers()) {
BoundBuff.Enqueue(value);
}
while (BoundBuff.GetQueue().Count > 0)
{
Thread.Sleep(100); // wait for the computation to complete.
}
Console.WriteLine("{0} of the numbers were prime", progressMonitor.TotalCount);
}
