synchronized

最新推荐文章于 2023-08-10 15:02:27 发布
最新推荐文章于 2023-08-10 15:02:27 发布
阅读量103 收藏
点赞数
分类专栏： 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27584277/article/details/103873686
版权

文章目录

0.synchronized关键字

  • synchronized关键字锁定的是对象不是代码块
  • 锁定的对象有两种:1.类的实例 2.类对象(类锁)
  • 加synchronized关键字之后不一定能实现线程安全，具体还要看锁定的对象是否唯一。

1. 锁定的对象为类的实例举例

public class Demo {

    private int count = 10;
    private Object object = new Object();

    public void test(){
        synchronized (object){
            count--;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    }
   }

public class Demo {

    private int count = 10;

    public void test(){
        //synchronized(this)锁定的是当前类的实例,这里锁定的是Demo类的实例
        synchronized (this){
            count--;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    }

}

public class Demo {

    private int count = 10;

    //直接加在方法声明上，相当于是synchronized(this)
    public synchronized void test(){
        count--;
        System.out.println(Thread.currentThread().getName() + " count = " + count);
    }

}

2.锁定的是类对象

public class Demo {

    private static int count = 10;

    //synchronize关键字修饰静态方法锁定的是类的.class文件
    //静态方法中synchronize锁定代码块，锁定的对象不能是类的实例，只能是类的.class文件。
    public synchronized static void test(){
        count--;
        System.out.println(Thread.currentThread().getName() + " count = " + count);
    }

    public static void test2(){
        synchronized (Demo4.class){//这里不能替换成this
            count--;
        }
    }

}

3.锁对象的改变

  • 锁对象的改变
  • 锁定某对象o，如果o的属性发生改变，不影响锁的使用
  • 但是如果o变成另外一个对象，则锁定的对象发生改变
  • 应该避免将锁定对象的引用变成另外一个对象
public class Demo {

    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) {
        Demo1 demo = new Demo();

        new Thread(demo :: test, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t2 = new Thread(demo :: test, "t2");

         demo.o = new Object();
        //t2能否执行？
        t2.start();//t1,t2交替输出
    }

}

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

  • 在下面，test1和test2其实锁定的是同一个对象
public class Demo {

    String s1 = "hello";
    String s2 = "hello";

    public void test1(){
        synchronized (s1) {
            System.out.println("t1 start");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t1 end");
        }
    }

    public void test2(){
        synchronized (s2) {
            System.out.println("t2 start");
        }
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        new Thread(demo :: test1,"test1").start();
        new Thread(demo :: test2,"test2").start();
    }

}

5.锁的粒度

同步代码快中的语句越少越好

  • 比较test1和test2
  • 业务逻辑中只有count++这句需要sync，这时不应该给整个方法上锁
  • 采用细粒度的锁，可以使线程争用时间变短，从而提高效率
public class Demo{

    int count = 0;

    public synchronized void test1(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        count ++;

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void test2(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        synchronized (this) {
            count ++;
        }

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

6.线程重入

问题就在于线程重入的问题，

  • 第一个线程减了个1变成9了，还没打印，第二个线程又减了个1，第三个线程又减了个1，
  • 这时候虽然第一个线程只减了一个1但是却打印出来一个7(这里情况是不一定的)
  • 可以给方法加上synchronized
public class Demo1 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) {
        Demo1 demo = new Demo1();
        for (int i = 0; i < 5; i++) {
            new Thread(demo,"THREAD" + i).start();
        }
    }

}


public class Demo2 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) {
        for (int i = 0; i < 5; i++) {
            //相比较Demo1，这里是new了五个对象，每个线程对应都拿到各自的锁标记，可以同时执行。
            Demo2 demo = new Demo2();
            new Thread(demo,"THREAD" + i).start();
        }
    }

}

7.同步方法和非同步方法是否可以同时调用

同步方法和非同步方法是否可以同时调用？可以

public class Demo{

    public synchronized void test1(){
        System.out.println(Thread.currentThread().getName() + " test1 start...");
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " test1 end...");
    }

    public void test2(){
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " test2");
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        new Thread(demo :: test1,"test1").start();
        new Thread(demo :: test2,"test2").start();
    }

}

8.脏读问题

脏读问题

  • 实际业务当中应该看是否允许脏读，不允许的情况下对读方法也要加锁
public class Demo {

    String name;
    double balance;

    public synchronized void set(String name,double balance){
        this.name = name;
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.balance = balance;
    }

    public /*synchronized*/ double getBalance(String name){
        return this.balance;
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        new Thread(()->demo.set("dd",100.0)).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(demo.getBalance("dd"));//

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(demo.getBalance("dd"));
    }

}

9.一个同步方法调用另外一个同步方法，能否得到锁

一个同步方法调用另外一个同步方法，能否得到锁?可以，synchronized本身可支持重入

public class Demo {

    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) {
        Demo demo= new Demo();
        demo.test1();
    }

}

10.重入锁的另外一种情况，继承

public class Demo {

    synchronized void test(){
        System.out.println("demo test start........");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("demo test end........");
    }

    public static void main(String[] args) {
            new Demo2().test();
    }

}

class Demo2 extends Demo {

    @Override
    synchronized void test(){
        System.out.println("demo2 test start........");
        super.test();
        System.out.println("demo2 test end........");
    }

}

11.T2线程能否执行？

public class Demo {

    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) {
                //碰到异常的情况，如果没有处理，会自动释放锁，所以T2可以执行。
                int i = 1/0;
            }
        }
    }

    public static void main(String[] args) {
        Demo demo11 = new Demo();

        Runnable r = () -> demo11.test();

        new Thread(r, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(r, "t2").start();
    }

}
阳光zfc
关注
专栏目录
加不加 synchronized 有什么区别？
12-21
在Java编程语言中，`synchronized`关键字是一个非常重要的概念，它主要用于实现线程同步，以确保多线程环境下的数据一致性与安全性。当我们讨论在方法或者代码块中是否使用`synchronized`时，主要涉及以下几个方面的...
【多线程与高并发】- synchronized锁的认知
qq_43843951的博客
02-19 23万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
【事务与锁】当Transactional遇上synchronized
qq_43843951的博客
03-15 22万+
最近工作中遇到某些七七八八的问题，就是与事务和锁、并发都有着紧密联系相关的问题所在。主要情况是：通过调用方法获取编号，而这个编号是递增有序的，并且存在于数据库中，简单理解就是需要用到这种编号(以下称任务编号)，需要从数据库获取出来，在+1最为本次需要的编号，然后在存回数据库中，提供下次使用。直观来看是没得问题的，但是，可能在某次并发的时候出现编号相同，着属实很令人头疼，在经过领导的指导下是完美的解决了，接下来复盘一下。
Java中Synchronized的用法
热门推荐
阳光日志
06-24 50万+
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 4..
深入理解Java并发之synchronized实现原理
zejian的博客
06-04 40万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/72828483 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深...
Synchronized
weixin_45062852的博客
10-26 1079
一 Synchronized简介 Synchronized是java内置的关键字。代表这个方法加锁,相当于不管哪一个线程，运行到这个方法时,都要检查有没有其它线程正在用这个方法(或者该类的其他同步方法)，有的话要等正在使用synchronized方法的线程运行完这个方法后再运行此线程,没有的话,锁定调用线程,然后直接运行。 Synchronized是同步锁，保障原子性、可见性、有序性 1 原子性 指一个操作一旦开始，就不会被其他线程所干扰，不可中断。 2.可见性 指一个线程对共享变量进行修改，另一个能立刻获
synchronized详解
codedot
01-09 8万+
synchronized详解
synchronized 关键字
buhuisuanfa的博客
12-12 3990
线程进入一个层锁，第二次加锁的时候会组设等待，直到第一次锁释放，才能获取第二个锁，但是我们会在锁对象里记录一下，当前的锁是那个对象是那个线程持有的，如果加锁线程和持有线程是同一个，就放过，否则阻塞。因为在加锁的同时，会带来额外的时间开销，有些情况下，不使用多线程，不会面临线程安全问题，所以我们的一些集合并没有加锁，因此，我们在多线程情况下使用这些集合时，可以手动加锁。两个线程两把锁，t1,t2现针对锁A，锁B加锁，再去获取对方的锁，双方都不愿意让步，就会造成死锁问题。
synchronized关键字
目目沐沐
03-06 1万+
synchronized关键字
总结synchronized
m0_66714418的博客
08-10 846
互斥性：synchronized保证了同一时刻只有一个线程可以执行被synchronized修饰的代码块或方法。当一个线程进入synchronized代码块或方法时，其他线程必须等待，直到该线程执行完毕并释放锁。可重入性：同一个线程可以多次获得同一个对象的锁。如果一个线程已经获取了对象的锁，在持有锁的情况下再次进入由synchronized修饰的代码块或方法，不会产生死锁，而是允许继续访问。保证可见性：synchronized不仅保证了线程的互斥执行，还保证了共享变量的可见性。
synchronized锁原理分析（一、从Java对象头看synchronized锁的状态）
12-21
《深入剖析synchronized锁原理——从Java对象头的角度》 synchronized关键字在Java中扮演着重要的角色，它是Java实现同步的基础，确保了多线程环境下的数据一致性。不同于基于JDK实现的Lock接口（如ReentrantLock）...
Java中synchronized正确使用方法解析
08-25
Java 中 synchronized 正确使用方法解析 Java 中 synchronized 关键字是解决线程安全问题的重要手段，它可以确保在多线程环境下，共享资源的访问安全性。本文将详细介绍 Java 中 synchronized 的正确使用方法，通过...
透彻理解Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别
08-27
Java 中 Synchronized（对象锁）和 Static Synchronized（类锁）的区别 Synchronized 和 Static Synchronized 是 Java 中两种同步机制，它们都用于解决多线程并发访问的安全问题。然而，它们之间存在着本质的区别。...
Synchronized 和 Lock 的区别和使用场景
01-20
本文将深入探讨两种主要的锁机制：`synchronized`关键字和`Lock`接口，以及它们各自的特点、应用场景和使用方式。 一、Synchronized `synchronized`是Java中的一个内置关键字，用于提供线程安全。它的主要作用是...
S7-1200的运动控制功能
10-07
mysql
闲置物品交易网站设计与实现.ppt
10-07
闲置物品交易网站设计与实现.ppt
2023全国最新区划代码
最新发布
10-07
行政区划代码，地区划分代码，包涵县以下
JAVA源码简单聊天软件CS模式JAVA源码简单聊天软件CS模式
10-07
JAVA源码简单聊天软件CS模式JAVA源码简单聊天软件CS模式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值