老师说：现实世界里，我们可以用多把锁来保护同一个资源，但在并发领域是不行的。
不能用两把锁锁定同一个资源吗？
如下代码：
public class X {
    private Object lock1 = new Object();
    private Object lock2 = new Object();
    private int value = 0;

    private void addOne() {
        synchronized (lock1) {
            synchronized (lock2) {
                value += 1;
            }
        }
    }

    private int get() {
        synchronized (lock1) {
            synchronized (lock2) {
                return value;
            }
        }
    }
}

虽然说这样做没有实际意义，但是也不会导致死锁或者其他不好的结果吧？请老师指导，谢谢。

相信很多人跟我一样会碰到这个问题,评论里也看到有人在问，内容有点长，辛苦老师帮忙大家分析下了 哈哈
  ---------------------------------------------------------
public class A implements Runnable {
    public Integer b = 1;
 
    @Override
    public void run() {
       System.out.println("A is begin!");
       while (true) {
               System.out.println("a");
           // System.out.println(b);
           if (b.equals(2))
              break;
       }
 
       System.out.println("A is finish!");
    }
 
    public static void main(String[] args) {
       A a = new A();
       //线程A
       new Thread(a).start();
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       a.b = 2;
    }
}
 
我们知道这个程序会出现可见性问题。
但是在while内加上System.out.println(b)后 当主线程修改b的值后 线程A居然能够取得最新值 可见性问题得到解决
System.out.println(b)的实现如下
    public void println(String x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
 
Doug Lea大神的Concurrent Programming in Java一书中有这样一个片段来描述synchronized这个关键字：
 
这里英文就不放出来了 字数超过两千……
这篇文章也有提及https://www.jianshu.com/p/3c06ffbf0d52
 
简单翻译一下：从本质上来说，当线程释放一个锁时会强制性的将工作内存中之前所有的写操作都刷新到主内存中去，而获取一个锁则会强制性的加载可访问到的值到线程工作内存中来。虽然锁操作只对同步方法和同步代码块这一块起到作用，但是影响的却是线程执行操作所使用的所有字段。


也就是说当调用System.out.println("a")时当前线程的缓存会被重新刷新过，所以才能够读到这个值最新值
 ---------------------------------------------------------
然后问题来了
问题1:
首先上面的说法不知道是不是真的是这样。
然后我在下面加了System.out.println(b) 结果打印出来的是旧值，但是下面的b.equals(2)却能通过 这里没弄明白 我觉得应该是编译器进行了优化?因为现在大三能力不够，还没学会看class文件 没法验证
 
问题2:
网上找了一些文章
有些人的说法是：打印是IO操作，而IO操作会引起线程的切换，线程切换会导致线程原本的缓存失效，从而也会读取到修改后的值。
 
我尝试着将打印换成File file = new File("D://1.txt");这句代码，程序也能够正常的结束。当然，在这里也可以尝试将将打印替换成synchronized(A.class){ }这句空同步代码块，发现程序也能够正常结束。
 
这里有个问题就是 线程切换时会把之前操作的相关数据保存到内存里，切换回来后会把内存里的数据重新加载到寄存器里吗，这样说的话 就算切换也是获取不到修改后的值的,不知道是什么做到能够读到这个修改后的值的？
 
问题3:
是不是
线程执行过程中，操作系统会随机性的把缓存刷到内存
线程结束后一定会把缓存里的数据刷到内存

 ---------------------------------------------------------
在评论里好多大神 能学到好多东西😄😄

不正确
使用锁保护资源时，对资源的所有操作应该使用同一个锁，这样才能起到保护的作用。
课后题中每个线程对资源的操作都是用的是各自的锁，不存在互斥和竞争的情况。
这就相当于有一个房间，每个人过来都安装一个门，每个人都有自己门的钥匙，大家都可以随意出入这个房间。
由于每个线程都可以随时进入方法，所以存在原子性问题；
但是因为每次都有加锁和解锁的操作，unlock操作会使其他缓存的变量失效，需要重新从主内存中加载变量的值，所以可以解决可见性问题。
如有错误，请老师指正。

老师，我觉得get方法有必要用加锁来保证可见性的另一个理由如下:
class SafeCalc {
    long value = 0L;

    synchronized long get() {
        return value;
    }

    synchronized void add(int i) {
        // 业务代码....假如这里比较耗时
        value += i;
    }
}

假如线程A执行add方法 当方法还没执行完
线程B执行get方法
如果get方法没有加锁 因为此时A正在修改这个数据 B获取的数据不是最新的

您看我说的对吗？还是说具体场景有不同的需求，有些还是允许这点延迟的？
本人大三，请前辈多指教😁😁谢谢

我理解get方法不需要加synchroized关键字，也可以保证可见性。
因为 对 value的写有被 synchroized 修饰，addOne（）方法结束后，会强制其他CPU缓存失效，从新从内存读取最新值！

class SafeCalc {
  long value = 0L;
  long get() {
    return value;
  }
  synchronized void addOne() {
    value += 1;
  }
}

class SafeCalc {
  static long value = 0L;
  synchronized long get() {
    return value;
  }
  synchronized static void addOne() {
    value += 1;
  }
}


get()方法的可见性不太理解为什么不能保证

老师，我有几个问题比较疑惑😄
---------------------------------------------
问题1:
synchronized void test() {
        //操作1
        value = value + 1;
         //业务方法....
        //操作2
         value = value + 2;
  }
为保证原子性，也就是value中间状态对外不可见，我觉得操作1完成后不会将最新值刷回内存,而是到解锁后才会将在synchronized块中操作的数据刷回内存！
 --------------------------------------------------
问题2：
有些同学说将value变量加volitile也可以实现同样效果.
我觉得不行，可见性保证了，原子性却会被破坏。理由如下:
基于问题1，假设操作1完成后不会将最新值刷回内存，那如果此时value变量加volitile上后，操作1完成后那岂不是会将这个中间值value存入内存?如果真是这样，原子性是保证不了的。
 ----------------------------------------------------
问题3:
volatile int x = 0：告诉编译器，对这个变量的读写，不能使用 CPU 缓存，必须从内存中读取或者写入。
 
Synchronized即保证可见性，又保证原子性。
那要保证可见性，在Synchronized块中是不是第一次读取到变量value时将直接从内存读，解锁时，将最新值刷回内存。


希望老师帮忙分析下 谢谢🙏🙏🙏