让我使用这个小而简单的示例:
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()
同时运行。
发布于 2011-05-03 04:11:37
对于此功能,最好根本不使用锁。尝试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);
}
}
不需要锁,代码更简单。在任何情况下,它都使用一个标准的结构来做你想要的事情。
发布于 2011-05-03 04:24:07
从Java1.5开始,考虑java.util.concurrent包总是一个好主意。它们是目前java中最先进的锁定机制。synchronize机制比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();
}
}
}
发布于 2011-05-03 04:05:30
使用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
方法可能会成为一个瓶颈-所有线程,即使它们想要调用该对象中可能交错的其他方法,也仍然必须等待。
在您的简单示例中,可以使用同步方法,因为您实际上有两个不应该交错的方法。但是,在不同的情况下,使用锁对象进行同步可能更有意义,如Joh Skeet的答案所示。
https://stackoverflow.com/questions/5861894
复制相似问题