正如所提到的,
Java语言还提供了另一种较弱的同步形式,即易失性变量,以确保对变量的更新可预测地传播到其他线程。
所以我的理解是
下面的代码使用锁(synchronized)提供(互斥+内存可见性),
public class SynchronizedInteger{
private int value;
public synchronized int get(){ return value; }
public synchronized void set(int value){ this.value = value; }
}
也可以使用volatile关键字
当多个线程可以访问成员变量时,我总是使用synchronized来保证te访问的安全性。
我在访问成员变量的方法中使用了它。
public synchronized void foo()
{
//do something with the member variable
}
否则,对成员的每次访问都会被synchronized包围。
synchronized(member)
{
//do something with the member here
}
我从不使用任何其他机制,如信号量和类似的多线程应用程序获得成员变量的安全访问,我想知道我是否忽略了什么,有一个严肃的理由,为什么我不应
给定以下代码:
public class Messager implements Runnable {
public static void main(String[] args) {
new Thread(new Messager("Wallace")).start();
new Thread(new Messager("Gromit")).start();
}
private String name;
在优秀的G4P of 生成的程序中,单词synchronized经常出现,如下面的代码片段所示,它复制了。基于这个例子,我打算在处理草图中使用两个窗口,在主窗口中显示纬度、经度和其他数据,在第二个窗口中显示天空中卫星的视图。主程序将设置一个卫星数据阵列,这些数据将被读取以在辅助窗口中显示。稍后,我将扩展该程序以记录旅途中的GPS数据,并制作天空图片和旅程的视频。(我在SuperBasic上做了一个类似的模拟辛克莱QL的项目,但这有一些缺点,我可以通过处理来克服)
我读过Java的 of synchronized,但不明白为什么会在这里应用。下面的草图和其他测试,无论是否使用该词,似乎都以相同的
我有一条等待的线索:
synchronized(sharedCounter) {
while(sharedCounter > 0) {
sharedCounter.wait(60000); //wait at most 1 minute
/*if it wakens from the end of the timeout, it should break the loop
or it could potentially restart the timeout*/
}
}
和一个线程,可以通知:
synchronized (sharedCounter)
我读过以下文章,并理解这一点:
实际上,同步将整个线程内存与“主”内存同步。
如果我有以下几点,我有疑问:
public class A {
int count;
public synchronized int methodA() {
return count++;
}
public int methodB() {
return count++;
}
}
methodA中的线程总是读取计数的最新值吗?或者因为methodB不同步而不能保证这一点?
我有一个用于多线程的静态HashMap<UUID, MyObject> ALL = new HashMap<>(); .
为了再现错误,我编写了以下代码:
HashMap<Integer, String> list = new HashMap<>();
list.put(1, "str 1");
list.put(2, "str 2");
new Thread(() -> {
while(true) {
ArrayList<String> val;
sy
我定义了一个具有许多“可观察”属性的类。在内部,类包含一个执行I/O的线程。
public class Foo {
private final PropertyChangeSupport support;
private State state;
public Foo() { this.support = new PropertyChangeSupport(this); }
public synchronized State getState() { return state; }
public synchronized void setState(State sta
我在一个类中有多个方法,并且大多数方法都有临界区(共享数据)。因此,我将这些方法设置为同步。假设线程t1正在运行其中一个synchronized块。同时线程t2可以访问其他方法的临界区吗?
class Sample{
synchronized public void method1(){
}
synchronized public void method2(){
}
synchronized public void method3(){
}
public void method4(){
}
}
我试着从下面的例子中理解关键字synchronized
Java Main方法-->
public int methodA(){
Hello h = new Hello();
h.callSomeSynchronizedMethod();
sysout("Main");
return 0;
}
在Hello类中-->
public synchronized void callSomeSynchronizedMethod(){
Hi h = new Hi();
h.someMethod();
sysout(&
我有以下代码:
public class State {
private List<Position> m_track;
public State() {
m_track = Collections.synchronizedList(new ArrayList<Position>());
}
public List<Position> getTrack() {
return m_track;
}
}
// in different class
public void modifyT
我在我的游戏中尝试使用多线程。然而,我似乎无法摆脱睡眠。
如果我不这样做,它是一个空白屏幕,因为计算机没有时间实际呈现triangleMob,因为它无法访问getArrayList(),在我的主类中,我有一个TriangleMob数组。如果我延迟了它,那么它可以访问previousMob并呈现。如果我不知道,那就是空白屏幕。
我能摆脱延误吗?而且,这是多线程的坏方法吗?
当然,这应该很快。我需要多线程,所以请不要建议不要使用它。
public class TriangleMob extends Thread implements Runnable {
private stat
我想验证我编写的以下测试,以验证两个线程可以同时访问静态同步方法和非静态同步方法(因为锁位于不同的对象上)。我得到了一个结果,但我想知道我的解释是否正确
我运行了下面的代码,我看到变量i分别从静态方法和非静态方法中打印出相同的值。这是一个有效的证据,证明静态和非静态方法在两个不同的对象上都有锁,并且两个线程可以同时访问它们。
代码
import java.util.ArrayList;
import java.util.List;
public class TestStaticSynchronize {
public static final TesteeClass obj = new T
因此,对于这个任务,我必须模拟电梯。现在,我生成了3个人,他们是在随机的楼层上产生的,并且有一个随机的目的地楼层。我有一部电梯来接他们。我遇到的问题是电梯一次只能处理一个人。我不知道怎么做才能让电梯停在有人的楼层。例如:
人1的起始层是3,是8人2的起始层是9,是10人3的起始层是6,是9
按照目前的工作方式,电梯先到3层,然后再到8层,没有在6楼为3个人停下来。我不知道如何解决这个问题。
电梯在楼层之间移动的代码如下所示:
public void moveTo(int floor) throws InterruptedException
{
int distance;
sy
我对多线程非常陌生。我目前正在处理一个项目,该项目需要启动一个线程,并在完成后通知启动它的线程并继续其执行。我尝试使用一个布尔变量,并指示系统打印出一些字符串来指示操作的阶段。找到下面的代码
public class BankDatabaseSQL {
private Connection connection;
private ResultSet resultSet;
private static final String URL = "jdbc:mysql://localhost/banktesting";
private static final String USER
Multi-Threading.中的I found that declaring a variable as static makes no sense我想,这是因为every thread has its own stack。这是唯一的原因吗?
我知道static variables should be used within synchronized block。但是为什么呢?