synchronized关键字(三)

最新推荐文章于 2024-03-03 21:02:09 发布
最新推荐文章于 2024-03-03 21:02:09 发布
阅读量450 收藏
点赞数
分类专栏： Java多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/babycan5/article/details/83352344
版权
一、三个结论

对于 synchronized(非 this 对象 x)

  1. 当多个线程同时执行 synchronized(x){} 同步代码块时呈现同步效果
  2. 当其他线程执行 x 对象中 synchronized 同步方法时呈同步效果
  3. 当其他线程执行 x 对象方法里面的 synchronized(this) 代码块时也呈同步效果

需要说的是，虽然有三点，都是本质都是一样的，即每个线程拥有相同的对象锁，可以看一下第2个结论的例子

class MyObject {
	//synchronized 同步方法
    synchronized public void speedPrintString() {
        System.out.println(Thread.currentThread().getName()
                + " speedPrintString begin " + System.currentTimeMillis());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()
                + " speedPrintString end " + System.currentTimeMillis());
    }

}

class Service1 {

    public void testMethod(MyObject object) {

        synchronized (object) {
            try {
                System.out.println(Thread.currentThread().getName() + " testMethod begin "
                        + System.currentTimeMillis());
                Thread.sleep(3000);
                System.out.println(Thread.currentThread().getName() + " testMethod end "
                        + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

class ThreadB1 extends Thread {

    private MyObject object;

    public ThreadB1(MyObject object) {
        this.object = object;
    }

    @Override
    public void run() {
        //线程 B 执行 synchronized 同步方法
        object.speedPrintString();
    }

}

public class ThreadA1 extends Thread {

    private Service1 service1;
    private MyObject object;

    public ThreadA1(Service1 service1, MyObject object) {
        this.service1 = service1;
        this.object = object;
    }

    @Override
    public void run() {
        //线程 A 执行 testMethod 中的同步方法块
        service1.testMethod(object);
    }

    public static void main(String[] args) throws InterruptedException {
        Service1 service1 = new Service1();
        MyObject object = new MyObject();

        ThreadA1 threadA1 = new ThreadA1(service1, object);
        threadA1.setName("AAA");
        threadA1.start();

        Thread.sleep(2000);

        ThreadB1 threadB1 = new ThreadB1(object);
        threadB1.setName("BBB");
        threadB1.start();
    }

}

结果是：

AAA testMethod begin 1540385682634
AAA testMethod end 1540385685634
BBB speedPrintString begin 1540385685634
BBB speedPrintString end 1540385687634

结果是同步执行的。同步方法块持有的是 object 对象锁，同步方法也是持有的 object 锁，这时因为两者都是对同一个 object 对象进行处理的。

第三个结论和第二个一样，不会是把同步方法变成了同步代码块，这里不加赘述

二、静态同步方法和synchronized(class)

synchronized 还可以作用于 static 静态方法上，表示对当前的 Class 类进行持锁

class Service3 {

    synchronized public static void printA() {
        try {
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + " 进入 printA ");
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + " 离开 printA ");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public static void printB() {
        try {
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + " 进入 printB");
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + " 离开 printB");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public void printC() {
        try {
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + " 进入 printC");
            Thread.sleep(4000);
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + " 离开 printC");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

class ThreadB3 extends Thread{

    private Service3 service3;

    public ThreadB3(Service3 service3) {
        this.service3 = service3;
    }

    @Override
    public void run() {
        //调用 static 方法
        service3.printB();
    }
}

class ThreadC3 extends Thread {

    private Service3 service3;

    public ThreadC3(Service3 service3) {
        this.service3 = service3;
    }

    @Override
    public void run() {
        //调用非 static 方法
        service3.printC();
    }
}

public class ThreadA3 extends Thread {

    private Service3 service3;

    public ThreadA3(Service3 service3) {
        this.service3 = service3;
    }

    @Override
    public void run() {
        //调用 static 方法
        service3.printA();
    }

    public static void main(String[] args) {
        Service3 service3 = new Service3();
        ThreadA3 threadA3 = new ThreadA3(service3);
        threadA3.setName("AAA");
        threadA3.start();

        ThreadB3 threadB3 = new ThreadB3(service3);
        threadB3.setName("BBB");
        threadB3.start();

        ThreadC3 threadC3 = new ThreadC3(service3);
        threadC3.setName("CCC");
        threadC3.start();
    }

}

结果是：

AAA 在 1540386724917 进入 printA 
CCC 在 1540386724917 进入 printC
AAA 在 1540386726917 离开 printA 
BBB 在 1540386726917 进入 printB
CCC 在 1540386728917 离开 printC
BBB 在 1540386729931 离开 printB

从结果看出，线程 AAA 和线程 BBB 是同步执行的，而线程 CCC 和他们两个都是异步执行的。因为线程 AAA 和线程 BBB 调用的是同步 static 方法，因此他们俩持有的是类锁，线程 CCC 调用的是同步非 static 方法，因此他持有的是对象锁，持有的锁不同是异步的主要原因

因为线程 AAA 和线程 BBB 持有的是类锁，因此，只要调用的是同一个类，就算调用类的不同的对象，也是同步执行的

//使用两个线程持有相同类锁的情况下调用不同的对象
public static void main(String[] args) {
    Service3 service3 = new Service3();
    Service3 service31 = new Service3();
    ThreadA3 threadA3 = new ThreadA3(service3);
    threadA3.setName("AAA");
    threadA3.start();

    ThreadB3 threadB3 = new ThreadB3(service31);
    threadB3.setName("BBB");
    threadB3.start();
}

结果为：

AAA 在 1540387705925 进入 printA 
AAA 在 1540387707926 离开 printA 
BBB 在 1540387707926 进入 printB
BBB 在 1540387710927 离开 printB

可见类锁对类的所有实例起作用

同步 synchronized(class) 代码块

同步 synchronized(this) 代码块的作用和 synchronized static 方法的作用一样，都是持有类的锁

class Service4 {

    public void printA() {
        synchronized (Service4.class) {
            try {
                System.out.println(Thread.currentThread().getName() + " 在 "
                        + System.currentTimeMillis() + " 进入 printA");
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + " 在 "
                        + System.currentTimeMillis() + " 离开 printA");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void printB() {
        synchronized (Service4.class) {
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + "进入 printB");
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + "离开 printB");
        }
    }

}

class ThreadB4 extends Thread{

    private Service4 service4;

    public ThreadB4(Service4 service4) {
        this.service4 = service4;
    }

    @Override
    public void run() {
        service4.printA();
    }
}

public class ThreadA4 extends Thread {

    private Service4 service4;

    public ThreadA4(Service4 service4) {
        this.service4 = service4;
    }

    @Override
    public void run() {
        service4.printB();
    }

    public static void main(String[] args) {
        Service4 service4 = new Service4();
        Service4 service41 = new Service4();
        ThreadA4 threadA4 = new ThreadA4(service4);
        threadA4.setName("AAA");
        threadA4.start();

        ThreadB4 threadB4 = new ThreadB4(service41);
        threadB4.setName("BBB");
        threadB4.start();
    }

}

结果是：

AAA 在 1540387998044进入 printB
AAA 在 1540387998045离开 printB
BBB 在 1540387998045 进入 printA
BBB 在 1540388000045 离开 printA

三、String常量池带来的问题

在使用 synchronized(非 this 对象 x) 的时候，对象 x 最好不要设置成 String 类型的，这时由于 String 有常量池的问题，如果有这样的方法

public void print(String str) {
    synchronized (str) {
        while(true) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

那么当我们在多个线程中运行这个方法，并且以下两个 String 类型参数 a 和 b 时

String a = "A"；
String b = "A";

因为 String 常量池的问题，所以对象 a 是 == 对象 b 的，当我们用不同的线程调用 print 方法并且分别传入参数 a 和 b 时，那么这两个线程持有的就是相同的对象锁，造成一个线程在执行，而一个线程用于在等待的情况，结果类似这样：

Thread-0 AAAA
Thread-0 AAAA
Thread-0 AAAA
Thread-0 AAAA
...

所以，大多数情况下，同步 synchronized 代码块都不使用 String 作为锁对象，而使用其他的，比如 Object 等

四、死锁

因为不同的线程都在等待根本不可能被释放的锁，而导致所有的任务都无法继续完成，这个就是死锁

public class DealThread implements Runnable {

    public String username;
    public Object lock1 = new Object();
    public Object lock2 = new Object();

    public void setFlag(String username) {
        this.username = username;
    }

    @Override
    public void run() {
        if (username.equals("a")) {
            synchronized (lock1) {
                try {
                    System.out.println("username = " + username);
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (lock2) {
                    System.out.println("按 lock1 -> lock2 代码顺序执行");
                }
            }
        }

        if (username.equals("b")) {
            synchronized (lock2) {
                try {
                    System.out.println("username = " + username);
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (lock1) {
                    System.out.println("按 lock2 -> lock1 代码顺序执行");
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        DealThread dealThread = new DealThread();
        dealThread.setFlag("a");

        Thread thread = new Thread(dealThread);
        thread.start();

        Thread.sleep(2000);

        dealThread.setFlag("b");
        Thread thread1 = new Thread(dealThread);
        thread1.start();
    }
}

结果是：

username = a
username = b

可以看到，此时两个线程发生了死锁，具体是这样的：

  1. 线程 A 先持有对象 lock1 的锁，然后在持有 lock1 锁的时候又想去申请 lock2 的锁，此时他还没有释放 lock1 的锁；
  2. 线程 B 先持有对象 lock2 的锁，然后在持有 lock2 锁的时候又想去申请 lock1 的锁，此时他还没有释放 lock2 的锁；
  3. 两方都握有自己的锁不放弃，而又同时申请另一方的锁，所以，此时就造成了死锁

虽然这个实验实验 synchronized 嵌套的代码结构来实现死锁，其实不用嵌套的 synchronized 代码结构也会出现死锁，与嵌套不嵌套没有关系。只要互相等待对方释放锁就有可能出现死锁

五、参考

《Java多线程编程核心技术》

EclipseO2
关注
专栏目录
java 锁 null_synchronized加锁的对象如果被置为null
weixin_32309879的博客
02-25 1340
代码public class MonitorNullDemo implements Runnable {private Object object = new Object();@Overridepublic void run() {synchronized (object) {System.out.println(Thread.currentThread().getName() + "开始执行，...
synchronized(obj)
uusad的专栏
08-24 3495
一个对象一把锁，不管锁这个对象的哪个引用，均是同一把锁。 基本原则是： 1.在synchronized块中不要改变该锁定对象在堆中内存的位置（貌似是根据对象的地址进行锁定） 2.synchronized不能锁null。 例子1： public class SynTest { public static String obj; public static void main(S
java 锁 null_java synchronized锁对象，但是当对象引用是null的时候，锁的是什么？...
weixin_39677419的博客
02-13 430
/* monitorenter and monitorexit for locking/unlocking an object */CASE(_monitorenter): {oop lockee = STACK_OBJECT(-1);// derefing's lockee ought to provoke implicit null check CHECK_NULL(lockee...
Synchronized
mulanlong的博客
11-27 3898
参考：https://blog.csdn.net/luoweifu/article/details/46613015 1.synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：  （1） 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；  （2）修饰一个方法，被修饰的方法称为同步方法，其作用的范围...
synchronized用法详解
最新发布
qq_43842093的博客
03-03 4016
synchronized 是 Java 中的关键字，是一种同步锁。主要应用于多线程环境下保证线程的安全性。A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
线程同步机制synchronized
Avices
08-09 360
线程同步机制synchronized 如果有一部分代码必须是线程排队的，不能并发。一个线程把这里的代码全部执行结束之后，另一个线程才能进来。需要使用线程同步机制 线程同步机制的语法是： 使用同步代码块的方式，这种方式比较灵活。修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； synchronized(线程共享对象){ // 线程同步代码块。 } 在实例方法上使用synchronized，例如： synchronize
举例讲解Java中synchronized关键字的用法
09-02
在Java编程语言中，`synchronized`关键字是一个非常重要的概念，它主要用于多线程环境中的线程同步，确保共享资源的正确访问，防止数据不一致性。以下是对`synchronized`关键字使用方法的详细讲解： 1. **修饰实例...
synchronized 关键字详解
TanaStudy的博客
04-07 7067
synchronized 关键字1. synchronized 关键字的三种使用方法1.1. 修饰实例方法2.2. 修饰静态方法3.3. 修饰代码块2. 双重检验锁方式实现单例模式3. 构造方法可以使用 synchronized 关键字修饰么？4. JDK1.6 之后的 synchronized 关键字底层做了哪些优化？5. synchronized 和 ReentrantLock 的区别6. synchronized 关键字与Lock的区别 synchronized 关键字解决的是多个线程之间访问资源的同
synchronized关键字
一切有为法，如梦亦如幻，如露亦如电，应作如是观。
10-23 234
1.Synchronized关键字概述 synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下。 为什么呢？ 因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而...
Java synchronized关键字使用方式及特性解析
08-25
需要注意的是，synchronized关键字的使用需要遵守一定的原则，例如避免使用synchronized关键字在循环语句中，以免出现死锁等问题。此外，synchronized关键字也可以与其他线程同步工具结合使用，以实现更复杂的线程...
Java synchronized关键字和Lock接口实现原理
08-25
Java synchronized关键字和Lock接口实现原理 Java 中的 synchronized 关键字和 Lock 接口是两种常用的线程同步机制，它们都可以用来解决并发问题。下面我们将详细介绍 synchronized 关键字和 Lock 接口的实现原理。...
synchronized关键字(一)
NULL的博客
10-21 547
一、线程安全和不安全 非线程安全：在多个线程对同一个对象的实例变量进行并发访问时会出现值被更改、值不同步的情况 线程安全：获得的实例变量的值是经过同步处理的，按照顺序执行，不会出现脏读情况 举个例子：5个销售员， 卖同一堆货物，每个销售员在卖出一个货品后，并不是立即知道当前货物剩余数量的，因为在他卖出的同时，可能其他销售员已经卖出好几个货品了，如果这个时候就减1，那么就会产生数据的不同步，可能...
并发编程-synchronized详解
null_zhouximin的博客
01-27 343
并发编程-synchronized详解synchronized原理详解Monitor监视器锁对象的内存布局锁的膨胀升级过程（JDK1.5后的优化）二级目录三级目录 synchronized原理详解 synchronized底层原理 synchronized是基于JVM 内置锁实现，通过 内部对象Monitor(监视器锁)实现，基于进入与退出Monitor对象实现方法与代码块同步，监视器锁的实现依赖底层操作系统的Mutex lock（互斥锁）实现，它是一个重量级锁性能较低。当然，JVM内置锁在1.5之后版
为何JVM中不建议使用synchronized（String s）?实例详解+解决方法
qq_28295947的博客
01-19 4080
阿泽在学习synchronized关键字小结 首先呢总结一下synchronized的三种使用方式： 修饰实例⽅法，给对象实例加锁 synchronized void method(){ } 修饰静态⽅法，给当前类加锁 synchronized static void method(){ } 修饰代码块，给当前对象/类加锁 synchronized（this）{ } 重点在于第三点，很多知识博客中都提醒了这样一点 尽量不要使⽤ synchronized(String a) 因为 JVM
synchronized详解
UpClear的博客
03-03 750
synchronized
synchronized 用法详解
u010349644的专栏
06-13 258
1、简介 在Java中，提供了一个关键字 synchronized 来保证多线程安全问题，synchronized可以修饰一个方法、代码块，能够保证在同一时刻最多只有一个线程执行该段代码。本篇文章将全面讲解synchronized 各种情景下的使用及产生的作用。 2、synchronized 修饰某一非静态方法 我们先看一下示例： private class MyObject1{ public synchronized void method1(String name){
synchronized
QYHuiiQ
05-19 513
synchronized关键字同步代码块：cpu正在执行某个线程时可能会被其它线程打断，导致出现我们不想要的结果。比如：这段代码：publicclass Lianxi10 { public static void main(String[] args) { final Printer p = new Printer(); new Thread(){/...
一文彻底理解synchronized（通俗易懂的synchronized）
fu_bobo
09-22 5253
一文搞懂synchronized
java共享缓存同步_Java并发系列（2）——线程共享：synchronized与volatile
weixin_36079903的博客
02-25 476
2.3 线程共享多个线程并发访问共享资源时，有可能产生线程安全问题。线程安全包括三个方面：原子性、可见性、有序性，也可以说是并发三大特性。2.3.1 cpu 缓存模型2.3.1.1 背景cpu 的运算是在一个容量较小但读写速度很快的寄存器上进行的，而数据是存储在计算机物理内存(主存)的。所以 cpu 需要从内存读取数据到寄存器进行运算，然后再把数据更新到内存。随着技术发展，cpu 运算速度飞...
synchronized关键字在使⽤层⾯的理解 synchronized关键字在字节码中的体现 synchronized关键字在JVM中的实现 synchronized关键字在硬件⽅⾯的实现
06-10
1. synchronized关键字在使用层面的理解 synchronized关键字是Java中用来实现线程同步的关键字，可以修饰方法和代码块。当线程访问被synchronized修饰的方法或代码块时，需要获取对象的锁，如果该锁已被其他线程获取，则该线程会进入阻塞状态，直到获取到锁为止。synchronized关键字可以保证同一时刻只有一个线程能够访问被锁定的方法或代码块，从而避免了多线程并发访问时的数据竞争和一致性问题。 2. synchronized关键字在字节码中的体现 在Java代码编译成字节码后，synchronized关键字会被编译成monitorenter和monitorexit指令来实现。monitorenter指令对应获取锁操作，monitorexit指令对应释放锁操作。 3. synchronized关键字在JVM中的实现 在JVM中，每个对象都有一个监视器（monitor），用来实现对象锁。当一个线程获取对象锁后，就进入了对象的监视器中，其他线程只能等待该线程释放锁后再去竞争锁。 synchronized关键字的实现涉及到对象头中的标志位，包括锁标志位和重量级锁标志位等。当一个线程获取锁后，锁标志位被设置为1，其他线程再去获取锁时，会进入自旋等待或者阻塞等待状态，直到锁标志位被设置为0，即锁被释放后才能获取锁。 4. synchronized关键字在硬件方面的实现 在硬件层面，锁的实现需要通过CPU指令和总线锁来实现。当一个线程获取锁时，CPU会向总线发送一个锁请求信号，其他CPU收到该信号后会进入自旋等待状态，直到锁被释放后才能获取锁。总线锁可以保证多个CPU之间的原子操作，从而保证锁的正确性和一致性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值