Java多线程学习（三）——synchronized（上）

在前两节的《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。

---

欢迎关注公众号：

公众号微信