Java - 如何为多线程同步运行 function

Question

I must use three instances of the Runnable class named changeCase and only one single instance of the Server class for all three changeCase instances. The process execution needs to run continously, that is why I have used while (true) inside the overridden run method. The process method execution for each Thread is overlapping. How can I solve this issue?

My code:

package uppercase;

import java.util.Scanner;

class Server {

    void process(String threadName) {

        System.out.println("You are inside the Server " +threadName);

        System.out.println("Enter your sentence");
        Scanner sc1 = new Scanner(System.in);
        String input = sc1.nextLine();

        System.out.println("Press 1 to convert to Uppercase or Press 2 to convert to Lowercase");
        Scanner sc2 = new Scanner(System.in);
        int num = sc2.nextInt();

        switch (num) {
            case 1:
                changetoUpperCase(input);
                break;
            case 2:
                changetoLowerCase(input);
                break;
            default:
                System.out.println("Invalid number given\n\n");
                break;
        }
    }

    void changetoUpperCase(String msg) {

        printMessage(msg.toUpperCase());
    }

    void changetoLowerCase(String msg) {

        printMessage(msg.toLowerCase());
    }

    void printMessage(String msg) {

        System.out.println("[ " +msg+ " ]\n\n");

        try {
            Thread.sleep(1000);
        }catch (Exception e) {
           System.out.println(e.getMessage());
        }
    }
}

class changeCase implements Runnable {

    String threadName;
    Server target;
    Thread t;

    public changeCase(Server c, String s) {

        this.threadName = s;
        this.target = c;
    }

    @Override
    synchronized public void run() {

        while(true) {

            target.process(threadName);
        }

        //target.process(threadName);
    }

}

public class UpperCase {

    public static void main(String[] args) {

        Server s1 = new Server();

        Thread t1 = new Thread(new changeCase(s1, "Thread1"));
        Thread t2 = new Thread(new changeCase(s1, "Thread2"));
        Thread t3 = new Thread(new changeCase(s1, "Thread3"));

        t1.start();
        t2.start();
        t3.start();
    }

}

The output I need:

run:
You are inside the Server Thread1
Enter your sentence
hello world
Press 1 to convert to Uppercase or Press 2 to convert to Lowercase
1
[ HELLO WORLD ]


You are inside the Server Thread3
Enter your sentence
HELLO WORLD
Press 1 to convert to Uppercase or Press 2 to convert to Lowercase
2
[ hello world ]


You are inside the Server Thread2
Enter your sentence
hello world
Press 1 to convert to Uppercase or Press 2 to convert to Lowercase
4
Invalid number given


You are inside the Server Thread3
Enter your sentence

The output I am getting:

run:
You are inside the Server Thread1
Enter your sentence
You are inside the Server Thread2
Enter your sentence
You are inside the Server Thread3
Enter your sentence

Answer 1

Declare your method as below and it should work just fine.

    @Override
    public void run() {

        while(true) {
            synchronized (target)
            {
                target.process(threadName);
                try {
                    target.wait();
                    notifyAll();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

Since you do not want to make process() method as synchronized , so I placed synchronized keyword in run() method.

Why it should work just fine :

• The synchronised around the process() method call, allows only one Thread to access it at a time.
• Passing the target object in synchronized keyword as that is the resource that threads are working on.
• Once you have utilised the resource ie the process() method is executed, need to wait() on the current Thread processing and notifyAll() other threads to take ownership.
• Calling target.wait() and not simply wait() because that uis the resource that threads are working on, otherwise it will throw java.lang.IllegalMonitorStateException: current thread is not owner .

Hope it answers your query.

You can go through some resources here. https://www.geeksforgeeks.org/synchronized-in-java/

Answer 2

You can use a counter to make thread execute one by one.

class Server {
int threadCount = 3;
volatile int i = 1;

synchronized void process(String threadName) {
    int thread = Integer.parseInt(threadName.substring(threadName.length() - 1));
    if (thread % threadCount != i) {
        return;
    }
    i = i == threadCount - 1 ? 0 : i + 1;

    System.out.println("You are inside the Server " + threadName);

    System.out.println("Enter your sentence");
    Scanner sc1 = new Scanner(System.in);
    String input = sc1.nextLine();
...