导致线程安全问题的根本原因在于,存在多个线程同时操作一个共享资源,要想解决这个问题,就需要保证对共享资源访问的独占性,因此人们在Java中提供了synchronized关键字,我们称之为同步锁,它可以保证在同一时刻,只允许一个线程执行某个方法或代码块。
synchronized同步锁具有互斥性,这相当于线程由并行执行变成串行执行,保证了线程的安全性,但是损失了性能。下面我们先来看一下synchronized的使用方法。
synchronized 的使用方法
synchronized 的使用方法比较简单,修饰方式有如下两种。
- 作用在方法级别,表示针对m1()方法加锁,当多个线程同时访问m1()方法时,同一时刻只有一个线程能执行。
public synchronized void m1(){
//省略代码
}
作用在代码块级别,表示针对某一段线程不安全的代码加锁,只有访问到synchronized(this)这行代码时,才会去竞争锁资源。
public void m2( ){
synchronized(this){
//省略代码
}
}
了解了 synchronized的基本使用语法之后,我们来看如图所示的流程,它针对上面的案例增加了 synchronized 同步锁之后的执行流程。简单地说,当多个线程同时访问加synchronized关键字修饰的方法时,需要先抢占一个锁标记,只有抢到锁标记的线程才有资格调用incr()方法。这就使得在同一时刻只有一个线程执行i++操作,从而解决了原子性问题。
了解 synchronized 同步锁的作用范围
我们对一个方法增加synchronized关键字后,当多个线程访问该方法时,整个执行过程会变成串行执行,这种执行方式很明显会影响程序的性能,那么如何做好安全性及性能的平衡呢?
实际上,synchronized关键字只需要保护可能存在线程安全问题的代码,因此,我们可以通过控制同步锁的作用范围来实现这个平衡机制。在synchronized 中,提供了两种锁,一是类锁,二是对象锁。
类锁
类锁是全局锁,当多个线程调用不同对象实例的同步方法时会产生互斥,具体实现方式如下。
- 修饰静态方法:
public static synchronized void m1( ){
//省略代码
}
- 修饰代码块,synchronized 中的锁对象是类,也就是Lock.class。
public class Lock{
public void m2(){
synchronized(Lock.class){
//省略代码
}
}
}
下面这段程序使用类锁来实现跨对象实例,从而实现互斥的功能。
public class SynchronizedExample{
public void m1( ) {
synchronized(SynchronizedExample.class) {
while (true){
System.out.println("当前访问的线程:"+Thread.currentThread( ).getName());
try{
Thread.sleep(1000);
} catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
public static void main(String[] args){
SynchronizedExample se1=new SynchronizedExample();
SynchronizedExample se2=new SynchronizedExample();
new Thread(()->se1.m1(),"t1").start();
new Thread(()->se2.m1(),"t2" ).start();
}
}
- 该程序中定义了一个m1()方法,该方法中实现了一个循环打印当前线程名称的逻辑,并且这段逻辑是用类锁来保护的。
- 在 main()方法中定义了两个SynchronizedExample对象实例sel和se2,又分别定义了两个线程来调用这两个实例的m10方法。
根据类锁的作用范围可以知道,即便是多个对象实例,也能够达到互斥的目的,因此最终输出的结果是:哪个线程抢到了锁,哪个线程就持续打印自己的线程名称。
对象锁
对象锁是实例锁,当多个线程调用同一个对象实例的同步方法时会产生互斥,具体实现方式如下。
- 修饰普通方法:
public synchronized void m1( ){
//省略代码
}
- 修饰代码块,synchronized中的锁对象是普通对象实例。
public class Lock{
Object lock=new 0bject( ); public void m2( ){
synchronized(lock){
//省略代码
}
}
}
下面这段程序演示了对象锁的使用方法,代码如下。
public class SynchronizedForobjectExample {
Object lock=new 0bject();
public void m1( ){
synchronized (lock){
while(true){
System.out.println("当前获得锁的线程:"+Thread.currentThread().getName());
try{
Thread.sleep(1000);
} catch (InterruptedException e){
e.printStackTrace();}
}
}
}
public static void main(String[] args) {
SynchronizedFor0bjectExample se1=new SynchronizedForobjectExample();
SynchronizedForObjectExample se2=new SynchronizedForobjectExample();
new Thread(()->se1.m1(),"t1").start();
new Thread(()->se2.m1(),"t2" ).start();
}
}
我们先来看一下打印结果。
当前获得锁的线程:t1
当前获得锁的线程:t2
当前获得锁的线程:t2
当前获得锁的线程:t1
当前获得锁的线程:t1
当前获得锁的线程:t2
当前获得锁的线程:t1
当前获得锁的线程:t2
从以上结果中我们发现,对于几乎相同的代码,在使用对象锁的情况下,当两个线程分别访问两个不同对象实例的m10方法时,并没有达到两者互斥的目的,看起来似乎锁没有生效,实际上并不是锁没有生效,问题的根源在于synchronized(lock)中锁对象lock的作用范围过小。
Class是在JVM启动过程中加载的,每个.class文件被装载后会产生一个Class对象,Class对象在JVM进程中是全局唯一的。通过static修饰的成员对象及方法的生命周期都属于类级别,它们会随着类的定义被分配和装载到内存,随着类被卸载而回收。
实例对象的生命周期伴随着实例对象的创建而开始,同时伴随着实例对象的回收而结束。
因此,类锁和对象锁最大的区别是锁对象lock的生命周期不同,如果要达到多个线程互斥,那么多个线程必须要竞争同一个对象锁。
在上述代码中,通过Objectlock-new Object();构建的锁对象的生命周期是由Synchronized- ForObjectExample 对象的实例来决定的,不同的SynchronizedForObjectExample 实例会有不同的 lock锁对象,由于没有形成竞争,所以不会实现互斥的效果。如果想要让上述程序达到同步的目的,那么我们可以对lock锁对象增加.static关键字。
static Object lock=new 0bject();
最后,留下一个问题去思考,关于 synchronized 同步锁的思考?同步锁的核心特性是排他,要达到这个目的,多线程必须抢占同一个资源。。。。。。
文章评论