How can global variables be shared in Java multi-threading?

In Java multi-threading, the following methods can be used to share global variables:

1. Using static variables: declare global variables as static variables so that they can be shared by all threads.

public class MyThread extends Thread {
    private static int globalVariable = 0;

    public void run() {
        // 访问和修改全局变量
        globalVariable++;
        System.out.println("Global variable: " + globalVariable);
    }
}

1. Utilizing shared objects: Create an object containing global variables and pass this object as a parameter to all threads. Threads can utilize this object to access and update global variables.

public class MyThread implements Runnable {
    private SharedObject sharedObject;

    public MyThread(SharedObject sharedObject) {
        this.sharedObject = sharedObject;
    }

    public void run() {
        // 访问和修改全局变量
        sharedObject.increment();
        System.out.println("Global variable: " + sharedObject.getVariable());
    }
}

public class SharedObject {
    private int variable = 0;

    public int getVariable() {
        return variable;
    }

    public void increment() {
        variable++;
    }
}

1. Using locking mechanism: acquire a lock before accessing global variables, and release the lock after modifying the global variables. This ensures that while one thread is modifying the global variable, other threads cannot access it simultaneously.

public class MyThread implements Runnable {
    private static int globalVariable = 0;
    private static Object lock = new Object();

    public void run() {
        synchronized (lock) {
            // 访问和修改全局变量
            globalVariable++;
            System.out.println("Global variable: " + globalVariable);
        }
    }
}

These methods ensure that multiple threads can safely share and modify global variables. However, it is important to note that when multiple threads are simultaneously modifying global variables, it may result in race conditions, leading to inconsistent or incorrect data. Therefore, it is necessary to use appropriate synchronization mechanisms to ensure thread safety when sharing global variables in multithreaded environments.