Java 并发开发:内置锁 Synchronized

摘要:

在多线程编程中,线程安全问题是一个最为关键的问题,其核心概念就在于正确性,即当多个线程访问某一共享、可变数据时,始终都不会导致数据破坏以及其他不该出现的结果。而所有的并发模式在解决这个问题时,采用的方案都是序列化访问临界资源。在 Java 中,提供了两种方式来实现同步互斥访问:synchronized和 Lock。本文针对 synchronized 内置锁详细讨论了其在 Java 并发 中的应用,包括它的具体使用场景(同步方法、同步代码块、实例对象锁 和 Class 对象锁)、可重入性 和 注意事项。

一. 线程安全问题

在单线程中不会出现线程安全问题,而在多线程编程中,有可能会出现同时访问同一个 共享、可变资源 的情况,这种资源可以是:一个变量、一个对象、一个文件等。特别注意两点,

· 共享: 意味着该资源可以由多个线程同时访问;

· 可变: 意味着该资源可以在其生命周期内被修改。所以,当多个线程同时访问这种资源的时候,就会存在一个问题:由于每个线程执行的过程是不可控的,所以需要采用同步机制来协同对对象可变状态的访问。

举个 数据脏读 的例子:

//资源类

classPublicVar {

public String username = "A";

public String password = "AA";

//同步实例方法

public synchronized void setValue(String username, String password) {

try {

this.username = username;

Thread.sleep(5000);

this.password = password;

System.out.println("method=setValue " +"\t"

+ "threadName=" +Thread.currentThread().getName()

+ "\t" + "username=" + username + ",

password=" + password);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

//非同步实例方法

public void getValue() {

System.out.println("method=getValue " + "\t"

+ "threadName="+Thread.currentThread().getName()

+ "\t" + " username=" +username + ", password="

+ password);

}

}

//线程类

classThreadA extends Thread {

private PublicVar publicVar;

public ThreadA(PublicVarpublicVar) {

super();

this.publicVar = publicVar;

}

@Override

public void run() {

super.run();

publicVar.setValue("B", "BB");

}

}

//测试类

public class Test {

public static void main(String[] args) {

try {

//临界资源

PublicVar publicVarRef = newPublicVar();

//创建并启动线程

ThreadA thread = newThreadA(publicVarRef);

thread.start();

Thread.sleep(200);// 打印结果受此值大小影响

//在主线程中调用

publicVarRef.getValue();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}/* Output ( 数据交叉 ):

method=getValue threadName=main username=B,

password=AA

method=setValue threadName=Thread-0 username=B, password=BB

*///:~

由程序输出可知,虽然在写操作进行了同步,但在读操作上仍然有可能出现一些意想不到的情况,例如上面所示的 脏读。发生 脏读 的情况是在执行读操作时,相应的数据已被其他线程 部分修改 过,导致 数据交叉 的现象产生。

这其实就是一个线程安全问题,即多个线程同时访问一个资源时,会导致程序运行结果并不是想看到的结果。这里面,这个资源被称为:临界资源。也就是说,当多个线程同时访问临界资源(一个对象,对象中的属性,一个文件,一个数据库等)时,就可能会产生线程安全问题。

不过,当多个线程执行一个方法时,该方法内部的局部变量并不是临界资源,因为这些局部变量是在每个线程的私有栈中,因此不具有共享性,不会导致线程安全问题。

二. 如何解决线程安全问题

实际上,所有的并发模式在解决线程安全问题时,采用的方案都是 序列化访问临界资源 。即在同一时刻,只能有一个线程访问临界资源,也称作 同步互斥访问。换句话说,就是在访问临界资源的代码前面加上一个锁,当访问完临界资源后释放锁,让其他线程继续访问。

在 Java 中,提供了两种方式来实现同步互斥访问:synchronized 和 Lock。本文主要讲述 synchronized 的使用方法,Lock 的使用方法我的另一篇博文《Java 并发:Lock 框架详解》中阐述。

三. synchronized 同步方法或者同步块

在了解 synchronized关键字的使用方法之前,我们先来看一个概念:互斥锁,即 能到达到互斥访问目的的锁。举个简单的例子,如果对临界资源加上互斥锁,当一个线程在访问该临界资源时,其他线程便只能等待。

在 Java 中,可以使用 synchronized 关键字来标记一个方法或者代码块,当某个线程调用该对象的synchronized方法或者访问synchronized代码块时,这个线程便获得了该对象的锁,其他线程暂时无法访问这个方法,只有等待这个方法执行完毕或者代码块执行完毕,这个线程才会释放该对象的锁,其他线程才能执行这个方法或者代码块。

下面这段代码中两个线程分别调用insertData对象插入数据:

1) synchronized方法

public class Test {

public static void main(String[] args) {

final InsertData insertData = new InsertData();

// 启动线程 1

new Thread() {

public void run() {

insertData.insert(Thread.currentThread());

};

}.start();

// 启动线程 2

new Thread() {

public void run() {

insertData.insert(Thread.currentThread());

};

}.start();

}

}

classInsertData {

// 共享、可变资源

private ArrayList<Integer> arrayList = newArrayList<Integer>();

//对共享可变资源的访问

public void insert(Thread thread){

for(int i=0;i<5;i++){

System.out.println(thread.getName()+"在插入数据"+i);

arrayList.add(i);

}

}

}/* Output:

Thread-0在插入数据0

Thread-1在插入数据0

Thread-0在插入数据1

Thread-0在插入数据2

Thread-1在插入数据1

Thread-1在插入数据2

*///:~

根据运行结果就可以看出,这两个线程在同时执行insert()方法。而如果在insert()方法前面加上关键字synchronized 的话,运行结果为:

classInsertData {

private ArrayList<Integer> arrayList = newArrayList<Integer>();

public synchronized void insert(Thread thread){

for(int i=0;i<5;i++){

System.out.println(thread.getName()+"在插入数据"+i);

arrayList.add(i);

}

}

}/* Output:

Thread-0在插入数据0

Thread-0在插入数据1

Thread-0在插入数据2

Thread-1在插入数据0

Thread-1在插入数据1

Thread-1在插入数据2

*///:~

从以上输出结果可以看出,Thread-1插入数据是等 Thread-0 插入完数据之后才进行的。说明Thread-0 和 Thread-1 是顺序执行insert() 方法的。这就是 synchronized 关键字对方法的作用。

不过需要注意以下三点:

1)当一个线程正在访问一个对象的 synchronized 方法,那么其他线程不能访问该对象的其他 synchronized 方法。这个原因很简单,因为一个对象只有一把锁,当一个线程获取了该对象的锁之后,其他线程无法获取该对象的锁,所以无法访问该对象的其他synchronized方法。

2)当一个线程正在访问一个对象的 synchronized 方法,那么其他线程能访问该对象的非 synchronized 方法。这个原因很简单,访问非 synchronized 方法不需要获得该对象的锁,假如一个方法没用 synchronized 关键字修饰,说明它不会使用到临界资源,那么其他线程是可以访问这个方法的,

3)如果一个线程 A 需要访问对象object1 的 synchronized 方法 fun1,另外一个线程 B 需要访问对象 object2 的synchronized 方法 fun1,即使 object1和 object2 是同一类型),也不会产生线程安全问题,因为他们访问的是不同的对象,所以不存在互斥问题。

2) synchronized 同步块

synchronized 代码块类似于以下这种形式:

synchronized (lock){

//访问共享可变资源

...

}

当在某个线程中执行这段代码块,该线程会获取对象lock的锁,从而使得其他线程无法同时访问该代码块。其中,lock 可以是 this,代表获取当前对象的锁,也可以是类中的一个属性,代表获取该属性的锁。特别地, 实例同步方法 与 synchronized(this)同步块 是互斥的,因为它们锁的是同一个对象。但与 synchronized(非this)同步块 是异步的,因为它们锁的是不同对象。

比如上面的insert()方法可以改成以下两种形式:

// this 监视器

classInsertData {

private ArrayList<Integer> arrayList = newArrayList<Integer>();

public void insert(Thread thread){

synchronized (this) {

for(int i=0;i<100;i++){

System.out.println(thread.getName()+"在插入数据"+i);

arrayList.add(i);

}

}

}

}

// 对象监视器

classInsertData {

private ArrayList<Integer> arrayList = newArrayList<Integer>();

private Object object = new Object();

public void insert(Thread thread){

synchronized (object) {

for(int i=0;i<100;i++){

System.out.println(thread.getName()+"在插入数据"+i);

arrayList.add(i);

}

}

}

}

从上面代码可以看出,synchronized代码块比 synchronized方法 的粒度更细一些,使用起来也灵活得多。因为也许一个方法中只有一部分代码只需要同步,如果此时对整个方法用synchronized进行同步,会影响程序执行效率。而使用synchronized代码块就可以避免这个问题,synchronized代码块可以实现只对需要同步的地方进行同步。

3) class 对象锁

特别地,每个类也会有一个锁,静态的 synchronized方法 就是以Class对象作为锁。另外,它可以用来控制对 static 数据成员 (static数据成员不专属于任何一个对象,是类成员) 的并发访问。并且,如果一个线程执行一个对象的非static synchronized 方法,另外一个线程需要执行这个对象所属类的static synchronized 方法,也不会发生互斥现象。因为访问 staticsynchronized 方法占用的是类锁,而访问非 static synchronized 方法占用的是对象锁,所以不存在互斥现象。例如,

public class Test {

public static void main(String[] args) {

final InsertData insertData = new InsertData();

new Thread(){

@Override

public void run() {

insertData.insert();

}

}.start();

new Thread(){

@Override

public void run() {

insertData.insert1();

}

}.start();

}

}

classInsertData {

// 非 static synchronized 方法

public synchronized void insert(){

System.out.println("执行insert");

try {

Thread.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("执行insert完毕");

}

// staticsynchronized 方法

public synchronized static void insert1() {

System.out.println("执行insert1");

System.out.println("执行insert1完毕");

}

}/* Output:

执行insert

执行insert1

执行insert1完毕

执行insert完毕

*///:~

根据执行结果,我们可以看到第一个线程里面执行的是insert方法,不会导致第二个线程执行insert1方法发生阻塞现象。下面,我们看一下 synchronized 关键字到底做了什么事情,我们来反编译它的字节码看一下,下面这段代码反编译后的字节码为:

public class InsertData {

private Object object = new Object();

public void insert(Thread thread){

synchronized (object) {}

}

public synchronized void insert1(Thread thread){}

public void insert2(Thread thread){}

}

从反编译获得的字节码可以看出,synchronized代码块实际上多了 monitorenter 和monitorexit 两条指令。 monitorenter指令执行时会让对象的锁计数加1,而monitorexit指令执行时会让对象的锁计数减1,其实这个与操作系统里面的PV操作很像,操作系统里面的PV操作就是用来控制多个进程对临界资源的访问。对于synchronized方法,执行中的线程识别该方法的 method_info 结构是否有 ACC_SYNCHRONIZED 标记设置,然后它自动获取对象的锁,调用方法,最后释放锁。如果有异常发生,线程自动释放锁。

有一点要注意:对于synchronized方法 或者 synchronized代码块,当出现异常时,JVM会自动释放当前线程占用的锁,因此不会由于异常导致出现死锁现象。

四. 可重入性

一般地,当某个线程请求一个由其他线程持有的锁时,发出请求的线程就会阻塞。然而,由于 Java 的内置锁是可重入的,因此如果某个线程试图获得一个已经由它自己持有的锁时,那么这个请求就会成功。可重入锁最大的作用是避免死锁。例如:

public class Test implements Runnable {

// 可重入锁测试

public synchronized void get() {

System.out.println(Thread.currentThread().getName());

set();

}

public synchronized void set() {

System.out.println(Thread.currentThread().getName());

}

@Override

public void run() {

get();

}

public static void main(String[] args) {

Test test = new Test();

new Thread(test,"Thread-0").start();

new Thread(test,"Thread-1").start();

new Thread(test,"Thread-2").start();

}

}/* Output:

Thread-1

Thread-1

Thread-2

Thread-2

Thread-0

Thread-0

*///:~

五. 注意事项

1). 内置锁与字符串常量

由于字符串常量池的原因,在大多数情况下,同步synchronized代码块 都不使用 String 作为锁对象,而改用其他,比如 new Object() 实例化一个 Object 对象,因为它并不会被放入缓存中。看下面的例子:

//资源类

classService {

public void print(String stringParam) {

try {

synchronized (stringParam) {

while (true) {

System.out.println(Thread.currentThread().getName());

Thread.sleep(1000);

}

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

//线程A

classThreadA extends Thread {

private Service service;

public ThreadA(Serviceservice) {

super();

this.service = service;

}

@Override

public void run() {

service.print("AA");

}

}

//线程B

classThreadB extends Thread {

private Service service;

public ThreadB(Serviceservice) {

super();

this.service = service;

}

@Override

public void run() {

service.print("AA");

}

}

//测试

public class Run {

public static void main(String[] args) {

//临界资源

Service service = new Service();

//创建并启动线程A

ThreadA a = new ThreadA(service);

a.setName("A");

a.start();

//创建并启动线程B

ThreadB b = new ThreadB(service);

b.setName("B");

b.start();

}

}/* Output (死锁):

A

A

A

A

...

*///:~

出现上述结果就是因为String 类型的参数都是 “AA”,两个线程持有相同的锁,所以 线程B 始终得不到执行,造成死锁。进一步地,所谓死锁是指:

不同的线程都在等待根本不可能被释放的锁,从而导致所有的任务都无法继续完成。

b). 锁的是对象而非引用

在将任何数据类型作为同步锁时,需要注意的是,是否有多个线程将同时去竞争该锁对象:

1).若它们将同时竞争同一把锁,则这些线程之间就是同步的; 2).否则,这些线程之间就是异步的。

看下面的例子:

//资源类

classMyService {

private String lock = "123";

public void testMethod() {

try {

synchronized(lock) {

System.out.println(Thread.currentThread().getName() + " begin "

+System.currentTimeMillis());

lock = "456";

Thread.sleep(2000);

System.out.println(Thread.currentThread().getName()+ " end "

+System.currentTimeMillis());

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

//线程B

classThreadB extends Thread {

private MyService service;

public ThreadB(MyServiceservice) {

super();

this.service = service;

}

@Override

public void run() {

service.testMethod();

}

}

//线程A

classThreadA extends Thread {

private MyService service;

public ThreadA(MyServiceservice) {

super();

this.service = service;

}

@Override

public void run() {

service.testMethod();

}

}

//测试

public class Run1 {

public static void main(String[] args) throwsInterruptedException {

//临界资源

MyService service = new MyService();

//线程A

ThreadA a = new ThreadA(service);

a.setName("A");

//线程B

ThreadB b = new ThreadB(service);

b.setName("B");

a.start();

Thread.sleep(50);// 存在50毫秒

b.start();

}

}/* Output(循环):

A begin 1484319778766

B begin 1484319778815

A end 1484319780766

B end 1484319780815

*///:~

由上述结果可知,线程 A、B 是异步的。因为50毫秒过后, 线程B取得的锁对象是 “456”,而 线程A 依然持有的锁对象是 “123”。所以,这两个线程是异步的。若将上述语句“Thread.sleep(50);” 注释,则有:

//测试

public class Run1 {

public static void main(String[] args) throwsInterruptedException {

//临界资源

MyService service = new MyService();

//线程A

ThreadA a = new ThreadA(service);

a.setName("A");

//线程B

ThreadB b = new ThreadB(service);

b.setName("B");

a.start();

//Thread.sleep(50);// 存在50毫秒

b.start();

}

}/* Output(循环):

B begin 1484319952017

B end 1484319954018

A begin 1484319954018

A end 1484319956019

*///:~

由上述结果可知,线程 A、B 是同步的。因为线程 A、B 竞争的是同一个锁“123”,虽然先获得运行的线程将 lock 指向了 对象“456”,但结果还是同步的。因为线程 A 和 B 共同争抢的锁对象是“123”,也就是说,锁的是对象而非引用。

六. 总结

用一句话来说,synchronized内置锁 是一种 对象锁 (锁的是对象而非引用), 作用粒度是对象 ,可以用来实现对 临界资源的同步互斥访问 ,是 可重入 的。特别地,对于 临界资源 有:

· 若该资源是静态的,即被 static 关键字修饰,那么访问它的方法必须是同步且是静态的,synchronized块必须是 class锁;

· 若该资源是非静态的,即没有被 static 关键字修饰,那么访问它的方法必须是同步的,synchronized 块是实例对象锁;

实质上,关键字synchronized主要包含两个特征:

· 互斥性:保证在同一时刻,只有一个线程可以执行某一个方法或某一个代码块;

· 可见性:保证线程工作内存中的变量与公共内存中的变量同步,使多线程读取共享变量时可以获得最新值的使用。

原文发布于微信公众号 - java一日一条(mjx_java)

原文发表时间:2017-11-12

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏IT派

菜鸟用Python操作MongoDB,看这一篇就够了

MongoDB是由C++语言编写的非关系型数据库,是一个基于分布式文件存储的开源数据库系统,其内容存储形式类似JSON对象,它的字段值可以包含其他文档、数组及文...

951
来自专栏JavaEdge

开发人员必备Redis知识点基础命令键命令string命令hash结构listset结构sorted set

3116
来自专栏小樱的经验随笔

C/C++中int128的那点事

最近群友对int128这个东西讨论的热火朝天的。讲道理的话,编译器的gcc是不支持__int128这种数据类型的,比如在codeblocks 16.01/Dev...

2701
来自专栏微信公众号:Java团长

Java基础知识详细总结

ClassLoader使用的是双亲委托模型来搜索类的,每个ClassLoader实例都有一个父类加载器的引用(不是继承的关系,是一个包含的关系),虚拟机内置的类...

1233
来自专栏java一日一条

50个常见的 Java 错误及避免方法(第二部分)

System.out.println("Whatdo you want to do?");

1103
来自专栏chenssy

干货分享|Java异常经典14问,你都能答对吗?

异常是在程序执行期间可能发生的错误事件,并且会中断它的正常流程。异常可能来自不同类型的情况,例如用户输入的错误数据,硬件故障,网络连接故障等。

1032
来自专栏java一日一条

Java编程常见问题汇总1

每天在写Java程序,其实里面有一些细节大家可能没怎么注意,这不,有人总结了一个我们编程中常见的问题。虽然一般没有什么大问题,但是最好别这样做。另外这里提到的很...

822
来自专栏测试开发架构之路

堆和栈的区别

一、预备知识—程序的内存分配          一个由C/C++编译的程序占用的内存分为以下几个部分     1、栈区(stack)— 由编译器自动分配释放,存...

2858
来自专栏积累沉淀

Linux之grep和egrep命令总结

grep / egrep 语法: grep  [-cinvABC]  'word'  filename -c :打印符合要求的行数 -i :忽略大小写 ...

18510
来自专栏java初学

spring框架(1)— 依赖注入

46212

扫码关注云+社区