Check whether the number is divisible by the multipliers of two and the rest of integers, java multithreading

Question

I am trying to find the largest factor of a number (except than itself) by using multiple

Threads in JAVA. the template for the code is ready but I don't know what to put in the missing methods. the thread classes will hold the missing synchronized methods in run() so the threads can run in the main class, but I still don't understand what exactly wanted from me in the methods.

this is the template:

public class LargestFactor {

// Do not change this method

public int testLargestFactor(int n) {

FactorChecker fc = new FactorChecker(n, 2, 1);

Thread t1 = new Thread(new Factor2(fc));

Thread t2 = new Thread(new FactorRest(fc));

t1.start();

t2.start();

try {

t1.join();

t2.join();

} catch (Exception e) {

System.out.println("Exception: " + e.getMessage());

}

return fc.getMaxFactor();

}

}

class FactorChecker {

// n: number that'd be queried

// div: divisor

// maxFactor: maximum factor of the number (except than itself)

private int n, div;

private int maxFactor;

public FactorChecker(int n, int div, int maxFactor) {

this.n = n;

this.div = div;

this.maxFactor = maxFactor;

}

// Check whether the number is divisible by the multipliers of two (e.g. 2,4,6,...)

public synchronized void checkFactor2() {

// *** Fill this method ***

}

// Check whether the number is divisible by the rest of the integers

public synchronized void checkFactorRest() {

// *** Fill this method ***

}

public int getN() {

return n;

}

public int getDiv() {

return div;

}

public int getMaxFactor() {

return this.maxFactor;

}

public void setDiv(int div) {

this.div = div;

}

}

// Thread for checking divisibility by multipliers of 2

class Factor2 implements Runnable {

// *** Fill this class ***

}

// Thread for checking divisibility by the rest of the integers

class FactorRest implements Runnable {

// *** Fill this class ***

}

Answer 1

I do not quite understand what you are supposed to do.

Below is an implementation of my interpretation, which may be wrong;

but I hope it can help.

The template uses comments starting with //

For clarity all my comments are surrounded by /* ... */

It turns out that my answer is longer than Wyzant limit.

I will try to provide it in several pieces.

class FactorChecker {

// n: number that'd be queried

// div: divisor

// maxFactor: maximum factor of the number (except than itself)

private int n, div;

private int maxFactor;

/* I do not know the original intention for the variable div.

I am going to use div and maxFactor as private variables

always satisfying the invariant

n = div*maxFactor

Those two variables will be changed whenever another such pair

with a larger factor is found.

The variables div and maxFactor can be modified in different

threads and therefore their accesses will have to be protected

in a critical region.

The variable n can be read by multiple threads, but will not be

modified, therefore need not be protected.

*/

public FactorChecker(int n, int div, int maxFactor) {

this.n = n;

this.div = div;

this.maxFactor = maxFactor;

/* In my usage of the variables div and maxFactor

the caller has no business setting them.

I am going to set them so as to satisfy the invariant.

Initially they will be set indicating

n = n*1

This trivial factoring will remain in case n is a prime,

or n < 2

*/

this.div = n;

this.maxFactor = 1;

/* I do not understand why your teacher's initial setting was

div=2.

I do understand why the initial setting must be

maxFactor=1;

setting it to the smallest factor facilitates increases.

*/

}

Part 2:

// Check whether the number is divisible by the multipliers of two (e.g. 2,4,6,...)

/* I do not understand what your teacher means by "multipliers of two".

The example suggests that he means "multiples of two",

i.e., "even numbers".

So I am letting checkFactor2 look for even divisors.

*/

public /* synchronized */ void checkFactor2() {

factor(0); /* Find largest factor with an even divisor */

}

// Check whether the number is divisible by the rest of the integers

/* I am interpretting "rest of the integers" as "odd numbers"

*/

public /* synchronized */ void checkFactorRest() {

factor(1); /* Find largest factor with an odd divisor */

}

Part 3:

/* I do not understand why your teacher declared checkFactor2() and

checkFactorRest() as synchronized.

It makes sense to declared a method as synchronized if it can be

executed in more than one thread.

But that is not the case here.

If you understand why they should be declared synchronized then

please go ahead and add the keywords back.

*/

Sorry, it turns out that Wyzant will let let me put in the whole thing.