在前两节的《Java多线程学习（一）——多线程基础》和《Java多线程学习（二）——Thread类的方法介绍》中我们接触了线程安全和非线程安全的概念，这节就来学习一下synchronized关键字的使用。
1、变量的线程安全性
“非线程安全”问题存在于“实例变量中”，如果是方法内部私有的变量，则不存在“非线程安全”的问题。如果两个线程同时操作对象中的实例变量，会出现非线程安全的问题，解决方法是在方法上添加添加synchronized关键字控制同步。
2、多个对象多个锁
先看代码：
public class HasSelfPrivateNum {
// 创建被同步关键字修饰的方法
private int num = 0;
synchronized public void add(String name){
try {
if ("a".equals(name)){
num = 100;
System.out.println("a set over");
Thread.sleep(2000);
}else {
num = 200;
System.out.println("b set over");
}
System.out.println(name + " num = " + num);
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
public class ThreadA extends Thread {
// 创建线程，构造器传参为上面方法的对象
private HasSelfPrivateNum hasSelfPrivateNum;
public ThreadA(String name, HasSelfPrivateNum hasSelfPrivateNum){
super();
this.hasSelfPrivateNum = hasSelfPrivateNum;
this.setName(name);
}
@Override
public void run() {
super.run();
hasSelfPrivateNum.add(this.getName());
}
}
// main方法和输出
public static void main(String[] args){
HasSelfPrivateNum hasSelfPrivateNum = new HasSelfPrivateNum();
HasSelfPrivateNum hasSelfPrivateNum1 = new HasSelfPrivateNum();
ThreadA threadA = new ThreadA("a", hasSelfPrivateNum);
ThreadA threadA1 = new ThreadA("b", hasSelfPrivateNum1);
threadA.start();
threadA1.start();
}
b set over
a set over
b num = 200
a num = 100
由于本实例创建了两个HasSelfPrivateNum对象，所以就会产生两个锁，所以运行的结果是异步的。
synchronized取得的锁都是对象锁，而不是把一段代码或方法当做锁。所以在上面的实例中，哪个线程先执行带synchronized关键字的方法，则哪个线程就持有该方法所属对象的锁Lock，那么其他线程只能呈等待状态，前提是多个线程访问的是同一个对象。但是如果多个线程访问多个对象，JVM会创建多个锁。
将main方向修改一下：
public static void main(String[] args){
HasSelfPrivateNum hasSelfPrivateNum = new HasSelfPrivateNum();
//HasSelfPrivateNum hasSelfPrivateNum1 = new HasSelfPrivateNum();
ThreadA threadA = new ThreadA("a", hasSelfPrivateNum);
ThreadA threadA1 = new ThreadA("b", hasSelfPrivateNum);
threadA.start();
threadA1.start();
}
----
a set over
a num = 100
b set over
b num = 200
可以看到threadA和threadA1拿到的是一个对象的锁，所以是顺序输出的。
3、synchronized方法与所对象
通过上面我们知道synchronized取得的锁都是对象锁，而不是把一段代码或方法当做锁。如果多个线程访问的是同一个对象，哪个线程先执行带synchronized关键字的方法，则哪个线程就持有该方法，那么其他线程只能呈等待状态。如果多个线程访问的是多个对象则不一定，因为多个对象会产生多个锁。
如果多个线程访问的是同一个对象中的未被synchronized关键字修饰的方法，线程会异步调用未被修饰的方法。
4、脏读
在赋值的时候进行了同步，但在取值的时候可能会出现一些意想不到的意外，这种情况就是脏读。发生脏读的情况是在读取实例变量的时候，此值已经被其他线程修改。
public class DirtyReadTest {
// 创建同步修改数据方法，非同步取数据方法
public String username = "A";
public String password = "AA";
synchronized public void setValue(String username, String password){
try {
this.username = username;
Thread.sleep(5000);
this.password = password;
System.out.println("setValue method: username = " + username + " password = " + password);
}catch (InterruptedException e){
e.printStackTrace();
}
}
public void getValue(){
System.out.println("getValue method: username = " + username + " password = " + password);
}
}
public class ThreadTest extends Thread {
private DirtyReadTest dirtyReadTest;
public ThreadTest(DirtyReadTest dirtyReadTest){
super();
this.dirtyReadTest=dirtyReadTest;
}
@Override
public void run() {
super.run();
dirtyReadTest.setValue("B", "BB");
}
}
输出：
public static void main(String[] args) throws Exception{
DirtyReadTest dirtyReadTest = new DirtyReadTest();
ThreadTest threadTest = new ThreadTest(dirtyReadTest);
threadTest.start();
Thread.sleep(200);
dirtyReadTest.getValue();
}
getValue method: username = B password = AA
setValue method: username = B password = BB
解决方法是在getValue方法上加上synchronized关键字。
当线程1调用一个对象的synchronized方法A时候，线程1就会获取该对象的锁，这是线程2是无法获取该对象的被synchronized修饰的任何方法，但是可以访问未被synchronized修饰的方法。
5、synchronized锁重入
在使用synchronized时，当一个线程得到一个对象的锁后，没有释放，再次请求该对象的锁是可以再次获取到的。一个对象中的synchronized修饰的方法可以访问该对象中其他被synchronized修饰的方法，如果不可重入锁会造成死锁。
测试方法：
public class Service {
synchronized public void service1(){
System.out.println("service1");
service2();
}
synchronized public void service2(){
System.out.println("service2");
service3();
}
synchronized public void service3(){
System.out.println("service3");
}
}
public class ThreadTest extends Thread {
@Override
public void run() {
super.run();
Service service = new Service();
service.service1();
}
}
public static void main(String[] args){
ThreadTest threadTest = new ThreadTest();
threadTest.start();
}
service1
service2
service3
可重入锁也支持在父子类继承的环境中，子类可以通过可重入锁调用父类的同步方法。这里不再写代码了，可以自行写一写。
6、出现异常，所自动释放
当一个线程执行的代码出现异常时，其所有的锁会自动释放。
7、同步不具有继承性
如果父类有一个带synchronized关键字的方法，子类继承并重写了这个方法。 但是同步不能继承，所以还是需要在子类方法中添加synchronized关键字。
本节代码的GitHub。
欢迎关注公众号：
