Help is needed

Question about the task

Resolved

Why is the task not accepted? All these constructors were produced by IntelliJ IDEA(Alt+Insert), I just added the logic to the corresponding two constructors. Validation result: Error in com/codegym/task/task28/task2805/MyThread.java on line 58 no suitable constructor found for Thread(java.lang.ThreadGroup,java.lang.Runnable,java.lang.String,long,boolean) constructor java.lang.Thread.Thread() is not applicable (actual and formal argument lists differ in length) constructor java.lang.Thread.Thread(java.lang.Runnable) is not applicable (actual and formal argument lists differ in length) constructor java.lang.Thread.Thread(java.lang.Runnable,java.security.AccessControlContext) is not applicable (actual and formal argument lists differ in length) constructor java.lang.Thread.Thread(java.lang.ThreadGroup,java.lang.Runnable) is not applicable (actual and formal argument lists differ in length) constructor java.lang.Thread.Thread(java.lang.String) is not applicable (actual and formal argument lists differ in length) constructor java.lang.Thread.Thread(java.lang.ThreadGroup,java.lang.String) is not applicable (actual and formal argument lists differ in length) constructor java.lang.Thread.Thread(java.lang.Runnable,java.lang.String) is not applicable (actual and formal argument lists differ in length) constructor java.lang.Thread.Thread(java.lang.ThreadGroup,java.lang.Runnable,java.lang.String) is not applicable (actual and formal argument lists differ in length) constructor java.lang.Thread.Thread(java.lang.ThreadGroup,java.lang.Runnable,java.lang.String,long) is not applicable (actual and formal argument lists differ in length)

In a separate file, create a class called MyThread that inherits Thread. MyThread must:
1. Be able to be created using any of the superclass's constructors (Alt+Insert).
2. Thread priorities must be set using a loop—from the minimum to the maximum value.
3. If the thread has a thread group (ThreadGroup), then the thread's priority can't be greater than its thread group's maximum priority.

Requirements:

Create a MyThread class in a separate file. Make it inherit Thread.
The MyThread class must have constructors similar to the superclass's constructors.
The priority of the MyThread objects should be set using a loop, from MIN_PRIORITY to MAX_PRIORITY.
If a MyThread object has a ThreadGroup, then the MyThread's priority must not be greater than the ThreadGroup's maximum priority.

package com.codegym.task.task28.task2805; import java.util.concurrent.atomic.AtomicInteger; public class MyThread extends Thread { private static AtomicInteger counter = new AtomicInteger(1); private static AtomicInteger counter1 = new AtomicInteger(3); public MyThread() { if (counter.get() <= MAX_PRIORITY) { setPriority(counter.getAndIncrement()); } else { counter.set(1); setPriority(counter.getAndIncrement()); } } public MyThread(Runnable task) { super(task); } public MyThread(ThreadGroup group, Runnable task) { super(group, task); } public MyThread(String name) { super(name); } public MyThread(ThreadGroup group, String name) { super(group, name); int groupMaxPriority = getThreadGroup().getMaxPriority(); if (counter1.get() < groupMaxPriority) { setPriority(counter1.getAndIncrement()); } else if (counter1.get() >= groupMaxPriority && counter1.incrementAndGet() < 12){ setPriority(groupMaxPriority); } else { counter1.set(1); setPriority(counter1.getAndIncrement()); } } public MyThread(Runnable task, String name) { super(task, name); } public MyThread(ThreadGroup group, Runnable task, String name) { super(group, task, name); } public MyThread(ThreadGroup group, Runnable task, String name, long stackSize) { super(group, task, name, stackSize); } public MyThread(ThreadGroup group, Runnable task, String name, long stackSize, boolean inheritInheritableThreadLocals) { super(group, task, name, stackSize, inheritInheritableThreadLocals); } }

Comments (5)

Popular
New
Old

You must be signed in to leave a comment

matemate123

Level 50 , Kraków, Poland

14 October 2023, 06:47

Last constructor is since java 9, try remove it, because course is on java 8 I think.

Amantai

Level 47 , Shymkent, Kazakhstan

14 October 2023, 12:50

I deleted the constructor with five parameters - points 3 and 4 did not work. I changed the code to the following:

private static AtomicInteger counter = new AtomicInteger(1);
private static AtomicInteger counter1 = new AtomicInteger(3);

public MyThread() {
    int temp = counter.getAndIncrement();
    for (int i = MIN_PRIORITY; i <= MAX_PRIORITY; i++) {
        if (i == temp)
            setPriority(i);
        if (i == MIN_PRIORITY && counter.get() > MAX_PRIORITY) {
            counter.set(1);
        }
    }
}

public MyThread(ThreadGroup group, String name) {
    super(group, name);

    int groupMaxPriority = getThreadGroup().getMaxPriority();
    int temp = counter1.getAndIncrement();

    for (int i = MIN_PRIORITY; i <= MAX_PRIORITY; i++) {
        if (i == temp && temp <= groupMaxPriority)
            setPriority(i);

        if (i == MIN_PRIORITY && temp > groupMaxPriority && temp <= MAX_PRIORITY)
            setPriority(groupMaxPriority);

        if (i == MIN_PRIORITY && counter1.get() > MAX_PRIORITY) {
            counter1.set(1);
        }

    }
}

Console output: 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 7 7 7 1 2 3 4 But points 3 and 4 do not work.

Thomas

Level 41 , Bayreuth, Germany

14 October 2023, 14:21

I also though you just need an explanation for the error and for that matemate123 gave an excellent reason. OK, you're supposed to set the priority for each new MyThread. You however do that just for two cases: a) the MyThread object gets created with a no args constructor b) or with the ThreadGroup, String constructor. What's with the other constructors? ThreadGroups: each thread is in a thread group. You don't need to explicitly specify one. Means you need to check that condition for each MyThread that's created. Best is to create a method that contains all the priority and group priority checking. You either call that method from each constructor or, if you're lazy, you use an instance block like:

{
    setInitialPriority();
}

Afaik the instance block is called right after the super call of the constructor. So exactly what you need and therefore no need to add additional code to each constructor. The setInitialPriorty method... you probably could synchronize the entire method as it multiple times accesses the priority field (4-5 times). Then you don't need an AtomicInteger anymore and a (one) normal int will do. What version is faster I don't know. That you'd need to test.

Amantai

Level 47 , Shymkent, Kazakhstan

14 October 2023, 18:01

solution

Before your comment, Thomas, I managed to write the following code (only point 3 failed):

private static AtomicInteger counter = new AtomicInteger(1);

public MyThread() {
    int temp = counter.getAndIncrement();
    if (counter.get() > MAX_PRIORITY) counter.set(1);

    for (int i = MIN_PRIORITY; i <= MAX_PRIORITY; i++) {
        if (i == temp)
            setPriority(i);
    }
}

public MyThread(ThreadGroup group, String name) {
    super(group, name);

    int groupMaxPriority = getThreadGroup().getMaxPriority();
    int temp = counter.getAndIncrement();
    if (counter.get() > MAX_PRIORITY) counter.set(1);

    for (int i = MIN_PRIORITY; i <= MAX_PRIORITY; i++) {
        if (i == temp && temp <= groupMaxPriority)
            setPriority(i);

        if (i == MIN_PRIORITY && temp > groupMaxPriority)
            setPriority(groupMaxPriority);
    }
}

After this unsuccessful code and mainly your explanation, the essence of the problem became clear. I passed verification following your advice. Thank you very much for the useful information!

Amantai

Level 47 , Shymkent, Kazakhstan

14 October 2023, 18:24

If anyone else is interested in this task. Based on the above code, I wrote a synchronized method, instead of AtomicInteger I used just an int and called this method in a block(but not in constructors), as Thomas advised.