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

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

举例代码：

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离开

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

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