在前两节的《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 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拿到的是一个对象的锁,所以是顺序输出的。
通过上面我们知道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 = AAsetValue method: username = B password = BB
解决方法是在getValue方法上加上synchronized关键字。
当线程1调用一个对象的synchronized方法A时候,线程1就会获取该对象的锁,这是线程2是无法获取该对象的被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(); }
service1service2service3
可重入锁也支持在父子类继承的环境中,子类可以通过可重入锁调用父类的同步方法。这里不再写代码了,可以自行写一写。
当一个线程执行的代码出现异常时,其所有的锁会自动释放。
如果父类有一个带synchronized关键字的方法,子类继承并重写了这个方法。 但是同步不能继承,所以还是需要在子类方法中添加synchronized关键字。
本节代码的GitHub。