多线程系列四-同步-Synchronized

最新推荐文章于 2023-01-05 13:04:22 发布
最新推荐文章于 2023-01-05 13:04:22 发布
阅读量272 收藏
点赞数
分类专栏： java-多线程并发 文章标签： java 多线程 synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a314773862/article/details/78868856
版权

synchronized 介绍

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：
1. 修饰代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
2. 修饰方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
3. 修改静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4. 修饰类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

非线程安全

多个线程共同访问一个对象中的实例变量，才会出现“非线程安全”问题。

锁相关

  1. 多个对象对应多个锁。一个对象只有一个锁。
  2. 每次访问对修饰的方法，需要获取该对象的锁。所以即使调用的同一个对象不同的同步方法，每次也只能执行其中一个方法。

修饰方法

  1. 场景一：两个线程分为访问同一个实例变量的同步和非同步方法。
public class SynchronizedMethod {

    private static class MyObject {
        public synchronized void methodA() {
            System.out.println("methodA start");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("methodA end");
        }

        public void methodB() {
            System.out.println("methodB start");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("methodB end");
        }
    }

    private static class MythreadA extends Thread {
        private MyObject object;

        MythreadA(MyObject object) {
            this.object = object;
        }

        @Override
        public void run() {
            object.methodA();
        }
    }

    private static class MythreadB extends Thread {
        private MyObject object;

        MythreadB(MyObject object) {
            this.object = object;
        }

        @Override
        public void run() {
            object.methodB();
        }
    }

    public static void main(String[] args) {
        MyObject myObject = new MyObject();
        MythreadA mythread1 = new MythreadA(myObject);
        MythreadB mythread2 = new MythreadB(myObject);

        mythread1.start();
        mythread2.start();
    }
}

输出结果：

methodA start
methodB start
methodA end
methodB end

methodB不需要获得锁，所以可以与同步方法异步调用。

  1. 场景二：两个线程分别访问同一个实例变量的不同的同步方法。
在上一个示例的methodB加上Syncrhoniezed
public class SynchronizedMethod {

    private static class MyObject {
        public synchronized void methodA() {
            System.out.println("methodA start");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("methodA end");
        }

        public synchronized void methodB() {
            System.out.println("methodB start");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("methodB end");
        }
    }

    private static class MythreadA extends Thread {
        private MyObject object;

        MythreadA(MyObject object) {
            this.object = object;
        }

        @Override
        public void run() {
            object.methodA();
        }
    }

    private static class MythreadB extends Thread {
        private MyObject object;

        MythreadB(MyObject object) {
            this.object = object;
        }

        @Override
        public void run() {
            object.methodB();
        }
    }

    public static void main(String[] args) {
        MyObject myObject = new MyObject();
        MythreadA mythread1 = new MythreadA(myObject);
        MythreadB mythread2 = new MythreadB(myObject);

        mythread1.start();
        mythread2.start();
    }
}

输出结果：
methodA start
methodA end
methodB start
methodB end

他们是虽然是两个方法，但是因为是同一个实例(每次只能有一个线程获得对象的锁)，所以也是顺序调用的。

修改代码块

当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

场景一： 两个线程分别访问同步方法和包含同步代码块的方法

public class SynchronizedBlock {

    private static class MyObject {
        public synchronized void methodA() {
            System.out.println("methodA start");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("methodA end");
        }

        public void methodB() {

            System.out.println("methodB start 1"); //这个不在同步方法内可以先执行
            synchronized (this) {
                System.out.println("methodB start 2");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("methodB end");
            }
        }
    }

    private static class MythreadA extends Thread {
        private MyObject object;

        MythreadA(MyObject object) {
            this.object = object;
        }

        @Override
        public void run() {
            object.methodA();
        }
    }

    private static class MythreadB extends Thread {
        private MyObject object;

        MythreadB(MyObject object) {
            this.object = object;
        }

        @Override
        public void run() {
            object.methodB();
        }
    }

    public static void main(String[] args) {
        MyObject myObject = new MyObject();
        MythreadA mythread1 = new MythreadA(myObject);
        MythreadB mythread2 = new MythreadB(myObject);

        mythread1.start();
        mythread2.start();
    }
}

methodB方法

System.out.println("methodB start 1"); //这个不在同步方法内可以先执行

这块代码不在任何同步方法或者代码块中，可以不同等待直接运行。

  • synchronized锁重入
    即线程访问同步方法methodA获得锁后，统一可以访问另一个同步方法methodB
  • 出现异常时，会自动释放锁

- 同步具有继承性：重写父类同步方法时，子类方法若没有用synchronized修饰，也是一个非同步方法

Synchronized原理

了解Synchronized原理，对于上面的一些场景就一目了然了。
详细解释可以参考这里
每个对象有一个监视器锁monitor，每次进入Synchronized方法时，monitor相当于被占用处于锁定状态。monitor默认是0，线程进入后为1。

和static一起及Synchronize(class)

  • 用在static方法上时，是对当前.javaw文件对哦应的Class类进行持锁(暂且称为类锁，前面实例变量锁暂称为对象锁)。
  • 类锁和对象锁是不同的一种锁
    实验实例：
public class SynchronizedStatic {

    private static class MyObject {
        public synchronized void methodA() {
            System.out.println("methodA start");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("methodA end");
        }

        public  static synchronized void methodB() {
                System.out.println("methodB start");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
               System.out.println("methodB end");

        }
    }

    private static class MythreadA extends Thread {
        private MyObject object;

        MythreadA(MyObject object) {
            this.object = object;
        }

        @Override
        public void run() {
            object.methodA();
        }
    }

    private static class MythreadB extends Thread {
        private MyObject object;

        MythreadB(MyObject object) {
            this.object = object;
        }

        @Override
        public void run() {
            object.methodB();
        }
    }

    public static void main(String[] args) {
        MyObject myObject = new MyObject();
        MythreadA mythread1 = new MythreadA(myObject);
        MythreadB mythread2 = new MythreadB(myObject);

        mythread1.start();
        mythread2.start();
    }
}

结果：

methodA start
methodB start 2
methodA end
methodB end
  • 类锁对所有实例对象有效
    代码示例：
public class SynchronizedStatic2 {

    private static class MyObject {
        public static synchronized void methodA() {
            System.out.println("methodA start");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("methodA end");
        }

        public  static synchronized void methodB() {
                System.out.println("methodB start");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
               System.out.println("methodB end");

        }
    }

    private static class MythreadA extends Thread {
        private MyObject object;

        MythreadA(MyObject object) {
            this.object = object;
        }

        @Override
        public void run() {
            object.methodA();
        }
    }

    private static class MythreadB extends Thread {
        private MyObject object;

        MythreadB(MyObject object) {
            this.object = object;
        }

        @Override
        public void run() {
            object.methodB();
        }
    }

    public static void main(String[] args) {
        MyObject myObject = new MyObject();
        MyObject myObject2 = new MyObject();//这里创建两个实例
        MythreadA mythread1 = new MythreadA(myObject);
        MythreadB mythread2 = new MythreadB(myObject2);

        mythread1.start();
        mythread2.start();
    }
}

结果：
methodA start
methodA end
methodB start
methodB end
  • 注意使用String的常量池特性。
String a="aa";
String b="aa";
//这里a和b持有的同一个对象锁
  • 在static方法中，用Synchronized(class)作用和Synchronized static作用一样

参考

http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html
https://www.cnblogs.com/paddix/p/5367116.html
https://www.cnblogs.com/paddix/p/5367116.html

Chase888
关注
专栏目录
多线程（synchronized）
zxx862309181的博客
05-18 795
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的
Java多线程-同步机制解决线程安全问题方式一：同步代码块
01-29
Java多线程编程中，线程安全问题是常见的挑战，特别是在并发环境下，多个线程可能会同时访问和修改同一份共享资源，导致数据不一致。为了解决这个问题，Java提供了同步机制，其中一种常用的方式就是同步代码块...
Java多线程-synchronized关键字
qq_24095055的博客
03-14 1661
文章目录synchronized关键字一 简介二 变量安全性三 多个对象多个锁四 synchronized方法与锁对象五 脏读六 synchronized锁重入七 同步不具有继承性synchronized同步语句块一 synchronized方法的缺点二 synchronized（this）同步代码块的使用三 synchronized（object）代码块间使用四 synchronized代码块间...
java多线程 synchronized
weixin_45729272的博客
04-17 1169
synchronized 设置为同步方法 package synchronizedTest; //模拟买票，不安全 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"用户A").start(); new Thread(buyTicket
Java多线程专题-synchronized的使用
一名coder
06-02 707
为什么有线程安全问题？ 当多个线程同时共享同一个全局变量或静态变量，做写的操作时，可能会发生数据冲突问题，也就是线程安全问题。但是做读操作是不会发生数据冲突问题。 使用同步方式解决线程安全 问:如何解决多线程之间线程安全问题? 答:使用多线程之间同步synchronized或使用锁(lock)。 问:为什么使用线程同步或使用锁能解决线程安全问题呢？ 答:将可能会发生数据冲突问题(线程不...
Java多线程之~~~~synchronized 方法
iteye_2022的博客
09-18 88
在多线程开发中，总会遇到多个在不同线程中的方法操作同一个数据，这样在不同线程中操作这个数据不同的顺序 或者时机会导致各种不同的现象发生，以至于不能实现你预期的效果，不能实现一致性，这时候就可以使用 synchronized关键字对一个方法来说，这个synchronized能保证所有调用这个方法的线程只有一个正在操作这个方法， 不会出现同时多个线程进入这个方法的情况，下面我们来一个例子说明这个...
Java多线程-同步机制解决线程安全问题方式二：同步方法
最新发布
01-30
在Java多线程编程中，线程安全问题通常是指多个线程访问共享资源时可能出现的不一致或错误状态。...但是，过度使用同步可能会导致性能下降，因此在设计多线程程序时，需要根据具体需求和性能考虑来选择合适的同步策略。
24.线程的同步机制-synchronized同步语句-synchronized同步代码块的使用.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
27.线程的同步机制-synchronized同步语句-synchronized代码块间的同步性.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
java多线程-同步块实例讲解
09-01
本文主要讲解Java中的同步块（synchronized block），这是一种实现线程同步的关键工具。 Java同步关键字`synchronized`用于标记方法或代码块，确保同一时间只有一个线程能够执行特定的代码。同步块的目的是防止多个...
Java 多线程(五）之 synchronized 的使用
09-01 323
目录 1 线程安全 2 互斥锁 3 内置锁 synchronized 3.1 普通同步方法，锁是当前实例对象(this) 3.1.1 验证普通方法中的锁的对象是同一个。 3.1.2 验证不同的对象普通方法的锁不一样 3.2...
Java 多线程 Synchronized 的注意细节
szn的专栏
04-19 117
最近做java多线程开发处理中发现synchronized的使用还是有一些细节问题要注意的。 1.synchronized与static synchronized 的区别 synchronized是对类的当前实例进行加锁，防止其他线程同时访问该类的该实例的所有synchronized块，注意这里是“类的当前实例”，类的两个不同实例就没有这种约束了。那么stati...
java 多线程 Thread、Runnable、synchronized
超级大洋葱的博客
01-16 323
文章目录1. 多线程概述2. 线程实现一：继承Thread类3. 线程实现二:实现Runnable接口4. synchronized 同步代码块5. 同步方法6. 线程生命周期图 1. 多线程概述 学习多线程之前，我们先要了解几个关于多线程有关的概念。 A:进程： 进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。 B:线程： 线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的
Java线程之synchronized
码客
03-24 258
翻译：https://www.journaldev.com/1061/thread-safety-in-java 我们知道线程安全在Java中是一个非常重要的主题，当多个线程操作共享数据时，如果没有任何控制，将会产生数据不一致的问题。数据不一致的重要原因是，当更新一个变量的值时，是分三步完成的，第一获取变量值，第二对变量值进行更新，第三将修改后的变量值刷新到内存。 下面我们用一个简单程序来...
JAVA线程同步——synchronized
此岸花开
03-27 375
问题：如何在多线程环境下安全地共享变量 首先理解一个概念：临界区 临界区是一个用来访问共享资源的代码块，这个代码块在同一个时间允许一个线程执行 JAVA中使用synchronized来声明一个方法或者一段代码块为临界区 每个对象只有一个锁，当它被某线程占有了，其他想获取锁的线程就只能阻塞 synchronized的语义： 1.对象锁 在同一个对象的临界区，同一时间只能有一个允许被访问
线程：synchronized
weixin_49496875的博客
07-02 224
关于synchronized的总结如下： 1、synchronized关键字的作用域有二种： 1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类
java多线程之synchronized
java小酱油
07-30 849
java多线程中synchronized方法，synchronized代码块。
Java多线程 -- 带你了解Java线程synchronized
ZeroWdd的博客
03-05 533
带你了解Java线程synchronized 0. 前言：Java对象头与Monitor概念 0.1 首先了解下Java对象头：32位虚拟机 普通对象 Object Header (64 bits) Mark Word (32 bits) | Klass Word (32 bits) 数组对象 O...
Java多线程（二）——synchronized 详解
m0_45198397的博客
01-05 5009
java多线程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值