关于线程锁的另外一个问题

多线程之间通过锁机制解决了共享资源的争夺，通常我们会使用某个具体的对象作为锁，那么，如果这个锁的值改变了？线程之间还会保持同步吗？

举例代码：

import java.util.Objects;

public class Operator {
    private String id;
    private String name;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Operator operator = (Operator) o;
        return Objects.equals(id, operator.id) &&
                Objects.equals(name, operator.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
}

这是一个很普通的Java类。

接下来是对这个类操作的service：

public class OperatorService {

    public void updateName(Operator operator) {
        synchronized(operator) {
            System.out.println("线程 ：" + Thread.currentThread().getName() + " 进入");
            System.out.println("operator对象name属性值:" + operator.getName());
            operator.setName("test" + Math.random());
            System.out.println("operator对象name属性值已更改:" + operator.getName());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "离开");
        }
    }
}

主运行入口：

public class Main {
    public static void main(String[] args) throws Exception {
        Operator operator = new Operator();
        operator.setId("123");
        operator.setName("123");

        OperatorService service = new OperatorService();

        new Thread(new ThreadA(operator, service)).start();
        new Thread(new ThreadB(operator, service)).start();

    }

    static class ThreadA implements Runnable{
        private Operator operator;
        private OperatorService service;

        public ThreadA(Operator operator, OperatorService service) {
            this.service = service;
            this.operator = operator;
        }

        @Override
        public void run() {
            service.updateName(operator);
        }
    }

    static class ThreadB implements Runnable{
        private Operator operator;
        private OperatorService service;

        public ThreadB(Operator operator, OperatorService service) {
            this.service = service;
            this.operator = operator;
        }

        @Override
        public void run() {
            service.updateName(operator);
        }
    }
}

这里的输出结果会是怎样的呢？输出结果如下：

线程 ：Thread-0 进入
operator对象name属性值:123
operator对象name属性值已更改:test0.49531243439875083
Thread-0离开
线程 ：Thread-1 进入
operator对象name属性值:test0.49531243439875083
operator对象name属性值已更改:test0.8638112164864292
Thread-1离开

虽然线程改变了锁的值，但是两个线程之间还是同步的。

总结：只要线程锁对象不变，锁对象的值改不改变，都不影响线程之间的同步效果。