标签: synchronized

假设我在某个类上有一个synchronized方法:

abstract class Foo {
    public synchronized void foo() {  // synchronized!
        // ...
    };
}

并且我在不使用synchronized修饰符的情况下覆盖它:

class Bar extends Foo {
    @Override
    public void foo() {               // NOT synchronized!
        super.foo();
        // ...
    }
 }

关于这种情况,我有几个具体的问题:

1. 被覆盖的方法也会被隐式同步吗？
2. 如果没有,super-call会同步吗？
3. 如果没有super-call,是否会同步？
4. 有没有办法强制使用重写方法synchronized(我注意到接口内的抽象方法定义或方法定义不允许使用synchronized关键字)？

我有一个webapp,我正在进行一些负载/性能测试,特别是在我们希望有几百个用户访问同一页面并在此页面上每10秒点击一次刷新的功能.我们发现我们可以使用此功能进行改进的一个方面是在一段时间内缓存来自Web服务的响应,因为数据没有变化.

在实现这个基本缓存之后,在一些进一步的测试中,我发现我没有考虑并发线程如何同时访问Cache.我发现在大约100毫秒内,大约有50个线程试图从缓存中获取对象,发现它已经过期,命中Web服务以获取数据,然后将对象放回缓存中.

原始代码看起来像这样:

private SomeData[] getSomeDataByEmail(WebServiceInterface service, String email) {

  final String key = "Data-" + email;
  SomeData[] data = (SomeData[]) StaticCache.get(key);

  if (data == null) {
      data = service.getSomeDataForEmail(email);

      StaticCache.set(key, data, CACHE_TIME);
  }
  else {
      logger.debug("getSomeDataForEmail: using cached object");
  }

  return data;
}

因此,为了确保在对象key过期时只有一个线程正在调用Web服务,我认为我需要同步Cache get/set操作,并且似乎使用缓存键是一个很好的候选对象同步(这样,对电子邮件b@b.com的此方法的调用不会被方法调用a@a.com阻止).

我将方法更新为如下所示:

private SomeData[] getSomeDataByEmail(WebServiceInterface service, String email) {


  SomeData[] data = null;
  final String key = "Data-" + email;

  synchronized(key) {      
    data =(SomeData[]) StaticCache.get(key);

    if (data == null) {
        data = service.getSomeDataForEmail(email); …

我在java中看到了一些例子,他们在一块代码上做同步来改变一些变量,而这个变量最初被声明为volatile.我在单例类的一个例子中看到,他们将唯一的实例声明为volatile并且他们同步了块初始化那个实例...我的问题是为什么我们在同步它时声明它是不稳定的,为什么我们需要同时做两个？对其他人来说不是其中之一吗？

public class someClass {
volatile static uniqueInstance = null;

public static someClass getInstance() {
        if(uniqueInstance == null) {
            synchronized(someClass.class) {
                if(uniqueInstance == null) {
                    uniqueInstance = new someClass();
                }
            }
        }
        return uniqueInstance;
    }

提前致谢.

在Java中,如果同步方法包含对非同步的调用,那么另一种方法是否仍然可以同时访问非同步方法？基本上我要问的是同步方法中的所有东西都锁定它(包括调用其他同步方法)？非常感谢

我正在建模一个游戏,其中多个玩家(线程)同时移动.此时玩家所处位置的信息被存储两次:玩家有一个变量"hostField",它引用棋盘上的一个字段,每个字段都有一个ArrayList,用于存储当前位于该字段的玩家.

对于我有冗余信息这一事实,我不是很满意,但是如果没有循环遍历大数据集,我发现没有办法避免这种情况.

然而,当玩家从一个领域移动到另一个领域时,我想确保(1)冗余信息保持联系(2)此刻没有其他人在操纵该领域.

所以我需要做点什么

synchronized(player, field) {
    // code
}

哪个不可能,对吧？

我该怎么办？:)

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

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

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

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

尝试可视化和理解同步.

1. 对同步块使用静态锁定对象(代码A)和非静态锁定对象(代码B)有什么区别？
2. 它在实际应用中有何不同？
3. 另一个不会有什么陷阱？
4. 确定使用哪一个的标准是什么？

代码A.

public class MyClass1 {
  private static final Object lock = new Object();
  public MyClass1() {
    //unsync
    synchronized(lock) {
      //sync
    }
    //unsync
  }
}

代码B.

public class MyClass2 {
  private final Object lock = new Object();
  public MyClass2() {
    //unsync
    synchronized(lock) {
      //sync
    }
    //unsync
  }
}

注意

上面的代码显示了构造函数,但您可以在静态方法和非静态方法中讨论行为的不同之处.另外,当synchronized块修改静态成员变量时,使用静态锁是否有利？

我已经在这个问题中查看了答案,但不清楚不同的使用场景是什么.

我一直认为在实现Runnable的java类中同步run方法是多余的.我试图找出人们为什么这样做:

public class ThreadedClass implements Runnable{
    //other stuff
    public synchronized void run(){
        while(true)
             //do some stuff in a thread
        }
    }
}

它似乎是多余的和不必要的,因为它们正在为另一个线程获取对象的锁.或者更确切地说,他们明确表示只有一个线程可以访问run()方法.但是由于它的run方法,它本身不是自己的线程吗？因此,只有它可以访问自己,它不需要一个单独的锁定机制？

我在网上发现了一个建议,通过同步run方法,你可以创建一个事实上的线程队列,例如:

 public void createThreadQueue(){
    ThreadedClass a = new ThreadedClass();
    new Thread(a, "First one").start();
    new Thread(a, "Second one, waiting on the first one").start();
    new Thread(a, "Third one, waiting on the other two...").start();
 }

我个人永远不会这样做,但它提出了为什么有人会同步run方法的问题.任何想法为什么或为什么不应该同步run方法？

Java中同步方法和同步块的主要思想是什么？

我们为什么要使用它们？

示例代码会很好.我已经阅读了有关同步方法的Java文档,但我没有理解.

这是Java文档代码

public class SynchronizedCounter {
    private int c = 0;

    public synchronized void increment() {
        c++;
    }

    public synchronized void decrement() {
        c--;
    }

    public synchronized int value() {
        return c;
    }
}

我是Java的新手,我读到Java中synchronized的"非常昂贵".我想知道的是什么是昂贵的,它是如何昂贵的？

谢谢.