Synchronized & Lock distinguish

最新推荐文章于 2022-03-27 21:32:21 发布
最新推荐文章于 2022-03-27 21:32:21 发布
阅读量518 收藏
点赞数
分类专栏： Java 文章标签： Synchronized lock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/slowdownthenrunfast/article/details/36185139
版权

http://blog.csdn.net/fw0124/article/details/6672522

http://uule.iteye.com/blog/1488356


Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

     一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

     二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

     三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

     四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

     五、以上规则对其它对象锁同样适用.



对象锁：java的所有对象都含有1个互斥锁，这个锁由JVM自动获取和释放。线程进入synchronized方法的时候获取该对象的锁，当然如果已经有线程获取了这个对象的锁，那么当前线程会等待；synchronized方法正常返回或者抛异常而终止，JVM会自动释放对象锁。这里也体现了用synchronized来加锁的1个好处，方法抛异常的时候，锁仍然可以由JVM来自动释放。

类锁：对象锁是用来控制实例方法之间的同步，类锁是用来控制静态方法（或静态变量互斥体）之间的同步。其实类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的。我们都知道，java类可能会有很多个对象，但是只有1个Class对象，也就是说类的不同实例之间共享该类的Class对象。Class对象其实也仅仅是1个java对象，只不过有点特殊而已。由于每个java对象都有1个互斥锁，而类的静态方法是需要Class对象。所以所谓的类锁，不过是Class对象的锁而已。获取类的Class对象有好几种，最简单的就是MyClass.class的方式。

package net.aty.lock.target;
 
public class TargetMethod
{
    // 对象锁：形式1
    public synchronized void objLockMethod1()
    {
        System.out.println("in...objLockMethod1");
        try
        {
            Thread.sleep(500);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println("out...objLockMethod1");
    }
 
    // 对象锁：形式2
    public void objLockMethod2()
    {
        synchronized (this)
        {
            System.out.println("in...objLockMethod2");
            try
            {
                Thread.sleep(500);
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("out...objLockMethod2");
        }
 
    }
 
    // 类锁：形式1
    public static synchronized void classLock1()
    {
        System.out.println("classLock1------in");
        try
        {
            Thread.sleep(500);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println("classLock1------out");
    }
 
    // 类锁：形式2
    public void classLock2()
    {
        synchronized (TargetMethod.class)
        {
            System.out.println("classLock2------in");
            try
            {
                Thread.sleep(500);
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("classLock2------out");
        }
 
    }
 
}


测试：如果线程不存在数据共享，锁就不会有效果，也就没有必要加锁。

package net.aty.lock.thread.first;

import net.aty.lock.target.TargetMethod;

public class DemoThread1 extends Thread {
	private TargetMethod target = null;

	public DemoThread1(TargetMethod target) {
		this.target = target;
	}

	@Override
	public void run() {
		target.objLockMethod1();
	}
}


package net.aty.lock.thread.first;

import net.aty.lock.target.TargetMethod;

public class DemoThread2 extends Thread {
	private TargetMethod target = null;

	public DemoThread2(TargetMethod target) {
		this.target = target;
	}

	@Override
	public void run() {
		target.objLockMethod2();
	}
}


package net.aty.lock.thread.first;

import net.aty.lock.target.TargetMethod;

public class Test {

	public static void main(String[] args) throws Exception {
		test2();
	}

	public static void test1() throws Exception {
		TargetMethod target1 = new TargetMethod();
		TargetMethod target2 = new TargetMethod();

		// 线程1运行后,睡眠500ms
		Thread t1 = new DemoThread1(target1);
		t1.start();

		// 主线程睡眠100ms后,恢复执行,此时线程1仍然处于睡眠状态
		Thread.sleep(100);
		System.out.println("main thread runnig....");

		// 线程2开始运行
		Thread t2 = new DemoThread2(target2);
		t2.start();
	}

	public static void test2() throws Exception {
		TargetMethod shared = new TargetMethod();

		Thread t1 = new DemoThread1(shared);
		t1.start();

		Thread.sleep(100);
		System.out.println("main thread runnig....");

		Thread t2 = new DemoThread2(shared);
		t2.start();
	}
}

第二组测试，验证所谓的"类锁"的确可以达到控制静态方法同步的效果 

package net.aty.lock.thread.second;

import net.aty.lock.target.TargetMethod;

public class DemoThread3 extends Thread {

	public DemoThread3() {
	}

	@Override
	public void run() {
		TargetMethod.classLock1();
	}
}


package net.aty.lock.thread.second;

import net.aty.lock.target.TargetMethod;

public class DemoThread4 extends Thread {
	private TargetMethod target = null;

	public DemoThread4(TargetMethod target) {
		this.target = target;
	}

	@Override
	public void run() {
		target.classLock2();
	}
}


package net.aty.lock.thread.second;

import net.aty.lock.target.TargetMethod;

public class Test {

	public static void main(String[] args) throws Exception {
		// 线程3运行后,睡眠500ms
		Thread t1 = new DemoThread3();
		t1.start();

		// 主线程睡眠100ms后,恢复执行,此时线程1仍然处于睡眠状态
		Thread.sleep(100);
		System.out.println("main thread runnig....");

		// 线程4开始运行
		Thread t2 = new DemoThread4(new TargetMethod());
		t2.start();
	}

}

执行结果如下：通过分析，可以知道的确实现了static方法之间的同步访问

classLock1------in

main thread runnig...

classLock1------out

classLock2------in

classLock2------out


最后测试下对象锁和类锁的区别和联系。线程5会访问同步的实例方法，线程6访问同步的静态方法。

package net.aty.lock.thread.third;

import net.aty.lock.target.TargetMethod;

public class DemoThread5 extends Thread {
	private TargetMethod target = null;

	public DemoThread5(TargetMethod target) {
		this.target = target;
	}

	@Override
	public void run() {
		target.objLockMethod1();
	}
}


package net.aty.lock.thread.third;

import net.aty.lock.target.TargetMethod;

public class DemoThread6 extends Thread {
	public DemoThread6() {
	}

	@Override
	public void run() {
		TargetMethod.classLock1();
	}
}


package net.aty.lock.thread.third;

import net.aty.lock.target.TargetMethod;

public class Test {

	public static void main(String[] args) throws Exception {
		test2();
	}

	public static void test1() throws Exception {
		// 线程5开始运行
		Thread t1 = new DemoThread5(new TargetMethod());
		t1.start();

		// 主线程睡眠100ms后,恢复执行,此时线程1仍然处于睡眠状态
		Thread.sleep(100);
		System.out.println("main thread runnig....");

		// 线程6运行后,睡眠500ms
		Thread t2 = new DemoThread6();
		t2.start();
	}

	public static void test2() throws Exception {
		// 线程6开始运行
		Thread t2 = new DemoThread6();
		t2.start();

		// 主线程睡眠100ms后,恢复执行,此时线程1仍然处于睡眠状态
		Thread.sleep(100);
		System.out.println("main thread runnig....");

		// 线程5
		Thread t1 = new DemoThread5(new TargetMethod());
		t1.start();
	}

}

执行结果如下：

classLock1------in

main thread runnig....

in...objLockMethod1

classLock1------out

out...objLockMethod1

可以看出，类锁和对象锁不是同1个东西，一个是类的Class对象的锁，1个是类的实例的锁。也就是说：1个线程访问静态synchronized的时候，允许另一个线程访问对象的实例synchronized方法。反过来也是成立的，因为他们需要的锁是不同的。


slowdownthenrunfast
关注
专栏目录
@synchronized的使用方法
Clear__Love的专栏
12-09 622
@synchronized 的作用是创建一个互斥锁，保证此时没有其它线程对self对象进行修改。这个是objective-c的一个锁定令牌，防止self对象在同一时间内被其它线程访问，起到线程的保护作用。 一般在公用变量的时候使用，如单例模式或者操作类的static变量中使用。 实例: @synchronized(self){     static Respatch *rech
【java.lang.ref】Reference & ReferenceQueue & ReferenceHandler
厚积薄发者，轻舟万重山
04-23 1355
java.lang.ref包： Reference & ReferenceQueue & ReferenceHandler SoftReference & WeakReference PhantomReference jdk.internal.ref.Cleaner FinalReference Finalizer & FinalizerThread java.lang.ref.Cleaner 零、概述 前文《ref包简述》..
@synchronized的使用
frankisbaby的博客
03-21 1117
参考文档： [https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/Multithreading/ThreadSafety/ThreadSafety.html#//apple_ref/doc/uid/10000057i-CH8-SW1] 官方文档： The @synchronized dir...
java lock可重入_java ReentrantLock可重入锁功能
weixin_35645077的博客
02-28 168
1、可重入锁是可以中断的，如果发生了死锁，可以中断程序1 //如下程序出现死锁，不去kill jvm无法解决死锁2 public classUninterruptible {3 public static void main(String[] args) throwsInterruptedException {4 final Object o1 = new Object(); final Obje...
关于@synchronized(self)的用法
04-16 2843
@synchronized 的作用是创建一个互斥锁，保证此时没有其它线程对self对象进行修改。这个是objective-c的一个锁定令牌，防止self对象在同一时间内被其它线程访问，起到线程的保护作用。 一般在公用变量的时候使用，如单例模式或者操作类的static变量中使用。 # import "NetworkManager.h" static NetworkManager *network
Using the @synchronized Directive
diaoju3333的博客
04-24 61
https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/Multithreading/ThreadSafety/ThreadSafety.html#//apple_ref/doc/uid/10000057i-CH8-SW2 Using the @synchronized Directive ...
@synchronized
yohohohoho的专栏
08-31 1831
http://www.cocoachina.com/bbs/read.php?tid-26112-keyword-self.html 作用：保证此时没有其他线程对self对象进行修改 Using the @synchronized Directive The @
@synchronized(self)
tangaowen的专栏
12-19 2151
以下内容转载自：http://blog.csdn.net/yohohohoho/article/details/6735066      作用：保证此时没有其他线程对self对象进行修改 Using the @synchronized Directive The @synchronized directive is a convenient way to create mu
about @synchronized directive
junlaiyan的专栏
05-08 402
Using the @synchronized Directive The @synchronized directive is a convenient way to create mutex locks on the fly in Objective-C code. The @synchronized directive does what any other mutex lock wou
【iOS开发】---- Using the @synchronized Directive（使用同步指令）
冻僵的企鹅'zone
07-05 3820
@synchronized指令可以在Objective-C中方便快速的创建一个互斥锁的方法。@synchronized 指令可以做到任何其他互斥锁所做的--它可以防止不同的线程同时获取相同的锁。然而，在这种情况下，你不直接创 建互斥或锁定对象。相反，你只需使用任何Objective-C的对象作为一个锁定令牌，如下面的例子所示： - (void)myMethod:(id)anObj {
Android7.0 PackageManagerService (3) APK安装
ZhangJian的博客
10-09 8213
在本篇博客中，我们分析一下Android中的APK是如何安装的，以及PKMS在这个过程中进行了哪些工作。APK的安装方式有很多，我们先来看看如何用adb命令进行安装。
操作系统——Process Synchronization 进程同步
m0_60941819的博客
03-27 1198
操作系统第三弹——进程同步 来啦来啦！
Java阻塞队列详解
weixin_45045072的博客
02-19 472
一、什么是阻塞队列 阻塞队列(BlockingQueue)是增加了两个附加操作的队列。两个附加操作分别是，1具有阻塞功能的插入操作，当队列为满时，向队列中添加元素的操作都会被阻止；2具有阻塞功能的获取操作，当队列为空时，从队列中移除元素的操作会被阻止。 阻塞队列提供了四种处理方法： 方法/处理方式 抛出异常 返回特殊值 ...
浅谈JVM
Token
03-13 1239
1、JVM是什么 JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。 Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。 一般的高级语言如果要在不同的平台上运行，至少需要编译成不同的目标代码。而引入Ja...
itext 操作PDF
slowdownthenrunfast的专栏
08-22 977
pom文件 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven
java的System.getProperty()方法与 getenv() 方法
slowdownthenrunfast的专栏
08-19 810
java.version Java 运行时环境版本 java.vendor Java 运行时环境供应商 java.vendor.url Java 供应商的 URL java.home Java 安装目录 java.vm.specification.vers
java ClassLoad详解
slowdownthenrunfast的专栏
08-19 651
ClassLoader基本概念 JVM在运行时会产生三个ClassLoader，Bootstrap ClassLoader、Extension ClassLoader和AppClassLoader.AppClassLoader的Parent是ExtClassLoader，而ExtClassLoader的Parent为Bootstrap ClassLoader。 Bootstrap是用C++
CopyOnWriteArrayList
slowdownthenrunfast的专栏
08-20 507
ArrayList的一个线程安全的变体，其所有可变操作（add、set 等）都是通过对底层数组进行一次新的复制来实现的，代价昂贵。而在平时操作过程中，经常出现ConcurrentModificationException错误，如果避免这些错误发生呢？本文列出了几种常见的使用场景： 【场景一】对于ArrayList，使用直接方式，一边遍历，一边删除，会报错。 for(String item :
Java并发编程Synchronized&Lock&AQS深入解析
- Synchronized&Lock&AQS详解（上）（1）.vep： 这部分资源可能详细解释了Synchronized关键字和Lock接口的使用方法、场景、优缺点以及与AQS的关系。例如，它可能会探讨在什么情况下应该选择Synchronized，而什么时候...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值