相关疑难解决方法(0)

我对synchronized关键字的用法和重要性有一些疑问.

• synchronized关键字有什么意义？
• 方法何时应该synchronized？
• 这在编程和逻辑上意味着什么？

任何人都可以通过一个例子告诉我同步方法优于synchronized块的优势吗？

java.util.concurrentAPI提供了一个名为as的类Lock,它基本上将序列化控件以访问关键资源.它给出了诸如park()和的方法unpark().

我们可以做类似的事情,如果我们可以使用synchronized关键字,并使用wait()和notify() notifyAll()方法.

我想知道其中哪一个在实践中更好,为什么？

我有2个矩阵,我需要将它们相乘,然后打印每个单元格的结果.一旦一个单元格准备就绪,我需要打印它,但是例如我需要在单元格[2] [0]之前打印[0] [0]单元格,即使[2] [0]的结果已经准备好了.所以我需要按顺序打印它.所以我的想法是让打印机线程等待,直到multiplyThread通知它正确的单元格已准备好打印,然后printerThread将打印单元格并返回等待等等.

所以我有这个线程来进行乘法运算:

public void run() 
{
    int countNumOfActions = 0; // How many multiplications have we done
    int maxActions = randomize(); // Maximum number of actions allowed

    for (int i = 0; i < size; i++)
    {       
        result[rowNum][colNum] = result[rowNum][colNum] + row[i] * col[i];
        countNumOfActions++;
        // Reached the number of allowed actions
        if (countNumOfActions >= maxActions)
        {
            countNumOfActions = 0;
            maxActions = randomize();
            yield();
        }   
    }
    isFinished[rowNum][colNum] = true;
    notify();
}

打印每个单元格结果的线程:

public …

在Java中,在代码中声明关键部分的惯用方法如下:

private void doSomething() {
  // thread-safe code
  synchronized(this) {
    // thread-unsafe code
  }
  // thread-safe code
}

几乎所有的块都同步 this,但是有什么特别的原因吗？还有其他可能吗？是否有关于同步对象的最佳实践？(比如私人实例Object？)

我正在研究java线程和死锁,我理解死锁的例子,但我想知道是否有一般规则要遵循以防止它.

我的问题是,是否有规则或技巧可以应用于java中的源代码以防止死锁？如果是,您能解释一下如何实施吗？

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

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

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

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

我有一个多线程Java代码,其中:

• 几个线程从同步的共享存储中读取有状态对象(即,因此,某些线程可能引用相同的对象);
• 然后每个线程调用一个方法process()并将其对象传递给那里;
• process() 以某种方式处理对象,这可能导致更改对象状态;
• 这些状态变化应该同步.

我创建了一个这样的方法:

public void process(Foo[] foos) {
    for (final Foo foo : foos) {
        if (foo.needsProcessing()) {
            synchronized (foo) {
                foo.process();  // foo's state may be changed here
            }
        }
    }
}

据我所知,这看起来很合法.然而,的IntelliJ的检查会抱怨局部变量的同步,因为"不同的线程很可能有不同的本地实例"(这是不是适用于我,因为我不是在方法的初始化的Foo).

基本上我想在这里实现的是与方法Foo.process()同步(这不是我的选项,因为Foo是第三方库的一部分).

我习惯了没有黄色标记的代码,所以社区的任何建议都值得赞赏.在本地人做同步真的很糟糕吗？有没有替代方案可以适用于我的情况？

提前致谢!

在什么情况下需要同步访问实例成员？我理解,对类的静态成员的访问总是需要同步 - 因为它们在类的所有对象实例之间共享.

我的问题是,如果我不同步实例成员,我什么时候会不正确？

例如,如果我的班级是

public class MyClass {
    private int instanceVar = 0;

    public setInstanceVar()
    {
        instanceVar++;
    }

    public getInstanceVar()
    {
        return instanceVar;
    }
}

在什么情况下(使用类MyClass)我需要有方法: public synchronized setInstanceVar()和 public synchronized getInstanceVar()？

提前感谢您的回答.

我读到了synchronized(this)应该避免的各种原因.然而,我遇到的一些可敬的代码在构造函数中使用以下代码:

public SomeClass(Context context) {
  if (double_checked_lock == null) {
    synchronized (SomeClass.class) {
      if (double_checked_lock == null) {
        // some code here
      }
    }
  }
}

是否真的之间的差异synchronized(this)和synchronized(SomeClass.class)？