每天学习一点点211129/211130--synchronized关键字

最新推荐文章于 2024-07-22 22:58:19 发布
最新推荐文章于 2024-07-22 22:58:19 发布
阅读量169 收藏
点赞数
文章标签： java java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45352902/article/details/121622449
版权

内部锁：synchronized 关键字

  Java 中每个对象都有一个与之关联的内部锁（intrinsic lock）。这种锁也称为监视器（Monitor），这种内部锁是一种排他锁，可以保障原子性，可见性与有序性。
  内部锁是通过 synchronized 关键字实现的。synchronized 关键字修饰代码块，修饰方法。修饰实例方法就称为同步实例方法，修饰静态方法就称为同步静态方法。
  修饰代码块的语法：

synchronized(对象锁){
	同步代码块，可以在同步代码块中访问共享数据
}
  1. 同步代码块
    使用this当前对象作为锁对象
package com.jason.java.duoxiancheng.intrinsiclock;

/**
 * synchronized 同步代码块
 * @author Jason
 */
public class Test01 {
    public static void main(String[] args) {
        //创建两个线程，分别调用mm()方法
        Test01 obj = new Test01();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.mm(); //使用的锁对象this就是obj对象
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.mm();//使用的锁对象this也是obj对象
            }
        }).start();
    }
    //定义方法，打印100行字符串
    public void mm(){
        synchronized (this) {//经常使用this当前对象作为锁对象
            for (int i = 0; i <= 100; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        }
    }
}

输出结果：Thread-0先输出0-100，Thread-1后输出


如果线程的锁不同，则不能实现同步

package com.jason.java.duoxiancheng.intrinsiclock;

/**
 * synchronized 同步代码块
 * 如果线程的锁不同，则不能实现同步
 * 想要同步必须使用用一个锁对象
 *
 * @author Jason
 */
public class Test02 {
    public static void main(String[] args) {
        //创建两个线程，分别调用mm()方法
        Test02 obj = new Test02();
        Test02 obj2 = new Test02();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.mm(); //使用的锁对象this就是obj对象
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj2.mm();//使用的锁对象this是 obj2 对象
            }
        }).start();
    }

    //定义方法，打印100行字符串
    public void mm() {
        synchronized (this) {//经常使用this当前对象作为锁对象
            for (int i = 0; i <= 100; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        }
    }
}

输出结果：Thread-0 和 Thread-1 两个线程交替输出，因为两个线程执行mm()方法并没有使用同一个锁


使用一个常量对象作为锁对象

package com.jason.java.duoxiancheng.intrinsiclock;

/**
 * synchronized 同步代码块
 * 使用一个常量对象作为锁对象
 * @author Jason
 */
public class Test03 {
    public static void main(String[] args) {
        //创建两个线程，分别调用mm()方法
        Test03 obj = new Test03();
        Test03 obj2 = new Test03();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.mm(); //使用的锁对象this就是obj对象
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj2.mm();//使用的锁对象this是 obj2 对象
            }
        }).start();
    }

    public static final Object OBJ = new Object();
    //定义方法，打印100行字符串
    public void mm() {
        synchronized (OBJ) {//使用一个常量对象作为锁对象
            for (int i = 0; i <= 100; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        }
    }
}

使用一个常量对象作为锁对象，不同方法中的代码也可以同步 
package com.jason.java.duoxiancheng.intrinsiclock;

/**
 * synchronized 同步代码块
 * 使用一个常量对象作为锁对象，不同方法中的代码也可以同步
 *
 * @author Jason
 */
public class Test04 {
    public static void main(String[] args) {
        Test04 obj = new Test04();
        Test04 obj2 = new Test04();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.mm(); //使用的锁对象this就是obj对象
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj2.mm();//使用的锁对象this是 obj2 对象
            }
        }).start();

        //第三个线程调用静态方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                sm();
            }
        });
    }

    //定义一个常量
    public static final Object OBJ = new Object();

    //定义方法，打印100行字符串
    public void mm() {
        synchronized (OBJ) {//使用一个常量对象作为锁对象
            for (int i = 0; i <= 100; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        }
    }

    public static void sm(){
        synchronized (OBJ) {//使用一个常量对象作为锁对象
            for (int i = 0; i <= 100; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        }
    }
}
  1. 同步方法

同步实例方法，把整个方法作为同步代码块，默认的锁对象是 this 对象

package com.jason.java.duoxiancheng.intrinsiclock;

/**
 * synchronized 同步实例方法
 * 把整个方法作为同步代码块，默认的锁对象是 this 对象
 * @author Jason
 */
public class Test05 {
    public static void main(String[] args) {
        //创建 Test05对象，通过对象名调用 mm()方法
        Test05 obj = new Test05();

        //一个线程调用 mm()方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.mm(); //使用的锁对象this就是obj对象
            }
        }).start();
        //另一个线程调用mm22()方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.mm22();//使用的锁对象this是 obj2 对象

            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                //使用的锁对象this是 new 创建的新对象，不是一个锁对象不能同步
                new Test05().mm22();
            }
        }).start();
    }

    //定义方法，打印100行字符串
    public void mm() {
        synchronized (this) {//使用this当前对象作为锁对象
            for (int i = 0; i <= 100; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        }
    }

    //使用 synchronized 修饰实例方法，同步实例方法，默认 this 作为锁对象
    public synchronized void mm22(){
        for (int i = 0; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

同步静态方法，默认的锁对象是当前类的运行时类对象 
package com.jason.java.duoxiancheng.intrinsiclock;

/**
 * synchronized 同步静态方法
 * 把整个方法作为同步代码块，默认的锁对象是当前类的运行时类对象
 * @author Jason
 */
public class Test06 {
    public static void main(String[] args) {
        Test06 obj = new Test06();

        //一个线程调用 mm()方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.mm(); //使用的锁对象是 Test06.class
            }
        }).start();
        //另一个线程调用mm22()方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                Test06.mm22();//使用的锁对象是Test06.class

            }
        }).start();
    }

    //定义方法，打印100行字符串
    public void mm() {
        //使用当前类的运行时类对象作为锁对象，可以简单的理解为把 Test06 类的字节码文件作为锁对象
        synchronized (Test06.class) {
            for (int i = 0; i <= 100; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        }
    }

    //使用 synchronized 修饰静态方法，同步静态方法，默认运行时类 Test06.class 作为锁对象
    public synchronized static void mm22(){
        for (int i = 0; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

同步方法，执行效率低。不需要同步的操作代码也被迫成为同步操作 同步代码块，锁的粒度细，执行效率高，可以只同步需要同步操作的地方 
package com.jason.java.duoxiancheng.intrinsiclock;

/**
 * @author Jason
 * 同步方法锁的粒度粗，执行效率低，同步代码块执行效率高
 */
public class Test07 {
    public static void main(String[] args) {
        Test07 obj = new Test07();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.doLongTimeTask2();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.doLongTimeTask2();
            }
        }).start();

    }

    //同步方法，执行效率低。不需要同步的操作代码也被迫成为同步操作
    public synchronized void doLongTimeTask(){
        try {
            System.out.println("Task Begin");
            Thread.sleep(3000);//模拟任务需要准备 3 秒 钟
            System.out.println("开始同步");
            for (int i = 0; i <= 10000; i++) {
                System.out.println(Thread.currentThread().getName() + "--" + i);
            }
            System.out.println("Task End");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //同步代码块，锁的粒度细，执行效率高，可以只同步需要同步操作的地方
    public void doLongTimeTask2(){
        try {
            System.out.println("Task Begin");
            Thread.sleep(3000);//模拟任务需要准备 3 秒 钟
            System.out.println("开始同步");
            synchronized (this){
                for (int i = 0; i <= 10000; i++) {
                    System.out.println(Thread.currentThread().getName() + "--" + i);
                }
            }
            System.out.println("Task End");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
  1. 脏读
package com.jason.java.duoxiancheng.intrinsiclock;

/**
 * 脏读
 * 出现读取属性值出现了一些意外，读取的是中间值，而不是修改之后的值
 * 出现脏读的原因是 对共享数据的修改 与对共享数据的读取不同步
 * 解决方法 不仅对修改数据的代码进行同步，还要对读取数据的代码块同步
 *
 * @author Jason
 */
public class Test08 {
    public static void main(String[] args) throws InterruptedException {
        PublicValue publicValue = new PublicValue();
        //开启子线程设置用户名和密码
        SubThread t1 = new SubThread(publicValue);
        t1.start();
        //为了确定设置成功
        //如果 不 sleep 一下，main线程先执行，获取的就是旧值
        Thread.sleep(100);
        //在 main 线程中读取用户名,密码
        //如果 getValue 不是同步方法，读取到的值可能是旧值，因为get值和set值没有同步
        publicValue.getValue();
    }

    static class SubThread extends Thread {
        private PublicValue publicValue;

        public SubThread(PublicValue publicValue) {
            this.publicValue = publicValue;
        }

        @Override
        public void run() {
            publicValue.setValue("ZDJ", "888");
        }
    }

    static class PublicValue {
        private String name = "jason";
        private String pwd = "666";

        public synchronized void getValue() {
            System.out.println(Thread.currentThread().getName() + ", getter -- name: " + name + ",--pwd: " + pwd);
        }

        public synchronized void setValue(String name, String pwd) {
            this.name = name;
            try {
                Thread.sleep(1000); //模拟操作 name 属性需要一定时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.pwd = pwd;
            System.out.println(Thread.currentThread().getName() + ", setter --name:" + name + ", --pwd: " + pwd);
        }
    }
}
  1. 线程出现异常会自动释放锁
package com.jason.java.duoxiancheng.intrinsiclock;

/**
 * 同步过程中线程出现异常，会自动释放锁对象
 * @author Jason
 */
public class Test09 {
    public static void main(String[] args) {
        Test09 obj = new Test09();

        //一个线程调用 mm()方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.mm(); //使用的锁对象是 Test09.class
            }
        }).start();
        //另一个线程调用mm22()方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                Test09.mm22();//使用的锁对象是Test09.class

            }
        }).start();
    }

    //定义方法，打印100行字符串
    public void mm() {
        //使用当前类的运行时类对象作为锁对象，可以简单的理解为把 Test09 类的字节码文件作为锁对象
        synchronized (Test06.class) {
            for (int i = 0; i <= 100; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
                if (i == 50) {
                    Integer.parseInt("abc");
                }
            }
        }
    }

    //使用 synchronized 修饰静态方法，同步静态方法，默认运行时类 Test09.class 作为锁对象
    public synchronized static void mm22(){
        for (int i = 0; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

Thread-0 输出到50的时候释放锁，停止输出，开始走 Thread-1

  1. 死锁
    有点没太懂，回头再看看
package com.jason.java.duoxiancheng.intrinsiclock;

/**
 * 死锁
 * 在多线程程序中，同步时可能需要使用多个锁，如果获得锁的顺序不一致，可能会导致死锁
 * 如何避免死锁 当需要获得多个锁的时候，所有线程获得锁的顺序保持一致即可
 *
 * @author Jason
 */
public class Test10 {
    public static void main(String[] args) {
        SubThread t1 = new SubThread();
        t1.setName("a");
        t1.start();

        SubThread t2 = new SubThread();
        t2.setName("b");
        t2.start();
    }

    static class SubThread extends Thread {
        private static final Object lock1 = new Object();
        private static final Object lock2 = new Object();

        @Override
        public void run() {
            if ("a".equals(Thread.currentThread().getName())) {
                synchronized (lock1) {
                    System.out.println("a 线程获得了 lock1 锁,还需 要获得 lock2 锁");
                    synchronized (lock2) {
                        System.out.println("a 线程获得 lock1 后又 获得了 lock2,可以想干任何想干的事");
                    }
                }
            }
            if ("b".equals(Thread.currentThread().getName())) {
                synchronized (lock2) {
                    System.out.println("a 线程获得了 lock2 锁,还需 要获得 lock1 锁");
                    synchronized (lock1) {
                        System.out.println("a 线程获得 lock2 后又 获得了 lock1,可以想干任何想干的事");
                    }
                }
            }
        }
    }
}
AJ7777777
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java进源码-Learn-Java-everyday:深入源代码级别学习Java
05-24
《深入源代码级别学习Java——探索Java编程的奥秘》 在编程的世界里，Java以其卓越的跨平台性、高效性和强大的生态系统，成为了...记住，每天进步一点点，终会汇聚成海。持续学习，持续成长，你将成为Java领域的专家。
Java-Programming-Part-1
03-13
理解线程的状态、同步机制（如synchronized关键字、wait/notify机制）以及死锁的概念，对于编写高效并发代码至关重要。 Java标准库（Java API）包含了大量的类和接口，如Math类用于数学运算，String类处理字符串，...
每天学习一点点211207/211208/211209--Lock显示锁
qq_45352902的博客
12-08 535
Lock显示锁锁的可重入性ReentrantLock   在 JDK5 中增加了 Lock 锁接口，有 ReentrantLock 实现类，ReentrantLock 锁称为可重入锁，它功能比 synchronized 多。 锁的可重入性   锁的可重入是指，当一个线程获得一个对象锁后，再次请求该对象锁时是可以获得该对象的锁的。 package com.jason.java.duoxiancheng.reentrantLock; /** * @author Jason */ public class
每天学习一点点211201--volatile关键字
qq_45352902的博客
12-02 233
轻量级同步机制：volatile关键字 volatile 的作用 volatile 使变量在多个线程之间可见。 volatile 与 synchronized 比较 volatile 关键字是线程同步的轻量级实现，所以 volatile 性能肯定比 synchronized 要好；volatile 只能修饰变量，而 synchronized 可以修饰方法，代码块。随着 JDK 新版本的发布,synchronized 的执行效率也 有较大的提升,在开发中使用 sychronized 的比率还是很大的。（斜
每天学习一点点211128--线程同步
qq_45352902的博客
11-29 159
线程同步 线程同步机制简介   线程同步机制是一套用于协调线程之间的数据访问的机制，该机制可以保障线程安全。 Java 平台提供的线程同步机制包括：锁，volatile 关键字，final 关键字，static 关键字以及相关的API，如 Object.wait() / Object.notify()等。 锁概述   线程安全问题产生的前提是多个线程并发访问共享数据。   将多个线程对共享数据的并发访问转换为串行访问，即一个共享数据一次只能被一个线程访问。锁就是用这种思路来保障线程安全的。   锁（Loc
synchronized关键字详解---来源网络大腿
激情中年的博客
11-21 187
来源自 http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html
PDF1-2-:马卡雷纳
05-02
5. **多线程**：理解线程的基本概念，线程同步和互斥，以及使用synchronized关键字、wait()和notify()方法进行线程通信。 6. **异常处理**：学习如何使用try-catch-finally语句块进行异常捕获和处理。 7. **Java ...
05.Java-Advanced
03-14
线程间的同步和通信是多线程编程的重要部分，Java提供了synchronized关键字、wait/notify机制以及Lock接口（如ReentrantLock）来确保数据的安全性。 2. **异常处理**：Java的异常处理机制帮助开发者捕获和处理程序...
advanced-java
03-16
理解线程同步机制，如synchronized关键字、volatile变量、Lock接口及其实现（如ReentrantLock），以及ThreadLocal，能够帮助开发者解决线程安全问题。 网络编程在Java中主要由java.net和java.nio包提供支持。Socket...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 730
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 690
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 709
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1231
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1255
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 1112
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1092
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
最新发布
Aishangyuwen的博客
07-22 826
Java实现拼图小游戏
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 755
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
synchronized关键字
09-01
synchronized关键字是Java中用于实现线程同步的关键字。它可以用来修饰方法或代码块，以确保在多线程环境下的安全性。 synchronized关键字的使用有以下几点需要注意： 1. synchronized是一种重量级的操作，会影响...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值