对于synchronized的运行顺序理解

已于 2022-08-11 15:14:10 修改
阅读量1k 收藏 1
点赞数 1
分类专栏： 笔记 文章标签： java
于 2020-11-30 23:32:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49093968/article/details/110411001
版权

文章目录

一、synchronized

同步关键字，分为同步代码块和同步函数

二、对synchronized的理解(未加static关键字)(以下所说：对同步方法和同步代码块均适用)

对象的创建是以类为模板的

1、两个并发的线程访问同一个类Object中的synchronized(this)同步代码块或者同步方法时，同一时间只能执行一个，另一个必须要等待当前线程执行完才能执行(同一个对象：见下面的testSynchronized，分为两个线程，两个线程访问的是一个方法)(一个对象两个线程一个方法)

例子：

public class TestSynchronized {
    public void test1(){
        synchronized(this) {
            System.out.println("1"+this);
            int i = 5; 
             while( i-- > 0) {
                 System.out.println(Thread.currentThread().getName() + " : " + i);  
                 try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
             }
        }
    }
    public static void main(String[] args) {
        final TestSynchronized testSynchronized = new TestSynchronized();
        final TestSynchronized testSynchronized1 = new TestSynchronized();
        Thread thread1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                testSynchronized.test1();
            }
        },"test1");
        Thread thread3 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                testSynchronized.test1();
            }
        },"test3");
        
        thread1.start();
        thread3.start();
    }
}

结果：

在这里插入图片描述

2、两个并发的线程访问同一个类Object中的synchronized(this)同步代码块或者同步方法时，两个交替进行，因为对象的创建是以类为模板的，所以两个对象都会有自己独立的方法(不同对象：testSynchronized和testSynchronized1，分为两个线程，两个线程访问的是一个方法)(两个对象两个线程一个方法)

例子：和第一个的例子相比仅仅修改了第31行

 public class TestSynchronized {
     public void test1(){
         synchronized(this) {
             System.out.println("1"+this);
             int i = 5; 
              while( i-- > 0) {
                  System.out.println(Thread.currentThread().getName() + " : " + i);  
                  try {
                     Thread.sleep(500);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
              }
         }
     }
     public static void main(String[] args) {
         final TestSynchronized testSynchronized = new TestSynchronized();
         final TestSynchronized testSynchronized1 = new TestSynchronized();
         Thread thread1 = new Thread(new Runnable() {
             
             @Override
             public void run() {
                 testSynchronized.test1();
             }
         },"test1");
         Thread thread3 = new Thread(new Runnable() {
             
             @Override
             public void run() {
                 testSynchronized1.test1();
             }
         },"test3");
         thread1.start();
         thread3.start();
     }
 }

复制代码
　　结果：

在这里插入图片描述

3、(两个线程同一对象)当一个线程已经访问了该类中的一个synchronized方法，另一个线程就不能再去访问访问其他的synchronized方法(对象锁是锁住了对象，所以只能执行完这个再去执行另一个)(一个对象两个线程两个方法)

例子：

 public class TestSynchronized {
     public void test1(){
         synchronized(this) {
             System.out.println("1"+this);
             int i = 5; 
              while( i-- > 0) {
                  System.out.println(Thread.currentThread().getName() + " : " + i);  
                  try {
                     Thread.sleep(500);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
              }
         }
     }
     public synchronized void test2(){
         System.out.println(this);
         int i = 5; 
          while( i-- > 0) {
              System.out.println(Thread.currentThread().getName() + " : " + i);  
              try {
                 Thread.sleep(500);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
          }
     }
     public static void main(String[] args) {
         final TestSynchronized testSynchronized = new TestSynchronized();
         final TestSynchronized testSynchronized1 = new TestSynchronized();
         Thread thread1 = new Thread(new Runnable() {
             
             @Override
             public void run() {
                 testSynchronized.test1();
             }
         },"test1");
         Thread thread2 = new Thread(new Runnable() {
             
             @Override
             public void run() {
                 testSynchronized.test2();
             }
         },"test2");
         thread1.start();
         thread2.start();
     }
 }

结果：

在这里插入图片描述

4、(同一个对象)当一个线程已经访问了一个类的synchronized方法，那么另一个线程也可以访问其他的非synchronized方法，结果是交替进行的(一个对象两个线程两个方法[一个synchronized一个非synchronized的])

进行了同步的方法（加锁方法）和没有进行同步的方法（普通方法）是互不影响的，一个线程进入了同步方法，得到了对象锁，其他线程还是可以访问那些没有同步的方法（普通方法）

例子：

public class TestSynchronized {
     public void test1(){
         synchronized(this) {
             System.out.println("1"+this);
             int i = 5; 
              while( i-- > 0) {
                  System.out.println(Thread.currentThread().getName() + " : " + i);  
                  try {
                     Thread.sleep(500);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
              }
         }
     }
         //非synchronized
     public void test2(){
         System.out.println(this);
         int i = 5; 
          while( i-- > 0) {
              System.out.println(Thread.currentThread().getName() + " : " + i);  
              try {
                 Thread.sleep(500);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
          }
     }
     public static void main(String[] args) {
         final TestSynchronized testSynchronized = new TestSynchronized();
         final TestSynchronized testSynchronized1 = new TestSynchronized();
         Thread thread1 = new Thread(new Runnable() {
             
             @Override
             public void run() {
                 testSynchronized.test1();
             }
         },"test1");
         Thread thread2 = new Thread(new Runnable() {
             
             @Override
             public void run() {
                 testSynchronized.test2();
             }
         },"test2");
         
         thread2.start();
         thread1.start();
     }
 }

结果：

在这里插入图片描述

三、加了static后现成的执行

1、对于一个类，一个线程访问了加了static的synchronized方法，另一个线程同样可以访问未加static的synchronized方法，所以结果是交替进行，因为类和对象不同(static修饰后锁住的是类，所有对象共享，而没有加static锁住的是对象，只有每个对象私有)(一个对象一个类两个线程两个方法)

例子：

  public class TestSynchronized {
     public void test1(){
         synchronized(this) {
             int i = 5; 
              while( i-- > 0) {
                  System.out.println(Thread.currentThread().getName() + " : " + i);  
                  try {
                     Thread.sleep(500);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
              }
         }
     }
     public static synchronized void test2(){
         int i = 5; 
          while( i-- > 0) {
              System.out.println(Thread.currentThread().getName() + " : " + i);  
              try {
                 Thread.sleep(500);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
          }
     }
     public static void main(String[] args) {
         final TestSynchronized testSynchronized = new TestSynchronized();
         Thread thread1 = new Thread(new Runnable() {
             
             @Override
             public void run() {
　　　　　　　　　 //对象调用的是该对象自己的方法
                 testSynchronized.test1();
             }
         },"test1");
         Thread thread2 = new Thread(new Runnable() {
             
             @Override
             public void run() {
　　　　　　　　　//类调用的是类方法
                 TestSynchronized.test2();
             }
         },"test2");
         thread2.start();
         thread1.start();
     }
 }

结果：
在这里插入图片描述

2、两个都是被static修饰的synchronized方法，结果是一个线程等待另一个线程执行完才会执行，因为类是一样的(和同一个对象的理解差不多)，方法被synchronized修饰只能一个执行完再执行另一个(一个类两个线程两个方法)

例子：

 public class TestSynchronized {
     public static void test1(){
         synchronized(TestSynchronized.class) {
             int i = 5; 
              while( i-- > 0) {
                  System.out.println(Thread.currentThread().getName() + " : " + i);  
                  try {
                     Thread.sleep(500);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
              }
         }
     }
     public static synchronized void test2(){
         int i = 5; 
          while( i-- > 0) {
              System.out.println(Thread.currentThread().getName() + " : " + i);  
              try {
                 Thread.sleep(500);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
          }
     }
     public static void main(String[] args) {
         final TestSynchronized testSynchronized = new TestSynchronized();
         Thread thread1 = new Thread(new Runnable() {
             
             @Override
             public void run() {
                 TestSynchronized.test1();
             }
         },"test1");
         Thread thread2 = new Thread(new Runnable() {
             
             @Override
             public void run() {
                 TestSynchronized.test2();
             }
         },"test2");
         
         thread2.start();
         thread1.start();
     }
 }

结果：

在这里插入图片描述

补充：
　　面试的一道题：

一个只被synchronized修饰的方法fun()，现有两个对象a,b，分别是两个线程t1，t2

①a.fun()和b.fun()可以同时进行吗？

答:可以，因为是两个为不同的对象，对象的创建是以类为模板的，所以这两个对象中都会有自己的fun()方法,所以两个线程开启后会交替进行，如上面的二2

②回答完可以后，怎么可以让两个分开进行即一个完了之后再进行另一个？

答：给方法加上static关键字,static锁住了类，此时锁为“类锁”，所以虽然对象不一样但是类都是一样的，所以简单说就是一个类两个线程调用一个方法，肯定是一个执行完再执行另一个

-乌鸦
关注
专栏目录
Java synchronized 方法的执行顺序
qq_25817753的博客
04-04 552
public void noSync() { try { for (int i = 0; i < 5; i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName()); } } catch (InterruptedException e) { ...
java 理解synchronized
norang的博客
06-23 392
15.2 理解synchronized 上一节，我们提到，共享内存有两个重要问题，一个是竞态条件， 另一个是内存可见性，解决这两个问题的一个方案是使用synchronized 关键字，本节就来讨论这个关键字。我们先来了解synchronized的用法 和基本原理，然后再从多个角度进一步理解，最后介绍使用 synchronized实现的同步容器及其注意事项。 15.2.1 用法和基本原理 synchronized可以用于修饰类的实例方法、静态方法和代码块，我们分别介绍。 1.实例方法 上节我们介绍了一个计数的
对于synchronized的理解
weixin_30632899的博客
10-08 156
一、synchronized 　　同步关键字，分为同步代码块和同步函数 二、对synchronized的理解(未加static关键字)(以下所说：对同步方法和同步代码块均适用) 　　对象的创建是以类为模板的 　　1、两个并发的线程访问同一个类Object中的synchronized(this)同步代码块或者同步方法时，同一时间只能执行一个，另一个必须要等待当前线程执行完才能执行(同一...
synchronized之同步代码块和同步方法
xun08042的博客
02-25 979
1.synchronized同步关键字 这里涉及到多个线程对共享资源进行处理，这里就必须要给线程“排队”，使用的关键字是synchronized（同步），在程序中，给对共享资源进行处理的代码部分（整个方法或代码块）添加此关键字。相当于给代码块加锁，取得钥匙的线程对资源操作，完成后将钥匙交予其他线程，这保证了同一个资源某一时间内只有一个线程可以对其修改等操作。 同步代码块 synchronized（lock）{ 操作共享资源代码块 } lock是一个锁对象，它是同步代码块的关键。当线程执行同步代码块时，首先
多线程通过synchronized来控制执行顺序
andylao62的专栏
09-11 553
package helloword; import java.util.*; public class Main { private static Object mLock = new Object(); private static Object mLock1 = new Object(); private static Object mLock2 = new Object(); private static Object mLock3 = new Object(); private st.
多线程之synchronized+方法
baidu_15113429的博客
10-26 589
根据前面的多线程之synchronized（this），我们在本实验中做一个对比。前面的博客在不是同一个对象的时候就会出现错误。package thread;public class SynchronizedCode implements Runnable { private int aa; public SynchronizedCode(int aa) { this.
synchronized 的简单理解使用
wxj280306451的博客
12-04 2288
synchronized(this) //此处this指的是进入此代码块的线程对象（也就是那个对象调用了该方法，就表示当前锁是那个对象）,如果t1进来了，那么锁住t1，若t1时间片结束了，t2走到此处也只能在上一句代码处等待t1获得了时间片后执行完synchronized锁住的所有代码，t2才能进去执行，若去掉synchronized(this),则t1和t2随时都可以进来执行此段代码中的任何一步，时间到了另一个接着进来执行 synchronized 修饰方法 用范围是整个方法，所以方法中所有的.
深入理解Synchronized
fancy_Coding的博客
04-18 2513
前言 大家好，我是fancy~ Synchronized想必大家在工作中一定有接触过，它算是Java并发场景下实现多线程安全一种比较直接的操作。有人会说它慢，确实。在JDK1.6之前，它有另一个名称叫做：重量级锁。但是从1.6版本起，它就在不断被优化。现如今已经是很成熟的并发安全技术；所以关于Synchronized的考察也常常成为面试官青睐的话题。 本文我们会使用图解的方式解析Synchronized的使用和原理，让我们开始吧~ 对象锁和类锁 什么是Synchronized？Synchronized是J
深入理解synchronized与volatile关键字
weixin_30484149的博客
10-20 541
在多线程并发编程中synchronized和volatile都扮演着重要的角色，synchronized一直是元老级角色，很多人都会称呼它为重量级锁。但是，随着Java SE 1.6对synchronized进行了各种优化之后，有些情况下它就并不那么重了。而volatile是轻量级的 synchronized，它在多处理器开发中保证了共享变量的“可见性”。 初识synchronized关键字 我们知道当多个线程对共享变量或者资源进行同时访问操作时，会引起线程不安全问题，在JDK1.5以前是通过synch.
Android中synchronized加锁控制主线程和子线程（同步执行、顺序执行）
aidou1314的博客
05-10 1490
参考网址：https://blog.csdn.net/night_dragon/article/details/54409473 https://blog.csdn.net/huanyuminhao/article/details/51960256 1.顺序执行（先让子线程执行完毕，再继续执行主线程） private Object obj = new Object(); private void test(){ new Thread(){ @Override
线程等待与唤醒
m0_59164927的博客
08-16 537
相比方式一synchronized是一种隐式锁，lock锁可以手动上锁和释放，以及可以设置trylock抢锁时间返回抢锁的结果，锁更加灵活。LockSupport park方法需要一个凭证，如果当前线程没有凭证，就会处于休眠状态,直到unpark(线程对象)给线程发放凭证(如果当前线程没有该对象的监视器锁时会抛出这个异常,由于线程一注释了synchronized锁，所以未持有对象的监视器锁。可以先唤醒在等待，也可以保证线程一的执行,先唤醒时，首先颁发了一个凭证，park时直接消费。...
java synchronized 顺序_Java 中 synchronized的用法详解(四种用法)
weixin_36263738的博客
02-16 558
1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.这时,线程获得的是成员锁,即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入.例如:2.对某一代码块使用,synchronized后跟括号,括号里是变量,这样,一次只有一个线程进入该代码块.此时,...
Java多线程-并发编程锁Synchronized和Lock
Mr.xing的博客
03-10 3709
线程安全的两个方面一个是执行控制和内存可见。执行控制的目的是控制代码执行顺序以及是否可以并发执行，内存可见控制的是线程执行结果在内存中对其它线程的可见性。根据Java内存模型的实现，线程在具体执行时，会先拷贝主存数据到线程本地（CPU缓存），操作完成后再把结果从线程本地刷到主存。
java三个线程如何做到顺序执行
最新发布
weixin_39304656的博客
06-11 1045
在 Java 中，要控制三个线程的执行顺序，可以使用多种方法，其中包括使用wait和notify机制，，以及Semaphore等。下面我将展示这些方法的具体实现。
并发编程基础 - synchronized使用场景和等待唤醒机制的正确姿势
it_lihongmin的博客
10-22 990
在理解完synchronized关键字反汇编之后信息，基于内存屏障解决了可见性和有序性，再基于MESA管程模型解决了线程的互斥和同步，并且顺便将执行的过程封装起来，中间状态对外不可见，解决了原子性。重点是理解管程模型是理解synchronized使用的关键，也理解了其模型，如图： 1、synchronized使用场景 1）、普通方法（锁的的对象，当同一个对象的多个synchronized方法才互斥） 该使用场景比较多，比如SringBuffer的几乎所以方法： 2）、静态方...
synchronized两个用法
Megetood的博客
07-25 199
对象锁 方法锁（synchronized修饰普通方法，默认对象为this当前实例对象） 同步代码块锁（自己制定锁对象） 类锁 synchronized修饰的静态的方法或指定锁为Class对象 对象锁： 应用：同一对象多个线程访问 类锁： java类可能有很多个对象，但是只有一个Class对象，也就是Class对象的锁 类锁只能在同一时刻被一个对象拥有 形式1：synchronized加在stati...
java多线程-synchronized(二)
makeliwei1的博客
07-07 113
搬运文章 具体请看下面这位大佬的文章，写得真好 http://www.cnblogs.com/xrq730/p/4851350.html 一、线程访问不同的synchronized(this) package java_lang_Object; /** * Created by luckyboy on 2018/7/7. */ public class SynchronizedT...
多线程锁（synchronized 锁的执行顺序、公平锁和非公平锁）
qq_51985869的博客
06-06 602
非公平锁：效率高，但是线程容易饿死（所有的工作，有一个线程完成）公平锁：效率相对低 ，但是cpu 的利用高了。可以有多把同步锁，但只能有一把静态同步锁。多线程 多对象 多把对象锁，之间互不干扰。一个线程即一个对象，所以只有一把对象锁。同步锁间互不干扰，静态同步锁按顺序执行。一个线程即一个类，所以只有一把类锁。只能有一把同步锁，一把静态同步锁。多线程属于同个类，只有一把类锁。一个线程就一个对象，一个类。多线程即多个对象，同个类；对象级别，一个对象一把锁。两把锁，之间互不干扰。类级别，一个类一把锁。
理解Java中synchronized与Volatile的关键区别与用法
- 文档提到的"as-if-serial"模型是一种并发模型，它描述了Java虚拟机如何对线程进行调度，确保程序看起来像是按顺序执行的，即使实际上多个线程并发运行。 5. **类级别的同步与实例级别的同步**： - 类级别的同步...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值