Java锁(同步)全局变量

Question

我有一个代码

public class Exec {

    private String string = "";

    public void start() {
        MyThread t = new MyThread();
        MyThread2 t2 = new MyThread2();
        t.start();
        t2.start();
    }

    private class MyThread extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {

                string = "1";

                System.out.println(string);
                try {
                    sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private class MyThread2 extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {

                string = "2";

                System.out.println(string);
                try {
                    sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

没什么难的。2线程打印一个值。

产出：

1
2
1
2
1
...

如何锁定全局变量(资源)的问题？产出：

1
1
1
1
...
2
2
2
2
...

Answer 1

简单的解决方案是将start()更改为run()，因为您实际上不需要多个线程。

但是，您可以使用这个

synchronized(Exec.class) {

或

synchronized(System.out) {

作为一个共享的全局对象，或者可以传递这样的对象。

Answer 2

在启动第二个线程之前(或者在启动它之后，但在进入for循环之前)，您可以调用t.join()，直到t完成为止。

Answer 3

只需创建一个锁变量并锁定该变量。

public class Exec {

    private String string = "";
    private Object globalLock = new Object();  // The global lock  

    public void start() {
        MyThread t = new MyThread(globalLock);
        MyThread2 t2 = new MyThread2(globalLock);
        t.start();
        t2.start();
    }

    private class MyThread extends Thread {
        private Object lock;

        public MyThread(Object lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            synchronized(lock) {
                for (int i = 0; i < 10; i++) {
                    string = "1";
                    System.out.println(string);
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    private class MyThread2 extends Thread {
        private Object lock;

        public MyThread2(Object lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            synchronized(lock) {
                for (int i = 0; i < 10; i++) {
                    string = "2";
                    System.out.println(string);
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}