java在不同情况下锁对象探索

最新推荐文章于 2024-01-17 09:16:26 发布
最新推荐文章于 2024-01-17 09:16:26 发布
阅读量317 收藏
点赞数
分类专栏： java 文章标签： 锁对象 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/perfectnihil/article/details/76408448
版权

先从最简单的开始

***************************************

分割线   demo1

***************************************

public static void main(String args[]){
   final  Class1 c1 = new Class1();
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            c1.test1();
        }
    });
    Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            c1.test1();
        }
    });
    t1.start();
    t2.start();
}
 

public class Class1 {
    public synchronized void test1(){
        System.out.println("线程"+Thread.currentThread().getName()+"进入test1");
        System.out.println("线程"+Thread.currentThread().getName()+"即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程"+Thread.currentThread().getName()+"休眠完成，释放锁");
        System.out.println(".........................我是一个方法结束的分割线.................................");
    }}
打印结果如下
线程Thread-0进入test1线程Thread-0即将休眠两秒当前线程Thread-0休眠完成，释放锁.........................我是一个方法结束的分割线.................................线程Thread-1进入test1线程Thread-1即将休眠两秒当前线程Thread-1休眠完成，释放锁.........................我是一个方法结束的分割线.................................
***************************************
分割线   demo2
***************************************
大家对于demo1的打印结果应该没有什么疑惑，加了同步锁了，第一个线程要在里面待上两秒
那么第二个线程自然需要等待，ok,我们把demo1的代码稍作修改
public static void main(String args[]){
   final  Class1 c1 = new Class1();
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            c1.test1();
        }
    });
    Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            c1.test2();
        }
    });
    t1.start();
    t2.start();
}

public class Class1 {
    public synchronized void test1(){
        System.out.println("线程"+Thread.currentThread().getName()+"进入test1");
        System.out.println("线程"+Thread.currentThread().getName()+"即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程"+Thread.currentThread().getName()+"休眠完成，释放锁");
	System.out.println(".........................我是一个方法结束的分割线.................................");

    }

    public synchronized void test2(){
        System.out.println("线程"+Thread.currentThread().getName()+"进入test2");
        System.out.println("线程"+Thread.currentThread().getName()+"即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程"+Thread.currentThread().getName()+"休眠完成，释放锁");
	System.out.println(".........................我是一个方法结束的分割线.................................");
}}
打印结果如下
线程Thread-0进入test1
线程Thread-0即将休眠两秒
当前线程Thread-0休眠完成，释放锁
.........................我是一个方法结束的分割线.................................
线程Thread-1进入test2
线程Thread-1即将休眠两秒
当前线程Thread-1休眠完成，释放锁
.........................我是一个方法结束的分割线.................................
这个结果也是没有什么疑问的，同一个对象里面，两个方法都加了锁了，
用两个不同的线程进行访问，自然第二个线程要等第一个线程出来之后再进去。
***************************************
分割线   demo3
***************************************
继续修改，
把demo2中的test2方法修改如下
public void test2() {
    synchronized (this) {
        System.out.println("线程" + Thread.currentThread().getName() + "进入test2");
        System.out.println("线程" + Thread.currentThread().getName() + "即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程" + Thread.currentThread().getName() + "休眠完成，释放锁");
        System.out.println(".........................我是一个方法结束的分割线.................................");
    }
}
打印结果
线程Thread-0进入test1线程Thread-0即将休眠两秒当前线程Thread-0休眠完成，释放锁.........................我是一个方法结束的分割线.................................线程Thread-1进入test2线程Thread-1即将休眠两秒当前线程Thread-1休眠完成，释放锁.........................我是一个方法结束的分割线.................................
说明什么？说明了在对象的方法上加上synchronized，则其锁对象，就是this,
下面提供一个反证。
***************************************
分割线   demo4
***************************************
把test2方法修改如下，
public String mObj = "HaHaHa";
public void test2() {
    synchronized (mObj) {
        System.out.println("线程" + Thread.currentThread().getName() + "进入test2");
        System.out.println("线程" + Thread.currentThread().getName() + "即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程" + Thread.currentThread().getName() + "休眠完成，释放锁");
        System.out.println(".........................我是一个方法结束的分割线.................................");
    }
}
则打印结果如下：
线程Thread-0进入test1
线程Thread-1进入test2
线程Thread-0即将休眠两秒
线程Thread-1即将休眠两秒
当前线程Thread-1休眠完成，释放锁
.........................我是一个方法结束的分割线.................................
当前线程Thread-0休眠完成，释放锁
.........................我是一个方法结束的分割线.................................

我们看到，线程访问无序了，问什么，因为这次test1和test2用了不同的锁对象了。
同时，我们还可以得出一个结论，那就是对象可以访问的非静态方法上直接加的synchronized的锁对象就是this。


***************************************
分割线   demo5
***************************************
继续修改，如果我们把test2改成静态方法会怎么样？
public static synchronized void test2() {
        System.out.println("线程" + Thread.currentThread().getName() + "进入test2");
        System.out.println("线程" + Thread.currentThread().getName() + "即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程" + Thread.currentThread().getName() + "休眠完成，释放锁");
        System.out.println(".........................我是一个方法结束的分割线.................................");
}

打印结果如下
线程Thread-0进入test1
线程Thread-1进入test2
线程Thread-0即将休眠两秒
线程Thread-1即将休眠两秒
当前线程Thread-1休眠完成，释放锁
.........................我是一个方法结束的分割线.................................
当前线程Thread-0休眠完成，释放锁
.........................我是一个方法结束的分割线.................................

说明什么，说明了静态方法使用的锁对象不是this，
其实想想也对，静态方法内部也无法引用的this，那么，静态方法使用的到底是哪个锁对象？
***************************************
分割线   demo6
***************************************
我们继续探索，先把test1也改成静态方法，那么
public static  synchronized void test1() {
    System.out.println("线程" + Thread.currentThread().getName() + "进入test1");
    System.out.println("线程" + Thread.currentThread().getName() + "即将休眠两秒");
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("当前线程" + Thread.currentThread().getName() + "休眠完成，释放锁");
    System.out.println(".........................我是一个方法结束的分割线.................................");
}

线程Thread-0进入test1
线程Thread-0即将休眠两秒
当前线程Thread-0休眠完成，释放锁
.........................我是一个方法结束的分割线.................................
线程Thread-1进入test2
线程Thread-1即将休眠两秒
当前线程Thread-1休眠完成，释放锁
.........................我是一个方法结束的分割线.................................

说明test1和test2都申明为静态方法时，其使用的是同一把锁，那么这把锁到底是哪个对象呢？
***************************************
分割线   demo7
***************************************
继续修改，现在，我们的test1()和test2()方法都是静态方法了。
那么如果我们把test2()改为非静态方法，并且稍作修改，会怎么样
public  void test2() {
    synchronized (Class1.class){
        System.out.println("线程" + Thread.currentThread().getName() + "进入test2");
        System.out.println("线程" + Thread.currentThread().getName() + "即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程" + Thread.currentThread().getName() + "休眠完成，释放锁");
        System.out.println(".........................我是一个方法结束的分割线.................................");
    }
}
打印结果会怎么样呢？
线程Thread-0进入test1
线程Thread-0即将休眠两秒
当前线程Thread-0休眠完成，释放锁
.........................我是一个方法结束的分割线.................................
线程Thread-1进入test2
线程Thread-1即将休眠两秒
当前线程Thread-1休眠完成，释放锁
.........................我是一个方法结束的分割线.................................

好吧，看来我们找到静态方法的锁了，就是字节码对象。

***************************************
分割线   demo8
***************************************
俗话说，一把钥匙开一把锁，
使用synchronized关键字的时候一定要清楚自己使用的到底使用的是哪把锁。


我们进一步修改，
public static   void test1() {
    synchronized (Class1.class){
        System.out.println("线程" + Thread.currentThread().getName() + "进入test1");
        System.out.println("线程" + Thread.currentThread().getName() + "即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程" + Thread.currentThread().getName() + "休眠完成，释放锁");
        System.out.println(".........................我是一个方法结束的分割线.................................");
    }
}
public  void test2() {
    synchronized (Class1.class){
        System.out.println("线程" + Thread.currentThread().getName() + "进入test2");
        System.out.println("线程" + Thread.currentThread().getName() + "即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程" + Thread.currentThread().getName() + "休眠完成，释放锁");
        System.out.println(".........................我是一个方法结束的分割线.................................");
    }
}
打印结果毫无疑问
线程Thread-0进入test1
线程Thread-0即将休眠两秒
当前线程Thread-0休眠完成，释放锁
.........................我是一个方法结束的分割线.................................
线程Thread-1进入test2
线程Thread-1即将休眠两秒
当前线程Thread-1休眠完成，释放锁
.........................我是一个方法结束的分割线.................................

***************************************
分割线   demo9
***************************************
那么，既然如此，平时使用synchronized关键字的时候是否可以使用自定义的锁？当然可以。
大家都知道，java中的字符串其实是String类来封装的，其实就是个对象，
而根据java编程思想-第四版这本书的描述，所有对象都有单一的锁，
所以，可以使用字符串作为锁（其实前面的demo中已经用到了）


我们继续修改demo代码
public static String mObj = "HaHaHa";
public   void test1() {
    synchronized (mObj){
        System.out.println("线程" + Thread.currentThread().getName() + "进入test1");
        System.out.println("线程" + Thread.currentThread().getName() + "即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程" + Thread.currentThread().getName() + "休眠完成，释放锁");
        System.out.println(".........................我是一个方法结束的分割线.................................");
    }
}
public  void test2() {
    synchronized (mObj){
        System.out.println("线程" + Thread.currentThread().getName() + "进入test2");
        System.out.println("线程" + Thread.currentThread().getName() + "即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程" + Thread.currentThread().getName() + "休眠完成，释放锁");
        System.out.println(".........................我是一个方法结束的分割线.................................");
    }
}

打印结果如下
线程Thread-0进入test1
线程Thread-0即将休眠两秒
当前线程Thread-0休眠完成，释放锁
.........................我是一个方法结束的分割线.................................
线程Thread-1进入test2
线程Thread-1即将休眠两秒
当前线程Thread-1休眠完成，释放锁
.........................我是一个方法结束的分割线.................................

看来，使用字符串作为锁对象，是完全成功的。

***************************************
分割线   demo10
***************************************
另外这里还有一个有趣的现象
public static String mObj = "HaHaHa";
public static String mObj2 = "HaHaHa";
public   void test1() {
    synchronized (mObj){
        System.out.println("线程" + Thread.currentThread().getName() + "进入test1");
        System.out.println("线程" + Thread.currentThread().getName() + "即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程" + Thread.currentThread().getName() + "休眠完成，释放锁");
        System.out.println(".........................我是一个方法结束的分割线.................................");
    }
}
public  void test2() {
    synchronized (mObj2){
        System.out.println("线程" + Thread.currentThread().getName() + "进入test2");
        System.out.println("线程" + Thread.currentThread().getName() + "即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程" + Thread.currentThread().getName() + "休眠完成，释放锁");
        System.out.println(".........................我是一个方法结束的分割线.................................");
    }
}
打印结果如下
线程Thread-0进入test1
线程Thread-0即将休眠两秒
当前线程Thread-0休眠完成，释放锁
.........................我是一个方法结束的分割线.................................
线程Thread-1进入test2
线程Thread-1即将休眠两秒
当前线程Thread-1休眠完成，释放锁
.........................我是一个方法结束的分割线.................................

也就是说，如上的这种一个相同字符串重复不同变量申明两次，这样也是算一个锁的，
呵呵，这个和字符串在内存中的保存机制有关。

***************************************
分割线   demo11
***************************************
public static String mObj = "HaHaHa";
public static String mObj2 = "HaHaHa1";
public   void test1() {
    synchronized (mObj){
        System.out.println("线程" + Thread.currentThread().getName() + "进入test1");
        System.out.println("线程" + Thread.currentThread().getName() + "即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程" + Thread.currentThread().getName() + "休眠完成，释放锁");
        System.out.println(".........................我是一个方法结束的分割线.................................");
    }
}
public  void test2() {
    synchronized (mObj2){
        System.out.println("线程" + Thread.currentThread().getName() + "进入test2");
        System.out.println("线程" + Thread.currentThread().getName() + "即将休眠两秒");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程" + Thread.currentThread().getName() + "休眠完成，释放锁");
        System.out.println(".........................我是一个方法结束的分割线.................................");
    }
}

修改了一下，使两个字符串不同，这个时候打印结果如下
线程Thread-1进入test2
线程Thread-0进入test1
线程Thread-1即将休眠两秒
线程Thread-0即将休眠两秒
当前线程Thread-0休眠完成，释放锁
.........................我是一个方法结束的分割线.................................
当前线程Thread-1休眠完成，释放锁
.........................我是一个方法结束的分割线.................................

嗯，这样就不算是同一个锁了，符合预期！

总结一下
1：对象的非静态方法将synchronized加在方法上，则锁对象为this
2：对象的静态方法将synchronized加在方法上，则锁对象为字节码文件
3：任意对象都可以作为锁。




















 

 


                

        

        

    




    

      

        

            

              
                
                  perfectnihil
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
3.12 SE11创建锁对象

				
			

			

				

					weixin_36231828的博客
				

				

					09-07
					
					779
					
				

			

		

		

			
				
3.11 SE11创建搜索帮助

命名规则：<Z><模块代码><3位流水号><下划线><F4>

举例说明：ZWM001_F4



业务说明：搜索帮助可以提高界面的友好性和程序的多样性，可用于自建表或数据元素。



3.11.1 SE11创建基本搜索帮助



具体步骤：

第1步：输入事务码：SE11





第2步：

1处，输入搜索帮助名称

2处，点击“创建”按钮，弹出窗口

3处，选择“基本索引帮助”

4处，点击“勾选”按钮，..

			
		

	



                

              
                



	

		

			

				
					
Java基础学习之并发篇：不同的锁的适用场景

				
			

			

				

					h16407的博客
				

				

					11-16
					
					810
					
				

			

		

		

			
				
前言
Java提供了种类丰富的锁，每种锁因其特性的不同，在适当的场景下能够展现出非常高的效率。本文旨在对锁相关源码（本文中的源码来自JDK 8）、使用场景进行举例，为读者介绍主流锁的知识点，以及不同的锁的适用场景。
Java中往往是按照是否含有某一特性来定义锁，我们通过特性将锁进行分组归类，再使用对比的方式进行介绍，帮助大家更快捷的理解相关知识。下面给出本文内容的总体分类目录：

1.乐观锁 VS 悲观锁#
乐观锁与悲观锁是一种广义上的概念，体现了看待线程同步的不同角度。在Java和数据库中都有此概念对应的

			
		

	



                


  
              

                


	

		

			

				
					
Java中常见的锁的使用

					
最新发布

				
			

			

				

					weixin_43702295的博客
				

				

					01-17
					
					1123
					
				

			

		

		

			
				
为对于Java中的锁而言，一把锁也可能占有多种标准，符合多种分类，比如ReentrantLock既可以是悲观锁，也可以是可重入锁。使用ReentrantLock来创建公平锁或非公平锁的差别只是在于ReentrantLock的入参是true，还是false。ReentrantReadWriteLock类中有两把锁，ReadLock代表共享锁，WriteLock表示独享锁。在 Java中，”无锁/偏向锁/轻量级锁/重量级锁“ 这些状态通常是用来描述synchronized关键字锁的状态。

			
		

	





	

		

			

				
					
如何根据不同的业务场景，来选择合适的锁？//Java、后端、经验交流

				
			

			

				

					Java_rich的博客
				

				

					08-26
					
					248
					
				

			

		

		

			
				
前言： 锁是有效的解决并发情况下保证临界资源操作原子性的有效手段之一。下面我就从我们几个开发使用的角度来说我们常用的锁。



锁可以解决什么问题？

锁可以解决并行执行任务执行过程中对，共享数据顺序访问、修改的场景。比如对同一个账户进行并行扣款或者转账。下面我们展开讨论下 synchronized 、ReetranLock 以及他们的使用。



synchronized

synchronized 是 JDK 提供的内置锁， 由 JVM 虚拟机内部实现，是基于 monitor 机制， 在 JDK 1.6

			
		

	



		

			
		



	

		

			

				
					
使用Lock，对不同商品加锁 

				
			

			

				

					gjp014的专栏
				

				

					03-13
					
					763
					
				

			

		

		

			
				

 
package com.boce.gbkutf;
 
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.lo...

			
		

	





	

		

			

				
					
Java中的锁机制 synchronized & 偏向锁 & 轻量级锁 & 重量级锁 & 各自优缺点及场景 & AtomicReference 侵立删

				
			

			

				

					心神沫沫的收藏
				

				

					08-25
					
					1414
					
				

			

		

		

			
				
转自：https://www.cnblogs.com/charlesblc/p/5994162.html

 

参考文章： http://blog.csdn.net/chen77716/article/details/6618779

目前在Java中存在两种锁机制：synchronized和Lock，Lock接口及其实现类是JDK5增加的内容，其作者是大名鼎鼎的并发专家Doug Lea。本文并...

			
		

	





	

		

			

				
					
java-benchmarks:一些用于理解探索 jvm 行为的基准

				
			

			

				

					06-20
				

			

		

		

			
				
Java基准测试是评估和优化Java应用程序性能的重要工具。这些基准测试可以帮助我们深入理解JVM（Java...通过深入分析和实践这些基准测试，我们可以提升Java应用程序的效率，确保其在各种工作负载下的稳定性和高性能。

			
		

	





	

		

			

				
					
Java学习指南第四版下册

				
			

			

				

					05-09
				

			

		

		

			
				
在Java学习的道路上，本书将带你探索以下几个关键知识点：  1. **异常处理**：Java中的异常处理是程序健壮性的重要保障。书中会详细介绍如何使用try-catch-finally语句块进行异常捕获和处理，以及自定义异常的创建与...

			
		

	





	

		

			

				
					
深入探索Java集合框架：解密复杂的面试题和精准解析

				
			

			

				

					06-14
				

			

		

		

			
				
 - **ConcurrentHashMap** 提供了更好的并发性能，通过分段锁机制减少锁竞争，适用于多线程环境下的高效读写操作。  6. **HashSet和HashMap的内部实现**  - **HashSet** 内部使用HashMap，元素作为键，值用固定对象...

			
		

	





	

		

			

				
					
Java

				
			

			

				

					02-08
				

			

		

		

			
				
Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现为Oracle公司的一部分）于1995年发布。它的设计目标是实现“一次编写，到处运行”，这得益于其跨平台的Java虚拟机（JVM）。Java语法简洁且具有强大...

			
		

	





	

		

			

				
					
java学习及java学习代码

				
			

			

				

					08-28
				

			

		

		

			
				
Java是一种广泛使用的高级编程语言，由Sun Microsystems（后被Oracle公司收购）于1995年发布。它的设计目标是“一次编写，到处运行”，强调跨平台的可移植性，使得...不断地实践和探索，是成为Java高手的必经之路。

			
		

	





	

		

			

				
					
浅谈Java并发编程之Lock锁和条件变量

				
			

			

				

					08-18
				

			

		

		

			
				
主要介绍了浅谈Java并发编程之Lock锁和条件变量，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

			
		

	





	

		

			

				
					
SAP 锁对象在ABAP程序中的使用（十二）

				
			

			

				

					SAP阿狸
				

				

					08-08
					
					1355
					
				

			

		

		

			
				
锁对象激活后，会在系统中自动产生两个函数，分别用于表对象的锁定及表对象的释放。
    创建锁定的函数的命名规则为：ENQUEUE_+锁对象名，下面用到的创建锁对象的函数为ENQUEUE_EZSPFLI。
    释放锁定的函数的命名规则为：DEQUEUE_+锁对象名，下面用到的释放锁对象的函数为DEQUEUE_EZSPFLI。
    在ABAP程序执行中...

			
		

	





	

		

			

				
					
java 多线程 对象 锁_java-不同对象的锁上的多线程

				
			

			

				

					weixin_39992660的博客
				

				

					02-28
					
					103
					
				

			

		

		

			
				
我是Java编程的新手,我知道Java中的多线程技术不是一个琐碎的话题,而且我作为C开发人员工作了将近3年.我将代码更新如下：package multithreading;import java.util.ArrayList;import java.util.List;import java.util.logging.Level;import java.util.logging.Logger;pu...

			
		

	





	

		

			

				
					
同一任务和对象锁的问题

				
			

			

				

					JaryBlueEye的专栏
				

				

					08-04
					
					192
					
				

			

		

		

			
				
   偶尔翻开java编程思想看看多线程的篇章，意焦突然卡在某个问题上不动了。这个问题看过多少次多少遍了，此刻才领会，顿时感觉自己好笨拙的思维。

    问题是这样的：一般来说，在多线程程序中，某个任务在持有某对象的锁后才能运行任务，其他任务只有在该任务释放同一对象锁后才能拥有对象锁，然后执行任务。于是，想到，同一个任务在持有同一个对象的锁后，在不释放锁的情况下，继续调用同一个对象的其他同步...

			
		

	





	

		

			

				
					
JAVA多线程-多个对象不同锁

				
			

			

				

					成凯的专栏
				

				

					05-06
					
					534
					
				

			

		

		

			
				
同一个对象共享同一个锁，那多个对象呢？我们通过代码来看下,

我们继续上一篇的例子：

账户类


package com.ck.thread;


import java.math.BigDecimal;


public class Account {


 private String name;


 private BigDecimal balance = new BigDe...

			
		

	





	

		

			

				
					
透彻理解 Java synchronized 对象锁和类锁的区别

					
热门推荐

				
			

			

				

					zhujiangtaotaise的专栏
				

				

					02-17
					
					2万+
					
				

			

		

		

			
				
synchronized 加到 static 方法前面是给class 加锁，即类锁；而synchronized 加到非静态方法前面是给对象上锁。这两者的区别我用代码来演示下：
对象锁和类锁是不同的锁，所以多个线程同时执行这2个不同锁的方法时，是异步的。
在Task2 中定义三个方法 doLongTimeTaskA和doLongTimeTaskB是类锁，而doLongTimeTaskC是对象锁。pub

			
		

	





	

		

			

				
					
JAVA多线程-类锁（多个对象同一把锁）

				
			

			

				

					成凯的专栏
				

				

					05-08
					
					3012
					
				

			

		

		

			
				
如果要使这个类的所有对象都共享一个方法的锁，那么需要将方法设置为static，再加上synchronized锁，这把锁属于类了，所有这个类的对象都共享这把锁。

继续之前的账户类，我们修改下代码

账户类：


package com.ck.thread;

import java.math.BigDecimal;

public class Account {

 public stati...

			
		

	





	

		

			

				
					
Java面向对象编程：线程通信与对象锁

				
			

			

				

					
				

			

		

		

			
				
2. notify()方法：唤醒在对象等待池中的一个线程，使其有机会重新竞争对象锁。Java虚拟机会随机选择一个线程，将其从等待池转移到锁池，准备获取锁并继续执行。  此外，这份讲义还强调了学习Java面向对象编程的重要...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值