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

在前两节的《Java多线程学习（一）——多线程基础》和《Java多线程学习（二）——Thread类的方法介绍》中咱们接触了线程安全和非线程安全的概念，这节就来学习一下synchronized关键字的使用。

一、变量的线程安全性

“非线程安全”问题存在于“实例变量中”，若是是方法内部私有的变量，则不存在“非线程安全”的问题。若是两个线程同时操做对象中的实例变量，会出现非线程安全的问题，解决方法是在方法上添加添加synchronized关键字控制同步。

二、多个对象多个锁

先看代码：

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拿到的是一个对象的锁，因此是顺序输出的。

三、synchronized方法与所对象

经过上面咱们知道synchronized取得的锁都是对象锁，而不是把一段代码或方法当作锁。若是多个线程访问的是同一个对象，哪一个线程先执行带synchronized关键字的方法，则哪一个线程就持有该方法，那么其余线程只能呈等待状态。若是多个线程访问的是多个对象则不必定，由于多个对象会产生多个锁。

若是多个线程访问的是同一个对象中的未被synchronized关键字修饰的方法，线程会异步调用未被修饰的方法。

四、脏读

在赋值的时候进行了同步，但在取值的时候可能会出现一些意想不到的意外，这种状况就是脏读。发生脏读的状况是在读取实例变量的时候，此值已经被其余线程修改。

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修饰的方法。

五、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
复制代码

可重入锁也支持在父子类继承的环境中，子类能够经过可重入锁调用父类的同步方法。这里再也不写代码了，能够自行写一写。

六、出现异常，所自动释放

当一个线程执行的代码出现异常时，其全部的锁会自动释放。

七、同步不具备继承性

若是父类有一个带synchronized关键字的方法，子类继承并重写了这个方法。 可是同步不能继承，因此仍是须要在子类方法中添加synchronized关键字。

本节代码的GitHub。

---

欢迎关注公众号：