高并发编程之synchronized

最新推荐文章于 2023-02-19 07:15:13 发布
最新推荐文章于 2023-02-19 07:15:13 发布
阅读量206 收藏
点赞数
分类专栏： 高并发 java 文章标签： java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a549137619/article/details/80249482
版权

1. synchronized对某个对象加锁

public class Demo01 {
    private int count = 10;
    private Object object = new Object();
    public void test(){
        //任何线程要执行下面的代码，必须先拿到object对象的锁
        synchronized (object) { 
            count --;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    }
}

知识点：
1.synchronized关键字锁定的是对象不是代码块,demo中锁的是object对象的实例
2.锁定的对象有两种情况：①类的实例 ②类的字节码(.class)
3.关于线程安全：加synchronized关键字之后不一定能实现线程安全，具体还要看锁定的对象是否唯一。demo中如果只开启一条线程进行访问时是线程安全的，但是如果开启不同的两条线程同时访问时就会出现线程不安全的问题。

2. synchronized锁定当前对象

public class Demo02 {
    private int count = 10;
    public void test(){
        synchronized (this) { //任何线程要执行下面的代码，必须先拿到Demo02对象实例的锁
            count --;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    }
}

知识点：
1.synchronized(this)锁定的是当前类的实例,demo中锁定的是Demo02类的实例
2.此demo中如果Demo02类是单例的话可以保证在多线程访问时是线程安全的， 如果存在有多个Demo02的实例的话在多线程中不能保证线程安全，因为方法中的锁不唯一了。

3. synchronized关键字修饰普通方法等同于synchronized(this)。

public class Demo03 {
    private int count = 10;
    public synchronized void test(){//等同于synchronized(this)，锁定的是Demo03对象的实例
        count --;
        System.out.println(Thread.currentThread().getName() + " count =" + count);
    }
}

4. synchronize关键字修饰静态方法

public class Demo04 {
    private static int count = 10;
    public synchronized static void test1(){ //这里等同于synchronized(Demo04.class)
        count --;
        System.out.println(Thread.currentThread().getName() + " count = " + count);
    }
    public static void test2(){ //考虑一下这里写synchronize(this)是否可以
        synchronized (Demo04.class) {
            count --;
        }
    }
}

知识点：
1.synchronize关键字修饰静态方法锁定的是类的.class文件
2.静态方法中synchronize锁定代码块，锁定的对象不能是类的实例，只能是类的.class文件。原理如同在静态方法中不能直接调用非静态方法
3.类的.class文件是唯一的，所以说synchronize修饰静态方法或者锁定的对象是类的.class文件的时候在多线程中是可以实现线程安全的

5. synchronize与线程安全

public class Demo05 implements Runnable{
    private int count = 10;
    @Override
    public /*synchronized*/ void run(){
        count --;
        System.out.println(Thread.currentThread().getName() + " count = " + count);
    }
    public static void main(String[] args) {
        Demo05 demo05 = new Demo05();
        for (int i = 0; i < 5; i++) {
            new Thread(demo05,"THREAD" + i).start();
        }
    }
}

知识点：
1.run()方法没加synchronized关键字时，多个线程同时访问count，线程是不安全的
2.run()方法加上synchronized关键字后，锁定的是Demo05对象的实例，因为只创建了 一个Demo05的实例，多个线程访问时都要拿到Demo05的锁标记才能执行，在多个线程同时访问时也是线程安全的。

6. 同步方法和非同步方法可以同时调用

public class Demo07 {
    public synchronized void test1(){
        System.out.println(Thread.currentThread().getName() + " test1 start..........");
        try {
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " test1 end........");
    }
    public void test2(){
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "test2 execute......");
    }
    public static void main(String[] args) {
        Demo07 demo07 = new Demo07();
        new Thread(demo07 :: test1,"t1").start(); //JDK1.8新特性
        new Thread(demo07 :: test2,"t2").start(); //JDK1.8新特性
    }
}

7.对业务写方法加锁，同时也要对业务读方法加锁，否则容易产生脏读问题

public class Demo08 {
    String name;
    double balance;
    public synchronized void set(String name, double balance){
        this.name = name;
        try {
            Thread.sleep(2 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.balance = balance;
    }
    public synchronized double getBalance(String name){
        return this.balance;
    }
    public static void main(String[] args) {
        Demo08 demo08 = new Demo08();
        new Thread(()->demo08.set("zhangsan",100.0)).start(); //JDK1.8新特性
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(demo08.getBalance("zhangsan"));
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(demo08.getBalance("zhangsan"));
    }
}

8.synchronized获得的锁是可重入的

public class Demo09 {
    synchronized void test1(){
        System.out.println("test1 start.........");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        test2();
    }
    synchronized void test2(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test2 start.......");
    }
    public static void main(String[] args) {
        Demo09 demo09 = new Demo09();
        demo09.test1();
    }
}

知识点:
1.一个同步方法可以调用另一个同步方法，一个线程已经拥有某个对象的锁，再次申请的时候仍然会得到该对象的锁，也就是说synchronized获得的锁是可重入的

9.子类调用父类同步方法

public class Demo10 {
    synchronized void test(){
        System.out.println("test start........");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test end........");
    }
    public static void main(String[] args) {
        new Demo100().test();
    }
}
class Demo100 extends Demo10{
    @Override
    synchronized void test() {
        System.out.println("child test start.......");
        super.test();
        System.out.println("child test end.......");
    }
}

注意：上面程序运行过程中父类方法锁定的对象仍是子类对象，和同步方法调用另一个同步方法类似。

10.异常会导致锁被释放

public class Demo11 {
    int count = 0;
    synchronized void test() {
        System.out.println(Thread.currentThread().getName() + " start......");
        while (true) {
            count++;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5) {
                int i = 1 / 0; //此处抛出异常，锁将被释放，要想不被释放，可以在这里进行catch处理，然后让循环继续
            }
        }
    }
    public static void main(String[] args) {
        Demo11 demo11 = new Demo11();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                demo11.test();
            }
        };
        new Thread(r, "t1").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(r, "t2").start();
    }
}

注意：程序在执行过程中，如果出现异常，默认情况锁会被释放。所以，在并发处理的过程中，有异常要多加小心，不然可能会发生不一致的情况。比如在一个web app处理过程中，多个servlet线程共同访问通一个资源，这是如果异常处理不合适在第一个线程中抛出异常，其他线程就会进入同步代码去，有可能访问到异常产生是的数据。因此要非常小心的处理同步业务逻辑中的异常。

11.同步代码块中的语句越少越好

public class Demo16 {
    int count = 0;

    public synchronized void test1() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
        count++;
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void test2() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
        //采用细粒度的锁，可以是线程争用时间变短，从而提高效率
        synchronized (this) {
            count++;
        }
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

说明：采用细粒度的锁，可以是线程争用时间变短，从而提高效率

12.避免将锁定对象的引用指向另外一个对象

public class Demo17 {
    Object o = new Object();

    public void test() {
        synchronized (o) {
            while (true) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }
        }
    }

    public static void main(String[] args) {
        Demo17 demo17 = new Demo17();
        //启动第一个线程
        new Thread(demo17::test, "t1").start(); //JDK1.8新特性
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //启动第二个线程
        Thread t2 = new Thread(demo17::test, "t2");
         //锁对象发生改变，所以t2线程得以执行，如果注释掉这句话，线程t2将永远得不到执行机会
        demo17.o = new Object();
        t2.start();
    }
}

说明：锁定某对象o，如果o的属性发生改变，不影响锁的使用。但是如果o变成另外一个对象，则锁定的对象发生改变，新指向的对象未上锁。 应该避免将锁定对象的引用变成另外一个对象

13.不要以字符串常量作为锁定的对象

public class Demo18 {
    String s1 = "hello";
    String s2 = "hello";

    public void test1() {
        synchronized (s1) {

        }
    }

    public void test2() {
        synchronized (s2) {

        }
    }
}

在上面的例子中，test1和test2其实锁定的是同一个对象。这种情况还会发生比较诡异的现象，比如你用到了一个类库，在该类库中代码锁定了字符串”hello”, 但是你读不到源码，所以你在自己的代码中也锁定了”hello”,这时候就有可能发生非常诡异的死锁阻塞，因为你的程序和你用的的类库不经意间使用了同一把锁。

迷途未远
关注
专栏目录
多线程与高并发之synchronized
李小白的博客
08-31 563
一、进程与线程的概念 进程 在计算机里一个任务就是一个进程，进程是操作系统进行资源分配和调度的一个独立单位,是应用程序运行的载体。 线程 进程内部还需要同时执行多个子任务，这些子任务被称为线程。一个程序里不同的执行路径，就是一个线程 二、创建线程的三种方式 继承Thread类创建线程类 实现Runnerable接口或者Callable接口 通过线程池进行创建 三、线程生命周期（状态迁移圈） New Runnable(Ready Running) TimedWaiting Waiting B
高并发（四）--Synchronized及其实现原理
m0_52675592的博客
04-21 171
文章目录一.Synchronized的基本使用二. synchronized原理三. 运行结果的解释 一.Synchronized的基本使用 Synchronized是解决并发问题的一种最常用的方法，也是最简单的一种方法。它的主要作用有三个： 确保线程互斥的访问同步代码 保证共享变量的修改能够及时可见 有效解决重排序问题 总有有三种用法： 修饰普通方法 修饰静态方法 修饰代码块 代码举例： 没有同步的情况： package com.paddx.test.concurrent; public c
浅谈并发—— synchronized的实现原理
weixin_44120790的博客
08-27 317
目 录Monitor监视器synchronized锁升级**偏向锁轻量级锁锁膨胀自旋优化（占cpu，适合多核，jdk7之后不能控制是否自旋） Monitor监视器 每个对象都可以关联一个Monitor对象（操作系统提供） 过程 obj与monitor对象靠指向monitor对象指针地址（存在obj的markword中，30位）关联 Thread2占用锁成为Ower,其他的线程先阻塞等待 刚开始 Monitor 中 Owner 为 null 当 Thread-2 执行 synchroni
面试总被问，创建多少个线程合适？真的越多越好吗
我不生产数据，只是数据的搬运工
05-27 7574
码农小光关注 72020.04.18 00:04:50字数 3,178阅读 9,004 来源公众号：于日拱一兵 作者：tan日拱一兵 你有一个思想，我有一个思想，我们交换后，一个人就有两个思想 If you can NOT explain it simply, you do NOT understand it well enough image 为什么要使用多线程？ 防止并发编程出错最好的办法就是不写并发程序 image 既然多线程编程容易出错，为什么它还经久不...
高并发之Synchronized（超详细笔记）
九哥的博客
09-19 1642
高并发之Synchronized Synchronized简介 Synchronized的作用 官方解释 Synchronized methods enable a simple strategy for preventing thread interference and memory consistency errors:if an object is visible to more than...
【多线程与高并发】- synchronized锁的认知
热门推荐
qq_43843951的博客
02-19 23万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
Java高并发编程之synchronized与wait和notify结合
weixin_42486373的博客
11-11 2174
有一道面试题是这样的：实现一个容器，提供两个方法，add和size。写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5时，线程2给出提示并结束。 咋一看，似乎并不能，首先，实现一个容器如下： public class MyContainer1 { List&lt;Object&gt; lists = new ArrayList&lt;&gt;(); pu...
高并发编程,高并发编程,高并发编程
01-10
高并发编程知识点总结 高并发编程是指在高并发环境下编写高效、稳定、可靠的程序，以满足大规模用户访问和高并发请求的需求。高并发编程需要考虑多线程、线程安全、线程池、异步编程等问题，本节将对高并发编程的...
深入理解高并发编程-核心技术原理
最新发布
03-14
【深入理解高并发编程-核心技术原理】是一本专注于讲解高并发编程核心概念和技术的书籍，由阿里P8级别的架构师及Mykit系列开源框架作者撰写。本书内容涵盖源码分析、基础案例、实战案例和面试相关知识，旨在帮助读者...
汪文君高并发编程实战视频资源下载.txt
08-08
│ 高并发编程第一阶段18讲、数据同步的引入与Synchronized的简单介绍.mp4 │ 高并发编程第一阶段19讲、结合jconsole,jstack以及汇编指令认识synchronized关键字.mp4 │ 高并发编程第一阶段20讲、同步代码块以及...
Java高并发编程实战4，synchronized与Lock底层原理
学Java，找哪吒
09-23 4880
Java高并发编程实战系列，打造精品专栏。
synchronized（隐式锁）
xingze的博客
11-08 608
文章目录synchronized对象监视器为objectsynchronized对象监视器为Class（字节码文件） synchronized具有同步功能，是一种互斥锁，锁的是对象，synchronized修饰普通方法时，锁对象是this对象。修饰静态方法时，锁对象是字节码文件对象（Class文件）。 synchronized对象监视器为object synchronized对象监视器为Class...
构建高性能服务（二）java高并发锁的3种实现
移动互联网后端技术
06-18 1933
提高系统并发吞吐能力是构建高性能服务的重点和难点。通常review代码时看到synchronized是我都会想一想，这个地方可不可以优化。使用synchronized使得并发的线程变成顺序执行，对系统并发吞吐能力有极大影响，我的博文 http://maoyidao.iteye.com/blog/1149015 介绍了可以从理论上估算系统并发处理能力的方法。   那么对于必须使用synchron...
高并发编程之面试题一
今是而昨非
05-12 3051
题目：实现一个容器，提供两个方法，add,size。写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。 程序一，分析下面程序能否实现 List lists = new ArrayList(); public void add(Object o) { lists.add(o); } publi...
高并发编程之面试题二
今是而昨非
05-13 644
题目：写一个固定容量同步容器，拥有put和get方法，以及getCount方法，能够支持2个生产者线程以及10个消费者线程的阻塞调用。 使用wait和notify/notifyAll来实现 public class MyContainer1&lt;T&gt; { private final LinkedList&lt;T&gt; lists = new LinkedList&lt...
Collections工具类中sort排序的两种方式
今是而昨非
03-17 580
package com.my.action;import java.io.Serializable; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List;public class Student implements Comparabl
高并发编程之ReentrantLock
今是而昨非
05-13 261
回顾synchronized public class ReentrantLock1 { public synchronized void test1() { for (int i = 0; i &amp;lt; 10; i++) { System.out.println(i); try { T...
高并发编程之volatile
今是而昨非
05-09 222
1.volatile 关键字，使一个变量在多个线程间可见 public class Demo12 { volatile boolean running = true; public void test() { System.out.println(&amp;amp;amp;quot;test start.......&amp;amp;amp;quot;); while (running) { ...
Java并发编程：Synchronized详解、优缺点与限制
其次，synchronized会使代码失去并行执行的能力，降低了程序的执行效率，特别是在高并发情况下。因此，除非必要，否则应尽量避免过度使用synchronized，尤其是在涉及大量计算或数据操作的代码段。 作者建议，在深入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值