相关疑难解决方法(0)

如果我在同一个类中有2个同步方法,但每个方法访问不同的变量,那么2个线程可以同时访问这两个方法吗？锁是否发生在对象上,或者它是否与synchronized方法中的变量一样具体？

例:

class X {

    private int a;
    private int b;

    public synchronized void addA(){
        a++;
    }

    public synchronized void addB(){
        b++;
    }

}

2个线程可以同时访问同一个X类实例x.addA()x.addB()吗？

我遇到过以下几次代码

class Foo {
   private Object lock = new Object();

   public void doSomething() {
      synchronized(lock) {
         ...

我感兴趣的是为什么创建一个锁对象而不是写synchronized(this)？是否可以共享锁定？我依稀记得读到这是一个优化.真的吗？另外,在某些情况下,将锁定声明为有意义final吗？

import java.math.BigInteger;

class Numbers {

    final static int NUMBER = 2;
    final static int POWER = 4;

    static long msecs;
    static BigInteger result;
    static Boolean done = false;

    public static void main(String[] args) {

        BigInteger number = BigInteger.valueOf(NUMBER);
        result = number;

        //Boolean done = false;

        Runnable pow = () -> {
            System.out.println(number + " pow " + POWER + " = " + number.pow(POWER));

            synchronized (done) {
                done = true;
                done.notifyAll();
            }
        };

        Runnable sum = () -> {
            for(int …

有什么区别:

public synchronized void test(){}

和

public void test() {
   synchronized(Sample.class){}
}

在示例代码中

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是否有独占访问权限 - …