如何在Java中同步或锁定变量？

让我使用这个小而简单的示例：

class Sample {
    private String msg = null;

    public void newmsg(String x){
        msg = x;
    }

    public String getmsg(){
        String temp = msg;
        msg = null;
        return temp;
    }
}

假设该函数newmsg()由我无权访问的其他线程调用。

我想使用synchonize方法来确保该字符串msg每次仅由一个函数使用。换句话说，功能newmsg()不能与同时运行getmsg()。

那很简单：

class Sample {
    private String message = null;
    private final Object lock = new Object();

    public void newMessage(String x) {
        synchronized (lock) {
            message = x;
        }
    }

    public String getMessage() {
        synchronized (lock) {
            String temp = message;
            message = null;
            return temp;
        }
    }
}

请注意，我既没有使方法本身同步，也没有使之同步this。我坚信，除非您有意公开该锁，否则仅对只有您的代码才能访问的对象获取锁是个好主意。这样可以很容易地向自己保证，其他任何东西都不会以与您的代码不同的顺序获取锁，等等。

对于此功能，最好不要使用锁。尝试一个AtomicReference。

public class Sample {
    private final AtomicReference<String> msg = new AtomicReference<String>();

    public void setMsg(String x) {
        msg.set(x);
    }

    public String getMsg() {
        return msg.getAndSet(null);
    }
}

不需要锁，代码更简单，恕我直言。无论如何，它都使用标准构造来满足您的需求。

从Java 1.5开始，考虑使用java.util.concurrent包始终是一个好主意。它们现在是Java中最先进的锁定机制。同步机制比java.util.concurrent类的权重更大。

该示例将如下所示：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Sample {

    private final Lock lock = new ReentrantLock();

    private String message = null;

    public void newmsg(String msg) {
        lock.lock();
        try {
            message = msg;
        } finally {
            lock.unlock();
        }
    }

    public String getmsg() {
        lock.lock();
        try {
            String temp = message;
            message = null;
            return temp;
        } finally {
            lock.unlock();
        }
    }
}

在这个简单的示例中，您可以在两个方法签名中都放synchronized一个修饰符public。

更复杂的场景需要其他内容。

使用synchronized关键字。

class sample {
    private String msg=null;

    public synchronized void newmsg(String x){
        msg=x;
    }

    public synchronized string getmsg(){
        String temp=msg;
        msg=null;
        return msg;
    }
}

synchronized在方法上使用关键字将要求线程获取实例的锁sample。因此，如果有任何一个线程进入，则即使newmsg()其他线程sample正在尝试调用，也没有其他线程能够获得该实例的锁getmsg()。

另一方面，synchronized如果您的方法执行长时间运行的操作，则使用方法可能会成为瓶颈-所有线程，即使它们想调用该对象中可能交错的其他方法，也将不得不等待。

IMO，在您的简单示例中，可以使用同步方法，因为实际上您有两个不应交错的方法。但是，在不同的情况下，让锁对象进行同步可能更有意义，如Joh Skeet的回答所示。

如果在其他情况下要同步Collection而不是String，则可能是您正在迭代该集合，并担心它会发生变化，Java 5提供了：

• CopyOnWriteArrayList
• CopyOnWriteArraySet