synchronized

最新推荐文章于 2020-09-19 18:28:44 发布
最新推荐文章于 2020-09-19 18:28:44 发布
阅读量148 收藏
点赞数
分类专栏： 多线程 java 文章标签： synchronized synchronized方法锁 synchronized类锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44030218/article/details/86755926
版权

文章目录

一、为什么需要synchronized

看下面这段代码

/**
 * Created by yan on 2019/2/3.
 */
public class ThreadDemo implements Runnable {

    static ThreadDemo threadDemo = new ThreadDemo();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(threadDemo);
        Thread t2 = new Thread(threadDemo);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }

    static int i = 0;
    @Override
    public void run() {
        for (int j = 0; j < 10000; j++) {
            i++;
        }
    }
}

正常情况下应该输出10000*2 = 20000
我运行三次看下结果
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
很明显它是不等20000的
原因：当t1线程读取到count++后在写入内存之前t2线程读取count++，因此两个线程读取的是同一个数字（这种概率是相当大的），因此最终获得的数字远小于预期的值

二、synchronized的两种用法

对象锁

包括方法锁（默认对象为this当前实例对象）和同步代码块锁（自己指定锁对象）

类锁

synchronized修饰的静态方法，或指定锁的class对象

2.1、对象锁

代码块形式：手动指定锁对象
方法锁形式：synchronized修饰普通方法，锁对象默认为this

2.1.1、代码块形式锁
/**
 * Created by yan on 2019/2/3.
 */
public class SynchronizedObjectCodeBlok implements Runnable {

    static SynchronizedObjectCodeBlok instance = new SynchronizedObjectCodeBlok();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()){  //当t1和t2两个线程都是存活状态时，做空循环

        }
        System.out.println("finished");
    }

    @Override
    public void run() {
        synchronized (this) {
            System.out.println("对象锁代码块形式" + Thread.currentThread().getName());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行完毕");
        }
    }
}
线程1 线程2 run（） 老二，咱俩一块走 老大，遵命 线程1：老二，我到了 大哥，你太胖了，我进不去 线程1 线程2 run（）

有synchronized代码块：对象锁代码块形式Thread-0-----5s-----Thread-0运行完毕，对象锁代码块形式Thread-1-----5s-----Thread-1运行完毕,finished
无synchronized代码块：两个线程“同时"运行，“同时”结束

如果指定锁对象？
创建锁对象

Object lock = new Object();

用lock取代synchronized中的this
运行效果：和this相同

那什么时候使用指定锁对象呢？
当有不止一个synchronized代码块时，可以指定不同的锁对象

/**
 * Created by yan on 2019/2/3.
 */
public class SynchronizedObjectCodeBlok implements Runnable {

    static SynchronizedObjectCodeBlok instance = new SynchronizedObjectCodeBlok();

    //创建锁对象
    Object lock1 = new Object();
    Object lock2 = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()){  //当t1和t2两个线程都是存活状态时，做空循环

        }
        System.out.println("finished");
    }

    @Override
    public void run() {
        synchronized (lock1) {
            System.out.println("对象锁代码块形式lock1--" + Thread.currentThread().getName());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "--lock1运行完毕");
        }
        synchronized (lock2) {
            System.out.println("对象锁代码块形式lock2--" + Thread.currentThread().getName());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "--lock2运行完毕");
        }
    }
}
线程1 线程2 lock1 lock2 老二，咱俩一块走 好的！看看咱俩谁快 老二，我先到了，我出去，你再进来 好的，大哥 老二，我进去了啊，你在哪呢？ 大哥，我刚出发 线程1 线程2 lock1 lock2

效果：
第一个线程拿到锁lock1—>第一个线程lock1执行完毕（“同时”第一个线程拿到lock2，第二个线程拿到lock1）—> 第一个线程的lock2和第二个线程的lock1“同时”执行完毕（“同时第二个线程拿到lock2”）—>第二个线程lock2执行完毕---->finished

如果是3个线程，更或者是10个线程呢？（那还不如去算彩票的中奖规律呢，之后再说！！！！）

2.1.2、方法锁
/**
 * Created by yan on 2019/2/3.
 */
public class SynchronizedObjectMethod implements Runnable {

    static SynchronizedObjectMethod instance = new SynchronizedObjectMethod();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()){  //当t1和t2两个线程都是存活状态时，做空循环

        }
        System.out.println("finished");
    }


    @Override
    public void run() {
        method();
    }
    
	//使用synchronized修饰方法，并在run方法中调用此方法
    public synchronized void method(){
        System.out.println("对象锁方法形式--"+Thread.currentThread().getName());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"--线程结束");
    }
}
线程1 线程2 synchronized方法 咱哥俩一块走 好的，大哥 线程1：老二，我先进去，你等会进 大哥，你不出去，我当然进不去了 线程1 线程2 synchronized方法

结果：第一个线程结束后第二个线程才开始运行

2.2、类锁

概念：java类中可能有很多个对象，但只有1个Class对象

类锁的使用方法：
1.synchronized加在static方法上
2.synchronized(*.class)代码块

2.2.1、synchronized加在static方法上

这里我们将类实例化了两次

/**
 * Created by yan on 2019/2/4.
 * 类锁---static形式
 */
public class SynchronizedClassStatic implements Runnable {

    static SynchronizedClassStatic instance1 = new SynchronizedClassStatic();
    static SynchronizedClassStatic instance2 = new SynchronizedClassStatic();

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("finished");
    }

    @Override
    public void run() {
        methed();
    }
    
	//synchronized加在static方法上，在run方法中调用
    public static synchronized void methed(){
        System.out.println("static形式--"+Thread.currentThread().getName());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"--运行结束");
    }
}

有static的效果：第一个线程执行完后，第二个线程开始执行
五static的效果：两个线程“同时”开始，“同时”结束

2.2.2、synchronized(*.class)代码块
/**
 * Created by yan on 2019/2/4.
 * 类锁--- *.class
 */
public class SynchronizedClassClass implements Runnable {

    static SynchronizedClassClass instance1 = new SynchronizedClassClass();
    static SynchronizedClassClass instance2 = new SynchronizedClassClass();

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("finished");
    }

    @Override
    public void run() {
        method();
    }

    public void method(){
        synchronized (SynchronizedClassClass.class){
            System.out.println("类锁*.class--"+ Thread.currentThread().getName());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--线程结束");
        }
    }
}

有*.class效果：第一个线程结束后，第二个线程开始运行
换成 this ：两个线程“同时”开始，“同时”结束

文章开篇的代码输出小于20000，我们学了sychronized的两大类–四种方法，感兴趣的可以试一下能不能得出20000

三、多线程访问同步方法的7种情况

1.两个线程同时访问一个对象的同步方法
2.两个线程同时访问两个对象的同步方法
3.两个线程同时访问synchronized的静态方法
4.两个线程同时访问同步方法和非同步方法
5.两个线程访问同一对象的不同的普通同步方法(非static)
6.两个线程同时访问静态synchronized和非静态synchronized方法
7.方法抛出异常后，会释放锁（延伸扩展内容）

3.1、两个线程同时访问一个对象的同步方法

       2.1.2、方法锁

3.2、两个线程同时访问两个对象的同步方法

两个对象指两个实例 instance1，instance2创建两个线程

/**
 * Created by yan on 2019/2/3.
 */
public class SynchronizedObjectCodeBlok implements Runnable {

    static SynchronizedObjectCodeBlok instance1 = new SynchronizedObjectCodeBlok();
    static SynchronizedObjectCodeBlok instance2 = new SynchronizedObjectCodeBlok();



    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()){  //当t1和t2两个线程都是存活状态时，做空循环

        }
        System.out.println("finished");
    }

    @Override
    public void run() {
        synchronized (this) {
            System.out.println("对象锁代码块形式--" + Thread.currentThread().getName());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "--运行完毕");
        }
        synchronized (this) {
            System.out.println("对象锁代码块形式--" + Thread.currentThread().getName());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "--运行完毕");
        }
    }
}
3.3、两个线程同时访问synchronized的静态方法

       2.2.2.1、synchronized加在static方法上

3.4、两个线程同时访问同步方法和非同步方法

我们设定一个线程访问synchronized的同步方法，另一个线程访问非同步（普通）方法，看代码：

/**
 * Created by yan on 2019/2/4.
 */
public class SynchronizedYesAndNoMethod implements Runnable {

    static SynchronizedYesAndNoMethod instance = new SynchronizedYesAndNoMethod();

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("finished");
    }

    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }else{
            method2();
        }
    }

    //同步方法
    public synchronized void method1(){
        System.out.println("synchronized同步方法--"+Thread.currentThread().getName());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"--线程结束");
    }

    //非同步方法
    public void method2(){
        System.out.println("非同步（普通）方法--"+Thread.currentThread().getName());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"--线程结束");
    }
}

两个线程“同时”开始，“同时”结束，意思就是*非同步方法不受影响

3.5、两个线程访问同一对象的不同的普通同步方法(非static)
/**
 * Created by yan on 2019/2/4.
 */
public class SynchronizedDifferenceMethod implements Runnable {

    static SynchronizedDifferenceMethod instance = new SynchronizedDifferenceMethod();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()){  //当t1和t2两个线程都是存活状态时，做空循环

        }
        System.out.println("finished");
    }

    @Override
    public void run() {
        method1();
        method2();
    }

    public synchronized void method1(){
        synchronized (SynchronizedClassClass.class){
            System.out.println("方法1--"+ Thread.currentThread().getName());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--线程结束");
        }
    }

    public synchronized void method2(){
        synchronized (SynchronizedClassClass.class){
            System.out.println("方法2--"+ Thread.currentThread().getName());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--线程结束");
        }
    }
}

方法1执行完两个线程，才执行方法2

3.6、两个线程同时访问静态synchronized和非静态synchronized方法（重要）
/**
 * Created by yan on 2019/2/4.
 */
public class SynchronizedStaticAndNormal implements Runnable {

    static SynchronizedStaticAndNormal instance = new SynchronizedStaticAndNormal();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()){  //当t1和t2两个线程都是存活状态时，做空循环

        }
        System.out.println("finished");
    }

    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }else{
            method2();
        }
    }

    public static synchronized void method1(){
            System.out.println("static方法1--"+ Thread.currentThread().getName());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--线程结束");
    }

    public synchronized void method2(){
            System.out.println("非static方法2--"+ Thread.currentThread().getName());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--线程结束");
        }
}

“同时”开始，“同时”结束

3.7、方法抛出异常后，会释放锁

不太容易表达，哎，睡觉！！！！！！！

StormEnum
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
static、final关键字、枚举、Synchronized
Shen_Dong的博客
03-28 339
访问修饰符 static 数据类型 变量名;[推荐]static 访问修饰符 数据类型 变量名。final中文意思:最后的,最终的.final可以修饰类、属性、方法和局部变量在某些情况下,程序员可能有以下需求，就会使用到final:1)当不希望类被继承时,可以用final修饰.【案例演示】2)当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字修饰。【案例演示:访问修饰符 final返回类型方法名】
大彻大悟synchronized原理，锁的升级
Curry4ever
11-08 812
前言     Synchronized原理是面试中的一个难点。网上的各种资料太乱了 ，概念晦涩难懂，看了不少资料、博客，花了不少时间，才整理成这篇笔记。看完对你大有帮助。 1、内存布局     要想了解Synchronized的原理，你先必须了解下Java对象内存布局。     我这里就先介绍下Java内存布局。     当你通过关键字new关键字创
深入理解Java枚举类型(enum), 反射机制，注解类型，synchronized同步锁，内存模型JMM volatile，类加载器
qb170217的博客
10-16 660
    1 深入理解Java类型信息(Class对象)与反射机制 2 深入理解Java枚举类型(enum) 3 深入理解Java注解类型(@Annotation) 4 深入理解Java并发之synchronized实现原理 5 深入理解Java内存模型(JMM)及volatile关键字 6 深入理解Java类加载器(ClassLoader)...
java线程多线程同步机制（synchronized）
qq_33866778的博客
12-21 554
java的线程一直是一个让初学者一个头疼不已的问题，反正是当初可能学习的时候比较烦躁，线程这一部分一直没有了解过他的具体概念和用处，参加工作后才学习的这一块相关的知识，呵呵，下面不多少废话了，说正题。        提到java多线程，难免会想到同步。线程的同步是保证多线程安全访问竞争资源的一种手段。 第一： 说到同步，为什么要对多线程访问的方法限制同步？ 很明显，当然是为了避免多个线程统
Java单例设计模式【转】
IT小man学习日记
10-07 1333
懒汉式，线程不安全 当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样教我们的。 1234567891011 public class Singleton { private static Singleton instance; private Singleton (){} public static Singlet
synchronized.md
02-24
关于synchronized的自学笔记
synchronized并发讲解源码.zip
03-16
在Java编程语言中，`synchronized`关键字是一个非常重要的并发控制机制，用于保证多线程环境下的数据一致性。本文将深入解析`synchronized`的工作原理、使用方式以及它在并发编程中的重要性。通过分析提供的源码，...
详解java中的synchronized关键字
09-03
在Java编程语言中，`synchronized`关键字是一个重要的并发控制机制，用于确保多线程环境下的数据一致性。本文将深入探讨`synchronized`关键字的使用和功能。 首先，`synchronized`关键字可以应用于方法和代码块，以...
Java中synchronized正确使用方法解析
08-25
Java 中 synchronized 正确使用方法解析 Java 中 synchronized 关键字是解决线程安全问题的重要手段，它可以确保在多线程环境下，共享资源的访问安全性。本文将详细介绍 Java 中 synchronized 的正确使用方法，通过...
简单了解synchronized和lock的区别
08-25
了解synchronized和lock的区别 synchronized是Java语言中的一个关键字，用于线程同步，主要用于解决多线程之间的竞争问题。它可以将某个方法或代码块锁定，使得只有一个线程可以执行该方法或代码块，其他线程只能...
Java多线程 synchronized底层原理
anying5823的博客
03-27 245
synchronized底层实现 本文转载 https://github.com/farmerjohngit/myblog/issues/12 synchronized简介 Java中提供了两种实现同步的基础语义：synchronized方法和synchronized块， public class SynTest{ public void syncBlock(){ sync...
Synchronized详解（可重入、Monitor原理等）
mulinsen77的博客
03-18 2万+
其他相关文章见：《Lock与synchronized 的区别》 《可重入锁 介绍以及原理》 介绍Synchronized之前，我们先来看一下线程安全的相关概念。 造成线程安全问题的主要诱因有两点，一是存在共享数据(也称临界资源)，二是存在多条线程共同操作共享数据。 因此，引入了互斥锁的概念，即一个共享数据只能被一个线程访问，其他线程需要等待（阻塞），直至当前线程处理完毕释放该锁。 so，synch...
深入理解Java并发之synchronized实现原理
热门推荐
zejian的博客
06-04 40万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/72828483 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深...
Java 多线程同步、死锁问题
StormWangxhu的博客
11-08 746
/** * @author StormWangxhu * @version 创建时间：2017年11月8日 下午15:19:46 * */1、同步代码块当多个线程使用同一个共享资源时，可以将处理共享资源的代码放在一个使用synchronized关键字来修饰的代码块中，这个代码块被称作同步代码块。语法格式如下：synchronized (lock){ 操作共享资源代码块 }解释： lock是一个锁对
一文详解synchronized底层实现原理
多回头看一看
09-19 3058
synchronized底层实现基础知识并发编程的三个问题可见性（1）什么是可见性？（2）实例演示（3）保证可见性方式一：使用`synchronized`加锁方式二：`volatile`修饰共享变量原子性（1）什么是原子性？（2）实例演示（3）保证原子性有序性（1）什么是有序性（2）实例演示（3）`as-if-serial`语义（4）保证有序性`Java`内存模型：`JMM（JavaMemoryModel）`（1）什么是`JMM`?（2）具体实现`计算机的内存模型`：现在开始聊一下`JMM`：规定关系作用.
多线程之互斥锁（synchronized关键字）
g414917512的博客
09-12 4709
synchronized关键字经常被用来做线程互斥锁，但是使用不当的话，经常达不到目的。初学者常对锁住的是对象还是类有疑问。 原理：无论是对象还是类都有唯一的锁，synchronized只是声明了函数调用时需要什么锁，每个锁同一时间只能由一个线程获取，借此实现了线程互斥。 （1）分析对象锁 A.synchronized修饰非静态函数 接下来看实例：public enum Person {
Synchronized的内存可见性
Hunaiyo-黄奕为
04-10 8333
在Java中，我们都知道关键字synchronized可以用于实现线程间的互斥，但我们却常常忘记了它还有另外一个作用，那就是确保变量在内存的可见性 - 即当读写两个线程同时访问同一个变量时，synchronized用于确保写线程更新变量后，读线程再访问该 变量时可以读取到该变量最新的值。 比如说下面的例子： public class NoVisibility { private s

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值