devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

详解Java锁对象_java 对象锁

作者：我家小花儿 | 2024-03-23 01:11:07

赞

踩

java 对象锁

1、Synchronized

1.1、synchronized特性

1、互斥

synchronized会起到互斥效果，某个线程执行到某个对象的synchronized中时，其他线程如果也执行到同一个对象synchronized就会阻塞等待。

*进入synchronized修饰的代码块，就相当于加锁。

*退出synchronized修饰的代码块，就相当于解锁。

 一个线程先上了锁，其他线程只能等待这个线程释放。可以理解为“阻塞等待”

注意：

*上一个线程解锁之后，下一个线程并不是立即就可以获取到锁，而是要靠操作系统来“唤醒”，这也就是操作系统线程调度的一部分。

*假设有A，B，C三个线程线程A先获取到锁，然后B尝试获取锁，然后C再尝试获取锁，此时B和C都在阻塞队列中等待，但是A释放锁之后，虽然B比C先来，但B不一定就能拿到锁，而是和C重新竞争。并部遵循先来后到的原则。

2、刷新内存

synchronized工作过程

(1)获得互斥锁

(2)从主内存拷贝变量的最新副本到工作内存

(3)执行代码

(4)将更改后的共享变量的值刷新到主内存

(5)释放互斥锁

所以synchronized可以保证内存可见性

3、可重入

synchronized同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的现象。

锁死现象：

一个线程没有释放锁，然后又开始尝试获取锁

// 第一次加锁, 加锁成功
lock();
// 第二次加锁, 锁已经被占用, 阻塞等待.
lock();

 

 java中的synchronized是可重入锁，所以不存在上述问题。

代码示例：

  1.  
  2. public class Exe_03 {
  3.     private static int num=50000;
  4.     public static void main(String[] args) throws InterruptedException {
  5.         Counter04 counter1=new Counter04();
  6.         //创建线程完成自增
  7.         Thread thread1=new Thread(()->{
  8.             for (int i = 0; i < num; i++) {
  9.                 //自增操作
  10.                 counter1.increase();
  11.             }
  12.         });
  13.         Thread thread2=new Thread(()->{
  14.             for (int i = 0; i < num; i++) {
  15.                 //自增操作
  16.                 counter1.increase1();
  17.             }
  18.         });
  19.         //启动线程
  20.         thread1.start();
  21.         thread2.start();
  22.         //等待线程结束
  23.         thread1.join();
  24.         thread2.join();
  25.         //获取自增后的count值
  26.         System.out.println("count结果="+counter1.count);
  27.     }
  28. }
  29. class Counter04{
  30.     int count=0;
  31.     public synchronized void increase(){
  32.         count++;
  33.     }
  34.     public synchronized void increase1(){
  35.         count++;
  36.     }
  37. }

运行结果：

 在可重入锁的内部，包含了“线程持有者”和“计数器”两个信息。

*如果某个线程加锁的时候，发现锁已经被人占用，但是恰好占用的是自己，那么依然可以获取到锁，并让计数器自增。

*解锁的时候计数器递减为0的时候，才真正的释放锁。（才能被其他线程获取到锁）

1.2、关于synchronized

1、被synchronized修饰的代码，变成串行执行

2、使用多线程的前提是保证结果的正确

3、在多线程修改共享变量的时候才会出现线程安全问题

针对修改操作加锁，缩小锁的范围（锁的粒度）从而提高成序的并发处理能力

4、synchronized不仅可以修饰方法，还可以修饰代码块

 5、用synchronized修饰的代码块所涉及的指令，并不是在CPU一下子就执行完成，而是有可能在执行了一半被CPU调度走了，但是锁并没有释放，别的线程想要获取锁依然需要等待。

6、只给一个线程加锁，也会出现线程安全问题

代码示例：

  1.  
  2. public class Exe_02 {
  3.     private static int num=50000;
  4.  
  5.     public static void main(String[] args) throws InterruptedException {
  6.         //实例化对象
  7.         Counter03 counter03=new Counter03();
  8.         //创建线程
  9.         Thread t1=new Thread(() ->{
  10.             for (int i = 0; i < num; i++) {
  11.                 //调用加锁方法
  12.                 counter03.add();
  13.             }
  14.         });
  15.         Thread t2=new Thread(() ->{
  16.             for (int i = 0; i < num; i++) {
  17.                 //调用不加锁方法
  18.                 counter03.increase();
  19.             }
  20.         });
  21.         //启动线程
  22.         t1.start();
  23.         t2.start();
  24.         //等待线程执行完成
  25.         t1.join();
  26.         t2.join();
  27.         //打印结果
  28.         System.out.println("累加结果"+counter03.count);
  29.     }
  30. }
  31. class Counter03{
  32.     int count=0;
  33.     public void add(){
  34.         synchronized (this){
  35.             count++;
  36.         }
  37.     }
  38.     public void increase(){
  39.         count++;
  40.     }
  41. }

7、锁对象

 获取锁总结：

1、只有一个线程A要获取锁，那么可以直接获取到锁，没有锁竞争。

2、线程A与线程B共同抢一把锁，那么谁先拿到就先执行谁的逻辑，另外一个线程就阻塞等待，等待持有锁的线程释放锁之后再去抢锁，这时就存在锁竞争。

3、线程A和线程B竞争的不是同一把锁，那么它们没有竞争关系，那么它们分别难道自己的锁，不存在锁竞争关系。

2、锁对象

锁对象本身就是一个对象，无论什么对象都可以成为锁对象（实例对象、类对象）

锁对象记录的是当前获得到锁的线程信息

比如ThreadA拿到了锁，锁信息记录的就是ThreadA的地址。

代码示例：

  1.  
  2. public class Exe_03 {
  3.     private static int num=50000;
  4.     public static void main(String[] args) throws InterruptedException {
  5.         Counter04 counter1=new Counter04();
  6.         Counter04 counter2=new Counter04();
  7.         //创建线程完成自增
  8.         Thread thread1=new Thread(()->{
  9.             for (int i = 0; i < num; i++) {
  10.                 //自增操作
  11.                 counter1.increase();
  12.             }
  13.         });
  14.         Thread thread2=new Thread(()->{
  15.             for (int i = 0; i < num; i++) {
  16.                 //自增操作
  17.                 counter2.increase1();
  18.             }
  19.         });
  20.         //启动线程
  21.         thread1.start();
  22.         thread2.start();
  23.         //等待线程结束
  24.         thread1.join();
  25.         thread2.join();
  26.         //获取自增后的count值
  27.         System.out.println("count结果="+counter2.count);
  28.     }
  29. }
  30. class Counter04{
  31.     int count=0;
  32.     public synchronized void increase(){
  33.         count++;
  34.     }
  35.     public synchronized void increase1(){
  36.         count++;
  37.     }
  38. }

 

 

 ​​​

3、Java Object LayOut工具

3.1、使用Java Object LayOut工具之前要先在pom.xml文件导入maven依赖包

 

代码示例：

  1.  
  2. import org.openjdk.jol.info.ClassLayout;
  3.  
  4. public class Demo_405 {
  5.     private int count;
  6.     private long count1 = 200;
  7.     private String hello = "";
  8.  
  9.     private TestLayout test001 = new TestLayout();
  10.  
  11.     public static void main(String[] args) {
  12.         Demo_405 obj = new Demo_405();
  13.         // 打印实例布局
  14.         System.out.println(ClassLayout.parseInstance(obj).toPrintable());
  15.         // 调用hashCode后才保存hashCode的值
  16.         obj.hashCode();
  17.         // 观察现象
  18.         System.out.println(ClassLayout.parseInstance(obj).toPrintable());
  19.         System.out.println("=================================");
  20.         // 加锁后观察加锁信息
  21.         synchronized (obj) {
  22.             System.out.println(ClassLayout.parseInstance(obj).toPrintable());
  23.             synchronized (obj) {
  24.                 System.out.println(ClassLayout.parseInstance(obj).toPrintable());
  25.             }
  26.             System.out.println(ClassLayout.parseInstance(obj).toPrintable());
  27.         }
  28.         System.out.println("=================================");
  29.         // 强制执行垃圾回收
  30.         System.gc();
  31.         // 观察GC计数
  32.         System.out.println(ClassLayout.parseInstance(obj).toPrintable());
  33.         // 打印类布局
  34.         System.out.println(ClassLayout.parseClass(Demo_405.class).toPrintable());
  35.     }
  36. }
  37.  
  38. class TestLayout {
  39.  
  40. }

 

 在多线程环境下进行锁竞争的时候，一个线程抢锁的时候，JVM先看一下对象里有没有锁信息，如果没有，那么就让现在锁竞争的线程获取锁，如果有这个锁信息，那么就阻塞等待锁的释放。

4、锁对象示例

4.1、Locker对象不同代码示例：

  1.  
  2. public class Exe_06 {
  3.     private static int num = 50000;
  4.  
  5.     public static void main(String[] args) throws InterruptedException {
  6.         Counter06 counter1=new Counter06();
  7.         Counter06 counter2=new Counter06();
  8.        // counter1.count=1;
  9.         System.out.println(counter1.count);
  10.         System.out.println(counter2.count);
  11.         System.out.println(counter1);
  12.         System.out.println(counter2);
  13.         System.out.println(counter1.locker);
  14.         System.out.println(counter2.locker);
  15.         Thread t1=new Thread(() ->{
  16.             for (int i = 0; i < num; i++) {
  17.                 // 这里调用了counter1的自增方法
  18.                 counter1.increase();
  19.             }
  20.         });
  21.         Thread t2=new Thread(() ->{
  22.             for (int i = 0; i < num; i++) {
  23.                 // 这里调用了counter2的自增方法
  24.                 counter2.increase();
  25.             }
  26.         });
  27.         t1.start();
  28.         t2.start();
  29.         t1.join();
  30.         t2.join();
  31.         System.out.println("count结果"+counter1.count);
  32.     }
  33. }
  34. class Counter06{
  35.     public static int count=0;
  36.     //自定义一个锁对象
  37.     Object locker=new Object();
  38.     public void increase(){
  39.         synchronized (locker){
  40.             count++;
  41.         }
  42.     }
  43. }

 4.2、Locker对象相同代码示例：

  1.  
  2. public class Exe_06 {
  3.     private static int num = 50000;
  4.  
  5.     public static void main(String[] args) throws InterruptedException {
  6.         Counter06 counter1=new Counter06();
  7.         Counter06 counter2=new Counter06();
  8.        // counter1.count=1;
  9.         System.out.println(counter1.count);
  10.         System.out.println(counter2.count);
  11.         System.out.println(counter1);
  12.         System.out.println(counter2);
  13.         System.out.println(counter1.locker);
  14.         System.out.println(counter2.locker);
  15.         Thread t1=new Thread(() ->{
  16.             for (int i = 0; i < num; i++) {
  17.                 // 这里调用了counter1的自增方法
  18.                 counter1.increase();
  19.             }
  20.         });
  21.         Thread t2=new Thread(() ->{
  22.             for (int i = 0; i < num; i++) {
  23.                 // 这里调用了counter2的自增方法
  24.                 counter2.increase();
  25.             }
  26.         });
  27.         t1.start();
  28.         t2.start();
  29.         t1.join();
  30.         t2.join();
  31.         System.out.println("count结果"+counter1.count);
  32.     }
  33. }
  34. class Counter06{
  35.     public static int count=0;
  36.     //自定义一个锁对象
  37.     public static Object locker=new Object();
  38.     public void increase(){
  39.         synchronized (locker){
  40.             count++;
  41.         }
  42.     }
  43. }

 

 4.3、锁静态Locker和this：

4.4、锁类对象：

 4.5、总结：

synchronized的几种用法

1、修饰普通方法，相当于锁实例对象。

2、对代码块加锁，相当于锁当前调用方法的对象（也是实例对象）。

3、对静态方法加锁，相当于锁类对象（静态对象）。

5、valatile关键字

volatile能保证内存可见性，也可以解决有序性问题（禁止指令重排）。

代码在写入volatile修饰的变量的时候，

*改变线程工作内存中volatile变量副本的值。

*将改变后的副本的值从工作内存刷新到主内存。

代码在读取volatile修饰的变量的时候，
*从主内存中读取volatile变量的最新值到工作内存中

*从工作内存中读取volatile变量的副本

观察内存可见性：

  1.  
  2. import java.util.Scanner;
  3.  
  4. public class Exe_10 {
  5.     public static class Counter{
  6.         public static volatile int count=0;
  7.     }
  8.  
  9.     public static void main(String[] args) {
  10.         Thread t1=new Thread(() ->{
  11.             System.out.println(Thread.currentThread().getName()+"线程启动");
  12.             while(Counter.count==0){
  13.                 //一直循环
  14.             }
  15.             System.out.println(Thread.currentThread().getName()+"线程退出");
  16.         },"t1");
  17.         //启动线程
  18.         t1.start();
  19.         //确保t1先启动
  20.         try {
  21.             Thread.sleep(1000);
  22.         } catch (InterruptedException e) {
  23.             e.printStackTrace();
  24.         }
  25.         Thread t2=new Thread(() ->{
  26.             System.out.println(Thread.currentThread().getName()+"线程启动");
  27.             Scanner sc=new Scanner(System.in);
  28.             System.out.println("请输入一个非零的值：");
  29.             Counter.count=sc.nextInt();
  30.             System.out.println(Thread.currentThread().getName()+"线程退出");
  31.         },"t2");
  32.         //启动线程
  33.         t2.start();
  34.     }
  35. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/292143?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号