相关疑难解决方法(0)

在Java中有没有办法获得一个方法来锁定(互斥)它所在的对象？

我知道这听起来令人困惑,但基本上我对C#的这个片段并不公平,但在Java中.

lock(this)
{
    // Some code here...
}

我的任务是将用.Net编写的API重新实现到Java中,并且我被要求保持Java版本尽可能与.Net版本类似.事实上,.Net版本看起来像是从我无法访问的C++版本转录而来的.

无论如何,上面的行出现在C#版本中,我需要在Java中做同样的事情.

如何确保 initialize() 方法只被调用一次？下面是我想重构以使用 AtomicBoolean 的线程不安全版本。我想要的是 initialize() 只被调用一次

if (!initialized) 
{
   initialize();
   initialized = true;
}

我只需要如果将多个线程读取它来标记字段挥发的同时？

那么线程A改变字段值的场景怎么样呢？线程B在保证线程A完成之后对它进行评估呢？

在我的场景中,是否存在之前发生的关系(没有volatile关键字)？

在下面的示例中,锁定是在实例变量employee上获得的(不在此),但在进入synchronized块时,TestClass1的Threads仍然被锁定.任何建议为什么这种行为.据我所知,如果它同步就应该被锁定.

public class TestClass{
  public static void main(String args[]){
    TestClass1 obj = new TestClass1();
    Thread t1 = new Thread(obj, "T1");
    Thread t2 = new Thread(obj, "T2");
    t1.start();
    t2.start();
  }
}

class TestClass1 implements Runnable{

Employee employee = new Employee();

public void myMethod () {
    synchronized (employee) {
        try {
            Thread.sleep(4000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public void myOtherMethod() {
    synchronized (employee) {
        try {
            Thread.sleep(4000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

@Override
public …

以下是什么可以理解？
我在SO上经历过这篇文章,但仍然无法组装它.

代码1:

synchronized(this){ 
// some code
}

码2:

Object lock = new Object();

synchronized(lock){
// some code
}

任何教程,或一些解释同步的链接,就像他们向孩子解释一样？

问题:我必须创建5个线程,每个线程必须执行添加操作.

• Thread1 - 添加1到10
• Thread2 - 添加1到50
• Thread3 - 添加5到15
• Thread4 - 添加10到20
• Thread5 - 添加15到20

完成此任务的最佳方法是什么？此外,每次加法操作之间需要1秒的时间延迟.我写了这段代码:我的输出错了,每次都在改变.我知道问题是同步但不能解决.

class adding implements Runnable{
    int a,b; 
    public adding(int a, int b){
        this.a = a;
        this.b = b;
    }
    public void run() {
        add(a,b);
    }
    public void add(int a, int b){
        int sum=0;
        synchronized (this) {
            for(int i=a;i<=b;i++){
                sum = sum+ a;
            }
            System.out.println("Sum of "+a+" to "+ b+" numbers = "+sum);    
        }
    }
}

public class addnumbersusing5threads {
    public static void main(String[] args) …

我的一本教科书提到,synchronized()的参数必须是这个...我知道这是错误的.但我听说,由于synchronized(this)更安全,所以应该总是使用它.真的吗 ？谢谢:)

我知道synchronized关键字make方法一次只能在单个类上运行.但这是问题所在.

我有一个带有方法的数据库类,例如insertAccount,updateSetting等等.如果我制作insertAccount,updateSetting同步,它们中的每一个都只能在一个线程上运行.

如果有一个整个数据库的方法,它会很棒,但没有一个.如果一个线程调用insertAccount而另一个线程调用updateSetting 的同时,它会坏了吧？

因为这些方法中只有一种可以随时运行.那我该怎么办？

有没有办法应用类似synchronized全班的东西？因此,如果第一个线程同时调用insertAccount第二个线程并且第二个线程调用updateSetting,则第二个线程必须等到第一个线程完成访问数据库.

这可能是一个愚蠢的问题,我的Java只是简陋的概率:-(但我不明白为什么这有效(它实际上是Android代码,但我认为这是一般的Java问题).

我不明白该对象mySensorEventListener是如何被实际创建的？

• 我不明白下面的代码实际上是做什么的.
• 如何调用此代码???
• 什么时候叫???

这是我不理解的部分

public SensorListener mySensorEventListener = new SensorListener() {

    @Override
    public void onSensorChanged(int sensor, float[] values) {
        synchronized (this) {
        }
    }
    @Override
    public void onAccuracyChanged(int sensor, int accuracy) {
    }
};

这是它所属的android Activity:

public class RouteMapActivity extends Activity implements IRegisterReceiver {
private SensorManager mSensorManager;
private MapView mapView;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    mapView = new MapView(this, provider.getTileSource()
            .getTileSizePixels(), resProxy, provider);

    mSensorManager=(SensorManager)getSystemService(Context.SENSOR_SERVICE);
    mSensorManager.registerListener(mySensorEventListener,
            SensorManager.SENSOR_ORIENTATION,
            SensorManager.SENSOR_DELAY_FASTEST);

    setContentView(mapView);
}

public SensorListener mySensorEventListener = new …