synchronized关键字在同步代码块中的应用（下）

最新推荐文章于 2023-01-17 10:14:02 发布
最新推荐文章于 2023-01-17 10:14:02 发布
阅读量238 收藏
点赞数
分类专栏： 多线程编程核心技术 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wozaibohaibian/article/details/125465494
版权
本文详细探讨了Java Class的单例实现，介绍了静态同步方法(synchronized)的应用，涉及锁对象的选择、String常量池的影响、死锁问题及其解决方案，以及内置类同步机制。通过实例演示，揭示了同步代码块在不同场景下的异步与同步行为。
摘要由CSDN通过智能技术生成

类Class的单例性

每一个*.java文件对应Class类的实例都是一个，在内存中是单例的，测试代码如下：

public class Test {
    public static void main(String[] args) {
        MyTest test1 = new MyTest();
        MyTest test2 = new MyTest();
        MyTest test3 = new MyTest();
        MyTest test4 = new MyTest();

        System.out.println(test1.getClass() == test1.getClass());
        System.out.println(test1.getClass() == test2.getClass());
        System.out.println(test1.getClass() == test3.getClass());
        System.out.println(test1.getClass() == test4.getClass());

        SimpleDateFormat format1 = new SimpleDateFormat();
        SimpleDateFormat format2 = new SimpleDateFormat();
        SimpleDateFormat format3 = new SimpleDateFormat();
        SimpleDateFormat format4 = new SimpleDateFormat();

        System.out.println(format1.getClass() == format1.getClass());
        System.out.println(format1.getClass() == format2.getClass());
        System.out.println(format1.getClass() == format3.getClass());
        System.out.println(format1.getClass() == format4.getClass());
    }
}
output:
true
true
true
true
true
true
true
true

Class类用于描述类的基本信息，包括有多少个字段，有多少个构造方法，有多少个普通方法等，为了减少对内存的高占用率，在内存中只需要存在一份Class类对象就可以了，所以被设计成单例的。

静态同步synchronized方法与synchronized(class)代码块

关键字synchronized还可以应用在static静态方法上，如果这样写，那是对当前*.java文件对应的Class类对象进行持锁，Class类的对象是单例的，更具体地说，在静态static方法上使用synchronized关键字声明同步方法时，使用当前静态方法所在类对应Class类的单例对象作为锁。

public class Service {
    synchronized public static void printA() {
        try {
            System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printA");
            Thread.sleep(3000);
            System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printA");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public static void printB() {
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printB");
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printB");
    }
}

public class ThreadA extends Thread {
    @Override
    public void run() {
        Service.printA();
    }
}

public class ThreadB extends Thread {
    @Override
    public void run() {
        Service.printB();
    }
}

public class Run {
    public static void main(String[] args) {
        ThreadA a = new ThreadA();
        a.setName("A");
        a.start();

        ThreadB b = new ThreadB();
        b.setName("B");
        b.start();
    }
}

output:
线程名称为：A在1655824945776进入printA
线程名称为：A在1655824948791离开printA
线程名称为：B在1655824948791进入printB
线程名称为：B在1655824948791离开printB

synchronized关键字加到static静态方法上的方式是将Class类对象作为锁，而synchronized关键字加到非static静态方法上的方式是将方法所在类的对象作为锁。

public class Service {
    synchronized public static void printA() {
        try {
            System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printA");
            Thread.sleep(3000);
            System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printA");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public static void printB() {
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printB");
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printB");
    }

    synchronized public void printC(){
        System.out.println("线程名称为："+Thread.currentThread().getName()+"在"+System.currentTimeMillis()+"进入printC");
        System.out.println("线程名称为："+Thread.currentThread().getName()+"在"+System.currentTimeMillis()+"离开printC");
    }
}

public class ThreadC extends Thread{
    private Service service;

    public ThreadC(Service service){
        super();
        this.service = service;
    }

    @Override
    public void run(){
        service.printC();
    }
}

output:
线程名称为：A在1655825737790进入printA
线程名称为：C在1655825737790进入printC
线程名称为：C在1655825737790离开printC
线程名称为：A在1655825740805离开printA
线程名称为：B在1655825740805进入printB
线程名称为：B在1655825740805离开printB

异步运行的原因是持有不同的锁，一个是将类Service的对象作为锁，另一个是将Service类对应Class类的对象作为锁，A、B线程和C线程是异步的关系，而A线程和B线程是同步的关系。

同步syn static方法可以对类的所有对象实例起作用

Class锁可以对类的所有对象实例起作用。

public class Service {
    synchronized public static void printA() {
        try {
            System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printA");
            Thread.sleep(3000);
            System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printA");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public static void printB() {
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printB");
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printB");
    }
}

public class ThreadA extends Thread {
    private Service service;

    public ThreadA(Service service) {
        super();
        this.service = service;
    }

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

public class ThreadB extends Thread {
    private Service service;

    public ThreadB(Service service) {
        this.service = service;
    }

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

output:
线程名称为：A在1655826421956进入printA
线程名称为：A在1655826424967离开printA
线程名称为：B在1655826424967进入printB
线程名称为：B在1655826424967离开printB

同步syn(class)代码块可以对类的所有对象实例起作用

同步synchronized(class)代码块的作用其实和synchronized static方法的作用一样。

String常量池特性与同步相关的问题与解决方案

JVM具有String常量池的功能，所以如下代码结果为true

public class MyTest {
    public static void main(String[] args) {
        String a = "a";
        String b = "a";
        System.out.println(a == b);
    }
}

当synchronized(string)同步块与String联合使用时，要注意常量池会带来一些意外。

public class Service {
    public static void print(String stringParam) {
        try {
            synchronized (stringParam) {
                while (true) {
                    System.out.println(Thread.currentThread().getName());
                    Thread.sleep(1000);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadA extends Thread {
    private Service service;

    public ThreadA(Service service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.print("AA");
    }
}

public class ThreadB extends Thread {
    private Service service;

    public ThreadB(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.print("AA");
    }
}

public class Test {
    public static void main(String[] args) {
        Service service = new Service();

        ThreadA t1 = new ThreadA(service);
        t1.setName("A");
        t1.start();

        ThreadA t2 = new ThreadA(service);
        t2.setName("B");
        t2.start();
    }
}

output:
A
A
A
A
A
A
A
A
A
A

出现这种情况的原因是String的两个值都是AA，两个线程持有相同的锁，造成B线程不能执行。这就是String常量池所带来的问题，所以大多数情况下同步synchronized代码块不适用String作为锁对象，而改用其他，例如，new Object()实例化一个新的Object对象，它并不放入缓存池中，或者执行new String()创建不同的字符串对象，形成不同的锁。

public class Service {
    public static void print(Object obj) {
        try {
            synchronized (obj) {
                while (true) {
                    System.out.println(Thread.currentThread().getName());
                    Thread.sleep(1000);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

output:
A
B
A
B
B
A
B
A
A
B
B
A

同步synchronized方法无限等待问题与解决方案

使用同步方法会导致锁资源被长期占用，得不到运行的机会，如下：

public class Service {
    synchronized public void methodA(){
        System.out.println("methodA begin");
        boolean isContinueRun = true;
        while(isContinueRun){}
        System.out.println("methodA end");
    }

    synchronized public void methodB(){
        System.out.println("methodB begin");
        System.out.println("methodB end");
    }
}

output:
methodA begin

B线程永远得不到运行的机会，这时可以使用同步块来解决这样的问题：

public class Service {
    Object o1 = new Object();
    public void methodA(){
        synchronized (o1){
            System.out.println("methodA begin");
            boolean isContinueRun = true;
            while(isContinueRun){}
            System.out.println("methodA end");
        }
    }

    Object o2 = new Object();
    public void methodB(){
        synchronized (o2){
            System.out.println("methodB begin");
            System.out.println("methodB end");
        }
    }
}

output:
methodA begin
methodB begin
methodB end

多线程的死锁

java线程死锁是一个经典的多线程问题，因为不同的线程都在等待根本不可能被释放的锁，从而导致所有的任务都无法继续完成。在多线程技术中，“死锁”是必须避免的，因为这会造成线程“假死”。

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(3000);
                } 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(3000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }

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

            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Service service = new Service();

        ThreadA t1 = new ThreadA(service);
        t1.setName("A");
        t1.start();

        ThreadB t2 = new ThreadB(service);
        t2.setName("B");
        t2.start();
    }
}

output:
username = a
username = b

可以使用jdk自带工具来监测是否有死锁现象，执行jps命令和jstack命令
image

image

死锁是程序设计的bug，在设计程序时要避免双方互相持有对方的锁，只要互相等待对方释放锁，就有可能出现死锁。

内置类与同步

  • 内置类中有两个同步方法，但使用的是不同的锁，输出结果也是异步的。
  • 同步代码块synchronized(lock)对lock上锁后，其他线程只能以同步的方式调用lock中的同步方法。

锁对象改变导致异步执行

在将任何数据类型作为同步锁时，需要注意是否有多个线程同时争抢锁对象。如果多个线程同时争抢相同的对象，则这些线程之间就是同步的；如果多个线程分别获得自己的锁，则这些线程之间就是异步的。

通常情况下，一旦持有锁后就不再对锁对象进行更改，因为一旦更改就有可能出现一些错误。

public class Service {
    private String lock = "123";

    public void testMethod() {
        try {
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName() + " begin " + System.currentTimeMillis());
                lock = "456";
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + " end " + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();

        ThreadA a = new ThreadA(service);
        a.setName("a");

        ThreadB b = new ThreadB(service);
        b.setName("b");

        a.start();
        Thread.sleep(50);
        b.start();
    }
}

output:
a begin 1656170359345
b begin 1656170359408
a end 1656170361360
b end 1656170361423

50ms后，B线程取得的锁是“456”。

去掉50ms后，可能出现同步，也可能出现异步。

锁对象不改变依然同步执行

如果锁是一个User对象，其中一个线程持有该锁后，修改了User对象的属性。与其他线程依然是同步执行，因为持有的锁对象为同一个，仅仅对象的属性改变了，但对象未发生改变。

同步写法案例比较多

使用关键字synchronized的写法比较多，常用的有以下几种：

public class MyService {
    synchronized public static void testMethod1(){}
    
    public void testMethod2(){
        synchronized (MyService.class){}
    }
    
    synchronized public void testMethod3(){}
    
    public void testMethod4(){
        synchronized (this){}
    }
    
    public void testMethod5(){
        synchronized ("abc"){}
    }
}

上面代码出现了3种类型的锁对象：

  • testMethod1()和testMethod2()持有的锁是同一个，即MyService.java对应Class类的对象。
  • testMethod3()和testMethod4()持有的锁是同一个，即MyService.java类的对象。
  • testMethod5()持有的锁是字符串abc。

相同的锁是同步关系，不相同的锁是异步关系。

贾欣晓
关注
专栏目录
同步代码块
StriverLi的博客
02-27 1342
什么是同步代码块使用synchronize关键字加上锁对象来定义一段代码，这就叫同步代码块。什么时候使用同步代码块当多线程并发，有多段代码同时执行，如果希望一段代码在执行过程中多CPU不要切换到其他线程工作，这时就需要用到同步代码块。示例public class Demo1_Synchronized { public static void main(String[] args) {
synchronized同步代码块
Waiting_Mr_Liu的博客
08-17 504
2.4. synchronized同步代码块 2.4.1. 同步代码块的使用方法 1）使用方法说明： 在多个线程共同访问的代码放在synchronized（）{ 代码块 } 中的代码块位置处。 2）样例程序： public class UsingMethod { public static void main(String[] args) { Service service = new Service(); UsingMethodThread1 thread1 = n
Synchronized同步代码块关键字
wangzhantao的专栏
08-25 547
   * synchronized的使用，其实是对象锁，可以锁定方法（对当前对象锁定），也可以锁定代码块（锁定单独的对象）  * 1 当n个线程同时执行对一个对象锁定的代码块时，则同一时间只能有一个线程执行  *   * 场景设想：  *  有一个车主想要出租自己的一个车（一个对象锁），  *  可是有5个人同时想租这个车主的车（5个线程）  *  那么这5个人按顺序分别租这个人的...
Java——多线程同步_同步代码块synchronized 关键字
XQC_KKK的博客
10-16 768
线程安全问题其实就是由多个线程同时处理共享资源所导致的。 要想解决线程安全问题,必须得保证下面用于处理共享资源的代码在任何时刻只能有一个线程访问。 为了实现这种限制, Java 中提供了同步机制。当多个线程使用同一个共享资源时,可以将处理共享资源的代码放置在一个代码块中,使用 synchronized 关键字来修饰,被称作同步代码块,其语法格式如下: synchronized（lock）{ 操作共享资源代码 } 上面的代码中, lock 是—个锁对象,它是同步代码块的关键。当线程执行同步代码块时,首先会
java线程代码块同步的关键字_一文搞懂Java线程同步以及同步块和同步函数的概念...
weixin_33958381的博客
02-24 329
本文详细介绍了Java线程同步的概念以及常用方法，重点介绍了同步块和同步函数。1 什么是线程同步线程同步：即当有一个线程在对一块内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，这种线程访问数据的模式就叫做线程同步。2 同步的前提多个线程执行的时候访问共享数据时需要同步，如果是单线程则不需要同步。多个线程在执行...
synchronized锁机制 之 代码块锁
最新发布
程序员阿飘 的博客
01-17 390
其实无论是方法所还是代码锁都是要以一个对象监视器来锁定，锁定的代码是同步的，锁this是当前对象，锁String是String这个对象，锁Object是Object这个对象，互不干扰，如果有其它线程调用同样用到跟上面锁this、Objcet、String相同对象的方法或代码，就需要等待同步，锁代码块比锁方法更加灵活。锁的是当前这个线程，针对锁的对象的这段代码或方法，一次只能一个线程运行，其它线程运行到此的话会暂停，如果是执行其它非锁的则是异步的，注意这里不要被多线程搞迷糊了。
简单了解Java synchronized关键字同步
08-25
Java synchronized关键字同步详解 Java 中的 synchronized 关键字是用于实现线程同步的重要机制。下面我们将详细介绍 synchronized 关键字的使用方法和原理。 synchronized 关键字的作用 synchronized 关键字可以...
详解java中的synchronized关键字
09-03
在Java编程语言中，`synchronized`关键字是一个重要的并发控制机制，用于确保多线程环境下的数据一致性。本文将深入探讨`synchronized`关键字的使用和功能。 首先，`synchronized`关键字可以应用于方法和代码块，以...
java多线程编程之使用Synchronized关键字同步类方法
09-04
`synchronized`关键字提供了线程同步机制，确保在任何时刻只有一个线程能够执行特定的代码块。 在描述中提到的示例中，将`synchronized`关键字添加到`run()`方法前面，可以使该方法成为同步方法。这意味着当一个...
java synchronized关键字的用法
09-02
当一个线程进入同步代码块或同步方法并获取到锁后，其他试图进入的线程将会被阻塞，直到持有锁的线程退出同步块，其他线程才有机会获取锁并执行。 4. synchronized 的局限性 虽然 synchronized 提供了线程安全，但...
Java并发编程-synchronized关键字
梦悠哉的博客
06-14 307
概念synchronized关键字是java内置的特性,是互斥锁的一种实现方式.同一时间只能有一个线程获取到锁.例如线程A请求已经被线程B获取到的锁时,会处于等待状态,直到线程B执行完同步代码,释放锁,线程A才能获取锁,如果线程B由于IO或者其他原因发生阻塞,线程B会一直处于等待获取锁的状态,没有中断线程等待状态的方法.也就是说synchronized做到了两点,原子性和可见性.(1)原子性:表示...
测试String的intern()获取的字符串缓冲池对象 能不能作为同步代码块的锁
Talk is cheap. Show me the code.
07-13 418
测试String的intern()获取的字符串缓冲池对象 能不能作为同步代码块的锁 代码块 controller方法： @RequestMapping("testSynchronized") public void testSynchronized(String userId) { String intern = userId.intern(); ...
【并发编程】synchronized 实现原理
yhl_jxy的博客
02-11 901
Monitor对象、monitorenter\monitorexit指令等。
这一次，彻底搞懂Java中的synchronized关键字
smily的博客
06-14 1705
多线程并发是Java语言中非常重要的一块内容，同时，也是Java基础的一个难点。说它重要是因为多线程是日常开发中频繁用到的知识，说它难是因为多线程并发涉及到的知识点非常之多，想要完全掌握Java的并发相关知识并非易事。也正因此，Java并发成了Java面试中最高频的知识点之一。本系列文章将从Java内存模型、volatile关键字、synchronized关键字、ReetrantLock、Atomic并发类以及线程池等方面来系统的认识Java的并发知识。通过本系列文章的学习你将深入理解volatile关键字
java中的synchronized（同步代码块和同步方法的区别）
weixin_30849591的博客
08-21 735
问题的由来： 看到这样一个面试题： //下列两个方法有什么区别 public synchronized void method1(){} public void method2(){ synchronized (obj){} } synchronized用于解决同步问题，当有多条线程同时访问共享数据时，如果不进行同步，就会发生错误，java提供的解决方案是：只...
java线程同步代码块_线程间的同步与通信(1)——同步代码块Synchronized
weixin_26824299的博客
02-26 397
前言同步代码块(Synchronized Block) 是java中最基础的实现线程间的同步与通信的机制之一，本篇我们将对同步代码块以及监视器锁的概念进行讨论。什么是同步代码块(Synchronized Block)同步代码块简单来说就是将一段代码用一把锁给锁起来, 只有获得了这把锁的线程才访问, 并且同一时刻, 只有一个线程能持有这把锁, 这样就保证了同一时刻只有一个线程能执行被锁住的代码.这里...
同步代码块、同步方法、锁总结
热门推荐
weixin_36937689的博客
06-07 1万+
同步代码块 1.为了解决并发操作可能造成的异常，java的多线程支持引入了同步监视器来解决这个问题，使用同步监视器的通用方法就是同步代码块，其语法如下： synchronized（obj）{ //同步代码块 } 其中obj就是同步监视器，它的含义是：线程开始执行同步代码块之前，必须先获得对同步代码块的锁定。任何时刻只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行完成后，该线程会
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值