相关疑难解决方法(0)

如果我在同一个类上同步两个方法,它们可以同时在同一个对象上运行吗？例如:

class A {
    public synchronized void methodA() {
        //method A
    }

    public synchronized void methodB() {
        // method B
    }
}

我知道我不能methodA()在两个不同的线程中对同一个对象运行两次.同样的事情methodB().

但是,在运行methodB()时我可以在不同的线程上methodA()运行吗？(同一个对象)

我知道同步方法和同步块之间的区别,但我不确定同步块部分.

假设我有这个代码

class Test {
  private int x=0;
  private Object lockObject = new Object();

  public void incBlock() {
    synchronized(lockObject) {
      x++;
    }
    System.out.println("x="+x);
  }

  public void incThis() {  // same as synchronized method
    synchronized(this) {
      x++;
    }
    System.out.println("x="+x);
  }
}

在这种情况下,使用lockObject和使用它作为锁有什么区别？对我来说似乎是一样的..

当您决定使用synchronized块时,如何确定哪个对象是锁？

Java中的synchronized方法和synchronized块之间有什么区别？

我一直在网上搜索答案,人们似乎对这一个如此不确定:-(

我的看法是两者之间没有区别,除了同步块可能在范围内更加局部化,因此锁定的时间会更短？

如果是静态方法上的Lock,那么Lock是什么？锁定类的含义是什么？

我的建筑师总是说

永远不要在布尔上同步

我无法理解其中的原因,如果有人可以用一个例子来解释为什么它不是一个好的做法,我会非常感激. 参考样本代码

private Boolean isOn = false;
private String statusMessage = "I'm off";
public void doSomeStuffAndToggleTheThing(){

   // Do some stuff
   synchronized(isOn){
      if(isOn){
         isOn = false;
         statusMessage = "I'm off";
         // Do everything else to turn the thing off
      } else {
         isOn = true;
         statusMessage = "I'm on";
         // Do everything else to turn the thing on
      }
   }
}

是java中的监视器不限制对实例变量的访问,而只限制对同步语句中声明为synchronized的方法或代码的访问？

我创建了两个线程,thread y调用sync方法,该方法在sync()调用未声明同步的unsync方法时声明为synchronized.两者都在共享对象上调用方法thread r.

unsync()能够修改对象的实例变量,s同时该对象的监视器或锁仍然被持有Thread r.

是Java中的监视器不限制对实例变量的访问,并且只限制声明为synchronized的方法或同步语句中的代码？

public class Stuff {

    private int a = 10;

    public synchronized void sync() {
        long t1 = System.currentTimeMillis();
        System.out.println("Okay, I am in sync() method. "
                        + "I will be waiting for 10 seconds. Current Time = "
                        + System.currentTimeMillis());
        while (System.currentTimeMillis() - t1 < 10000);
        System.out.println("Okay, I have waited for 10 seconds. Current time is "
                        + System.currentTimeMillis()
                        + ". Now I …

关于使用synchronizationin,我需要一些澄清multi-threaded environment.我在Class下面有一个小例子.但我实际上发现很难做出以下内容如何工作的测试用例; 我想要测试用例的原因是要了解如何synchronization处理这些不同的场景

• 如果一个thread电话SharedResource.staticMethod,将收购lock的class.意思了instance的SharedResource,说X,将不得不等待,直到它得到lock到exectute x.staticMethod.

• 会synchronization的this一个block,获取用于代码或整个该节的锁定object.即可以在另一个thread调用相同method的相同object; 但执行不属于的代码的其余部分synchronization block

• 如果以上观点属实,那么a dummy objectto lockon不会提供任何额外的好处.正确？

• 所以有不同的层次synchronziations.Class等级,Object等级和method等级block level.那么这意味着locks这些个人水平应该存在吗？如果我获得了一个锁定Object,另一个Thread无法调用任何methods上same object,但如果我获得了锁定method,另一个thread可以锁定另一个method …

我在类中有多个方法,大多数方法都有关键部分(共享数据).所以我把这些方法做成了同步.假设线程t1正在运行其中一个同步块.同时线程t2可以访问其他方法的关键部分吗？

class Sample{

synchronized public void method1(){

}

synchronized public void method2(){

}

synchronized public void method3(){

}

public void method4(){

}

}

在阅读线程中的并发问题并通过synchronized关键字处理它时,我想到的问题是,当我们使用术语时,lock它用于包含run方法(或线程的工作)的对象.但是为什么我们不能将该术语lock用于其定义包含synchronized关键字的方法,因为这个关键字意味着一旦线程进入该方法,那么该方法完成后该JVM调度程序只能干扰该线程？

我正在从第一个头java开始学习并且在那里写了"对象被锁定"的行,并且给出的理由再次以一种质疑的方式,即"如果我们有两个同步方法会发生什么".所以我在这里感到困惑如果只锁定方法会发生什么令人惊讶的事情呢？

如果我提出一个模糊的问题并提前致谢,请原谅我.

我有以下代码片段.

synchronized (mObject) {
    if (mObject.variable != -1) {
        doThis();
        doThisAsWell();
        andThis();
        insertObjectInDb(); // This is crashing because mObject.variable is -1
    }
}

据我所知,如果我在一个对象上使用synchronized,然后运行该块,那么任何其他线程都不能更改该变量的值,对吧？我不明白变量的值是-1,当我在进入下一个块之前专门检查它.不,该块中的所有功能都没有改变该值.我完全误解了这些块是如何工作的吗？

如果它很重要,那么这就是Android应用程序中异步任务的doInBackground()方法.

有任何想法吗？

我是并发新手,想问下面这个问题.我有以下课程:

public class MyClass{

    public synchronized void method1(){
         //do some
    }

    public synchronized void method2(){
         //do another some
    }
}

因此,只要了解某些线程何时开始执行其中一种方法,它就会获得锁定this.我的问题是,它是否意味着除非线程发布this,否则任何其他线程都不能执行同一对象的任何方法,如果要允许并发调用,我该怎么办？

在示例代码中

public class MsLunch {
private long c1 = 0;
private long c2 = 0;
private Object lock1 = new Object();
private Object lock2 = new Object();

public void inc1() {
    synchronized(lock1) {
        c1++;
    }
}

public void inc2() {
    synchronized(lock2) {
        c2++;
    }
}
}

在这个页面上,

lock1和lock2正在控制c1和c2上的更新.

然而,

    synchronized(lock2) 

获取对象lock1的锁定并在同步块时释放它

    synchronized(lock1) {
        c1++;
    }

被执行.

在执行此块时,仍然可以对此对象的成员c1进行更新 - 而且我没有看到如何通过在代码中同步lock1来阻止此更新.

对象lock1是否有独占访问权限 - …