Thread: The yield() function in Java does not work.

I'm using Netbeans 6.9.1 on Ubuntu 10.04 x86 64 to work with Threads in Java. I'm having trouble with the yield() function because when I use it, the current thread continues to run instead of pausing and allowing other threads to execute.

The code below is a simple example copied from here (https://www.scaler.com/topics/yield-method-in-java/) of using yield to run two threads. Instead of running the first thread, printing one line, and then stopping it, the programme finishes thread 1 and then runs thread 2, since the yield method is not invoked. I tested this code on Windows and it works flawlessly! So I'm wondering if there are any issues with using this strategy on Ubuntu or 64bit systems.

//ThreadTest.java
public class ThreadTest extends Thread{
    public ThreadTest (String name){
        super(name);
    }
    public void run(){
        for (int i=0;i<5;i++){
            System.out.println(getName()+" - "+i);
            yield();
        }
        System.out.println(" END "+getName());
    }
}
 
//Main.java
public class Main {
   public static void main(String[] args) {
        ThreadTest t1 =new ThreadTest("Thread1");
        ThreadTest t2 =new ThreadTest("Thread2");
        t1.start();
        t2.start();
   }
}

Any suggestion, please?

It seems like you're experiencing an issue with the `yield()` method not functioning as expected in your Java threads on Ubuntu 10.04 x86 64. The `yield()` method is supposed to pause the currently executing thread to allow other threads of the same priority to execute, but you're observing that the current thread continues to run without yielding.

Firstly, let's address the specific issue you're encountering. The behavior you're observing might be due to differences in how the JVM (Java Virtual Machine) handles thread scheduling on different operating systems or architectures. While your code may work as expected on Windows, it appears to behave differently on Ubuntu 10.04 x86 64.

However, relying on `yield()` for thread synchronization and control is not recommended for most applications because it's non-deterministic and platform-dependent, as you're experiencing. Instead, you should consider using other mechanisms provided by the `java.util.concurrent` package, such as locks, semaphores, or explicit thread coordination using `wait()` and `notify()`.

For your specific code, if you want to ensure that the threads alternate execution, you can utilize `join()` method or `Thread.sleep()` method with proper synchronization to achieve the desired behavior.

Here's a modified version of your `ThreadTest` class using `sleep()` for demonstration:

```java
public class ThreadTest extends Thread {
private static Object lock = new Object(); // Lock for synchronization
private static int turn = 1; // Variable to control thread turn

public ThreadTest(String name) {
super(name);
}

public void run() {
synchronized (lock) {
for (int i = 0; i < 5; i++) {
// Check if it's this thread's turn
while (!getName().equals("Thread" + turn)) {
try {
lock.wait(); // Wait until it's this thread's turn
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(getName() + " - " + i);
turn = (turn == 1) ? 2 : 1; // Switch turn
lock.notifyAll(); // Notify other threads
}
System.out.println(" END " + getName());
}
}
}
```

In this modified version, each thread checks if it's its turn to execute. If not, it waits until it's notified. This ensures that the threads take turns executing. The `turn` variable controls which thread should execute next.

If you need further help with Java assignment, exploring different synchronization mechanisms and thread control techniques, such as the ones discussed here, can be quite beneficial. Additionally, seeking guidance from reputable educational resources, online assignment help services like ProgrammingHomeworkHelp.com or consulting with experienced professionals in the field could provide valuable insights to enhance your understanding.