synchronized 同步锁(Java)

时间:2024-03-24 09:20:01

 引言

在多线程应用场景中,同步锁是一种非常重要的机制,例如:ID号的分配,多个客户端分别与服务端建立连接,客户端并发请求的情况下,为提升吞吐量,服务端一般采用多线程处理请求,若无同步锁机制,不同线程分配到相同ID号的情况将不可避免,而这种情况与预期相违背。在现实中是有许许多多的例子的,比较典型的有购票,抽奖等。


java 同步锁机制介绍

java同步锁的关键字为:synchronized,其应用主要有两种方式:[synchronized 方法]和[synchronized 块],顾名思义,其区别在于作用范围不同,以下分别对两种方式进行介绍,首先我们看一个例子类:

public class TestForSynchronized 
{
	static int ID=0;
	//测试方法01-synchronized块(对象级)
	public String setID_01()
	{
		 synchronized(this)
		 {
			ID++;			
			return "setID_01() ID No.:"+ID;
		 }			
	}
	
	//测试方法02-synchronized块(类级别)
	public String setID_02()
	{
		 synchronized(TestForSynchronized.class)
		 {
			ID++;			
			return "setID_02() ID No.:"+ID;
		 }		
	}
	
	//测试方法03-synchronized 方法
	public synchronized String setID_03()
	{		
		ID++;			
		return "setID_03() ID No.:"+ID; 		
	}
	
	//普通方法
	public  String commonMethod()
	{
		return "commonMethod ID No."+ID;
	}	
}

如上程序所示,分别体现了synchronized块(对象级别和类级别),synchronized方法,普通方法的定义方式。

synchronized 方法

通过在方法的定义中加入synchronized关键字来定义synchronized方法,例如:
public synchronized String setID(),这就是一个返回值为String类型的synchronized方法,对于一个应用了synchronized机制的类来说,以上面定义的类TestForSynchronized 为例,它的每一个实例(对象)都具有单一的锁,当通过这个(实例)对象调用它的任何synchronized方法,或者这个实例(对象)执行synchronized块的时候,这个实例(对象)就会被加锁,即:

 

  • 在多线程场景下,对于某一个类实例(对象)tempObject,如果多个线程并发通过tempObject访问其synchronized方法或者synchronized块时,任何一个时刻只有一个线程处于可执行状态,因为同一时刻只有一个线程能够获取该实例的唯一的锁,其它线程都会被阻塞,直到synchronized方法返回或者synchronized块执行完毕,锁才会被占用的线程释放,此前被阻塞的线程才有机会获得该对象的锁;
  • 在多线程场景下,对于某一个类实例(对象)tempObject,如果一个线程获得tempObject的锁,在一个synchronized方法返回或者一个synchronized块执行完毕后,便会将锁释放,而不会继续持有锁,即使该线程接下来仍需执行该实例tempObject的其它synchronized方法或者synchronized块;

  我们以具体的例子来验证一下上述介绍(类实例为上面定义的TestForSynchronized):
 验证<1>中论点:

public class MainClass 
{
 
	public static void main(String[] args) 
	{		
		// 创建10个线程来调用【同一个】TestForSynchronized实例(对象)
		TestForSynchronized temp=new TestForSynchronized();		
		for(int index=0;index<10;index++)
		{
			MyThread_01 thread=new MyThread_01(temp);
			thread.start();		
		}				
	}
}
 
class MyThread_01 extends Thread
{
	TestForSynchronized testObject;
	
	public  MyThread_01(TestForSynchronized testObject)
	{
		this.testObject=testObject;
	}
	
	@Override
	public void run()
	{
		try 
		{
			Thread.sleep(0);
		} catch (InterruptedException e) 
		{
			
			e.printStackTrace();
		}
	
		System.out.println(Thread.currentThread().getName()+"--"+testObject.commonMethod());	
		System.out.println(Thread.currentThread().getName()+"--"+testObject.setID_01());
	}
}

synchronized 同步锁(Java)

 验证<2>中论点:
 将上面验证<1>中的commonMethod换成synchronized方法setID_03:

public class MainClass 
{
 
	public static void main(String[] args) 
	{		
		// 创建10个线程来调用【同一个】TestForSynchronized实例(对象)
		TestForSynchronized temp=new TestForSynchronized();		
		for(int index=0;index<10;index++)
		{
			MyThread_01 thread=new MyThread_01(temp);
			thread.start();		
		}				
	}
}
 
class MyThread_01 extends Thread
{
	TestForSynchronized testObject;
	
	public  MyThread_01(TestForSynchronized testObject)
	{
		this.testObject=testObject;
	}
	
	@Override
	public void run()
	{
		try 
		{
			Thread.sleep(0);
		} catch (InterruptedException e) 
		{
			
			e.printStackTrace();
		}
		
		System.out.println(Thread.currentThread().getName()+"--"+testObject.setID_01());
		System.out.println(Thread.currentThread().getName()+"--"+testObject.setID_03());
	}
}

某次运行的输出结果:

synchronized 同步锁(Java)


synchronized 块

通过上面的介绍,相信读者已经对synchronized块和synchronized方法有了一定理解,这里我们再补充介绍一下synchronized块。前已述及,synchronized块和synchronized方法,最明显的区别在于【作用域】,synchronized方法的作用域更大一些,某些场景下,作用域太大是一种缺陷,例如:对于一个很复杂,代码量比较大的方法,如果将其定义为synchronized方法,那么,由于同步锁的机制制约,多线程场景下,效率将会显得低下;如果,需要同步锁机制保障的仅仅只是一小段代码的话,完全可以采用synchronized块来解决。
 synchronized块的定义方式:synchronized(syncObject)

synchronized(syncObject){
	//允许控制的代码块
}

synchronized块具有以下特点:

  • synchronized块必须获得了syncObject的锁才能执行这块代码,具体获得锁的机制如前面分析;
  • 当多个线程并发访问某个实例syncObject的synchronized(this)块时,任何一个时刻只有一个线程能够持有该实例的锁,执行synchronized(this)块,其它线程将被阻塞,直到执行完毕释放锁;
  • 多线程场景下,当某个线程访问实例syncObject的synchronized(this)块时,其它线程可以访问实例syncObject的非synchronized(this)块和非synchronized方法;

特殊的synchronized 块(重要!!!)

如我们在例子类TestForSynchronized中定义的方法setID_02():

//测试方法02-synchronized块(类级别)
	public String setID_02()
	{
		 synchronized(TestForSynchronized.class)
		 {
			ID++;			
			return "setID_02() ID No.:"+ID;
		 }		
	}

在synchronized块中,并不是this(对象级),而是class(类级别),相较于对象级别,类级别具有更严格的同步约束,主要有以下几点:

  • 前已述及,采用了synchronized机制的类,其每一个实例都有一个锁(对象级别的锁),事实上,类也有唯一的锁,换言之,采用了synchronized机制的类有一个类锁;
  • 多线程场景下,当某一线程获得类锁(注意:不再是对象锁),其它线程将被阻塞,将无法调用或访问该类的所有方法和域,包括静态方法和静态变量;
  • 对于含有静态方法和静态变量的代码块的同步,类锁的严格约束在多线程场景下非常实用,应用也较多。

类锁的应用实例

基于在TestForSynchronized类中定义了synchronized块的方法setID_02,运行如下代码:

public class MainClass 
{
 
	public static void main(String[] args) 
	{		
		//创建10个线程,每个线程各创建一个TestForSynchronized实例(对象)
		for(int index=0;index<10;index++)
		{
			MyThread_02 thread=new MyThread_02();
			thread.start();		
		}
	}
}
 
class MyThread_02 extends Thread
{
	
	@Override
	public void run()
	{
		//每个线程均创建一个TestForSynchronized实例	
		TestForSynchronized temp=new TestForSynchronized();	
		System.out.println(Thread.currentThread().getName()+"--"+temp.setID_02());
	}
}

某次运行的输出结果:

synchronized 同步锁(Java)


互斥锁mutex

上面介绍的“类锁”虽然可以最大限度的避免并发场景下的冲突,但是,其过于严格:多线程场景下,当某一线程获得类锁(注意:不再是对象锁),其它线程将被阻塞,将无法调用或访问该类的所有方法和域,包括静态方法和静态变量。

  事实上,对于一个类,不可能所有属性和方法都涉及并发问题,因此,类锁过于严格的限制会极大的影响性能。鉴于此,本节介绍另外一种锁:互斥锁mutex,其定义方式如下:

public class TestForSynchronized
{
    //定义一个静态对象
    private static Object mutex = new Object();
    //
    //省略其它属性的定义
    
    public void TestMethod()
    {
        synchronized (mutex)
        {
            //涉及并发问题的代码块
        }
    }
}

    由于mutex为静态类型,对于TestForSynchronized类的所有对象,当需要访问TestMethod的同步块时都必须获得mutex对象的锁,然而,mutex属于类,有且仅有一个锁,从而可以保证任意一个时刻只有一个线程可以访问这个同步块。

 

全文地址请点击:https://blog.csdn.net/jin_kwok/article/details/74898102?utm_source=copy