Java多线程学习（三）——synchronized（上）
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 overa set overb num = 200a 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 overa num = 100b set overb 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 = AAsetValue 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(); }
service1service2service3可重入锁也支持在父子类继承的环境中，子类可以通过可重入锁调用父类的同步方法。这里不再写代码了，可以自行写一写。
6、出现异常，所自动释放
当一个线程执行的代码出现异常时，其所有的锁会自动释放。
7、同步不具有继承性
如果父类有一个带synchronized关键字的方法，子类继承并重写了这个方法。 但是同步不能继承，所以还是需要在子类方法中添加synchronized关键字。
本节代码的GitHub。