synchronized使用情况

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量245 收藏
点赞数 1
分类专栏： synchronized 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunstaday/article/details/107473660
版权

synchronized

未加static关键字

1）一对象两线程一方法【等待执行】

两个并发的线程访问同一个类Object中的synchronized同步代码块或者同步方法时，同一时间只能执行一个线程，另一个线程必须等待当前线程执行完才能执行。

import java.util.concurrent.TimeUnit;
public class Sync {
    public synchronized void test1(){
            for ( int i = 0; i < 5; i++) {
              System.out.println(Thread.currentThread().getName() + " " + i);
            }
            try {
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    }
    public static void main(String[] args) {
        Sync sync = new Sync();
        Thread thread1 = new Thread("线程A"){
            @Override
            public void run() {
                sync.test1();
            }
        };
        Thread thread2 = new Thread("线程B"){
            @Override
            public void run() {
                sync.test1();
            }
        };
        thread1.start();
        thread2.start();
    }
}

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

2）两对象两线程一方法【交替执行】

对象的创建是以类为模板，两个对象都有自己独立的方法，不同对象，分为两个线程，两个线程访问同一个方法，他们交替进行。

import java.util.concurrent.TimeUnit;

public class Sync {
    public synchronized void test1(){
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Sync sync = new Sync();
        Sync sync1 = new Sync();
        Thread thread1 = new Thread("线程A"){
            @Override
            public void run() {
                sync.test1();
            }
        };
        Thread thread2 = new Thread("线程B"){
            @Override
            public void run() {
                sync1.test1();
            }
        };
        thread1.start();
        thread2.start();
    }
}

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

3）一对象两线程两方法【等待执行】

当一个线程访问了该类中的一个synchronized方法，另一个线程就不能再去访问其他的synchronized方法，只能执行完这一个再去继续执行。

import java.util.concurrent.TimeUnit;


public class Sync {
    public synchronized void test1(){
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void test2(){
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Sync sync = new Sync();
        Sync sync1 = new Sync();
        Thread thread1 = new Thread("线程A"){
            @Override
            public void run() {
                sync.test1();
            }
        };
        Thread thread2 = new Thread("线程B"){
            @Override
            public void run() {
                sync.test2();
            }
        };
        thread1.start();
        thread2.start();
    }
}

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

4）一对象两线程两方法（有一非synchronized方法）【交替执行】

同一对象，当一个线程访问了一个类的synchronized方法，另一个对象访问其他的非synchronized方法，两个线程交替进行。

import java.util.concurrent.TimeUnit;


public class Sync {
    public synchronized void test1(){
        System.out.println(this);
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public  void test2(){
        System.out.println(this);
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Sync sync = new Sync();
        Sync sync1 = new Sync();
        Thread thread1 = new Thread("线程A"){
            @Override
            public void run() {
                sync.test1();
            }
        };
        Thread thread2 = new Thread("线程B"){
            @Override
            public void run() {
                sync.test2();
            }
        };
        thread1.start();
        thread2.start();
    }
}

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

加static关键字

5）一类一对象两线程两方法（一个方法static修饰，一个没有）【交替执行】

同一个类中，一个线程访问了加static的synchronized方法，另一个线程可以访问未加static修饰的synchronized方法，他们交替进行，因为static修饰后锁住的是类，所有对象共享，而没有加static锁住的是对象，只有每个对下那个私有。

import java.util.concurrent.TimeUnit;


public class Sync {
    public synchronized void test1(){
        System.out.println(this);
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static synchronized void test2(){
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Sync sync = new Sync();
        Sync sync1 = new Sync();
        Thread thread1 = new Thread("线程A"){
            @Override
            public void run() {
                sync.test1();
            }
        };
        Thread thread2 = new Thread("线程B"){
            @Override
            public void run() {
                //类调用类方法
                Sync.test2();
            }
        };
        thread1.start();
        thread2.start();
    }
}

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

6）一类两线程两方法【等待执行】

两个都被static修饰的synchronized方法，一个线程只能等待另一个线程执行完成后才能执行。

import java.util.concurrent.TimeUnit;


public class Sync {
    public static synchronized void test1(){
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static synchronized void test2(){
        for ( int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Thread thread1 = new Thread("线程A"){
            @Override
            public void run() {
                Sync.test1();
            }
        };
        Thread thread2 = new Thread("线程B"){
            @Override
            public void run() {
                //类调用类方法
                Sync.test2();
            }
        };
        thread1.start();
        thread2.start();
    }
}

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

SunStaday
关注
专栏目录
Java - 反射机制中，在静态方法上加synchronized，同步对象是什么？
sara_211的博客
03-26 1140
输出是最好的输入，做一个Java学习记录~ 在对象方法前，加上修饰符synchronized，同步对象是当前实例，也就是this啦 那么如果在类方法前，加上修饰符sunchronized，同步对象是什么呢？ 当synchronized修饰静态方法的时候，同步对象就是这个类的类对象。 代码验证如下： package reflection; public class TestReflec...
synchronized失效的情况
qq_33409840的博客
12-08 2561
1.在spring的事务中使用synchronized，会导致锁失效的： 底层的原因是如下的：transaction方法的调用对象是当前对象的代理对象的，而synchronized对应的锁定的是当前对象的，两者完全不是同样的一个对象的，所以，此时transaction对应的是失效的。 示例1：下面是事务失效的代码的 public class DemoServiceImpl { @Autowired private DemoDao demoDao; // 根据id获取序列号，获取完之后进行 + 1 @Tran
各种情况下使用synchronized的差别
风团团
09-04 373
这里不做原理分析，列举了7种情况，意在我们使用synchronized时更加有底气 。下面的情况都是围绕这个姑且称为定理的东西来讲的 synchronized作用于方法上，有static的修饰时锁定的是调用这个方法的对象 无static修饰时锁定的是拥有这个方法的类的class 情况1 public class test02 { public static void main(String[] args) { data data1 = new data(); data
Synchronized 同步出现失效
技术基地
05-29 6727
Synchronized 同步出现失效 Synchronized ，大家都知道这个是Java 提供的一种原子性内置锁，其实现原理是通过获取对象的监视器monitor进行来实现同步的，只有当线程获取到对象monitor才能继续执行，否则该线程进行阻塞(等待)。 示例: public class DemoServiceImpl { @Autowired private D...
Java线程同步
zhicheng_angle的博客
07-28 307
package work2; public class SynchronizedTest implements Runnable { int num = 50; @Override public void run() { // TODO Auto-generated method stub while(true) { ...
Synchronized-锁失效问题剖析
Fong灵
11-08 2802
线程锁-Synchronized
Synchronized 和 Lock 的区别和使用场景
01-20
总结来说，`synchronized`和Lock各有优势，前者使用简单，适用于大多数情况，而后者提供了更高级的功能，适合需要精细控制的并发编程。选择哪种锁机制应根据具体需求和性能考虑。在实际开发中，合理地使用锁机制可以...
Java中使用synchronized关键字实现简单同步操作示例
09-03
下面将详细介绍`synchronized`关键字的三种使用方式：修饰函数、修饰代码块以及修饰静态方法。 1. **synchronized 修饰函数** 当`synchronized`修饰非静态方法时，它会锁定当前对象实例。这意味着，对于同一个对象...
Java多线程中使用synchronized说明
12-22
使用`synchronized`时，需要警惕死锁和活锁的情况。死锁是指两个或多个线程相互等待对方释放资源，导致它们都无法继续执行。活锁则是线程虽然没有阻塞，但由于某种原因不断重试导致无法继续执行。 7. **可重入性**...
Java使用synchronized实现互斥锁功能示例
08-19
Java使用synchronized实现互斥锁功能示例 在Java编程语言中，synchronized关键字是实现互斥锁功能的主要手段。互斥锁是一种机制，用于控制多个线程访问共享资源的顺序，从而避免因为资源竞争而导致的程序错误。在...
Synchronized锁失效的几种情况
我就说我500的博客
10-27 4890
Synchronized锁失效的几种情况
Synchronized 同步出现失效的问题
jyworker_1313的博客
12-17 731
Synchronized 同步出现失效的问题
java synchronized同步方法调用另一个同步方法，锁机制问题
EnjoyInwind的专栏
07-09 5109
要明白两个问题，1.锁的对象是谁，2.谁持有了锁。 假设方法A和B是在同一个类Test中的两个方法。 Test t=new Test(); t.methodB(); 这个时候，methodB方法被调用时，因为加了synchronized ，需要先获得一个锁，这个锁的对象应该是t，也就是当前的这个Test类的实例，而获得锁的东西是线程，也就是说当前线程拿到了t的锁（而不是你说的B方
Java Synchronized 详解
zcyhappy1314的专栏
05-19 610
以下内容是我的摘抄和理解，想学习 synchronized 用法，戳这里就可以了。synchronied ： java 中的一个关键字，是一种同步锁，其主要作用就是用来保证在同一时刻最多只有一个线程执行 synchronied 修饰的代码。根据其修饰对象不同，其锁的范围不同，其修饰对象有以下几种： 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这
一个对象的多个synchronized方法多个线程调用
热门推荐
LMR的博客
05-29 1万+
今天遇到一个笔试题，说的是：当一个线程进入一个对象的synchronized方法之后，其它线程能否进入该对象的其他方法？ 答：很明显当其它方法是非synchronized方法时，调用是不受影响的，但当其它方法也是synchronized方法时呢？接下来我们进行实验验证： class Test{ public synchronized void synchronizedMethod...
同一个类里面两个synchronized方法，两个线程同时访问的问题
suncat的博客
07-29 9395
代码如上所示，MyObject类有两个方法，分别创建两个线程调用方法A和方法B： 会有以下几种情况： 1、两个方法都没有synchronized修饰，调用时都可进入：方法A和方法B都没有加synchronized关键字时，调用方法A的时候可进入方法B； 2、一个方法有synchronized修饰，另一个方法没有，调用时都可进入：方法A加synchronized关键字而方法B没有加...
synchronized使用的正确姿势
蜕变的快乐
07-28 1671
synchronized关键字在java中是用作线程同步的，保障同步区代码的正确执行，同一时间仅有一个线程进入同步区，其原理是使用锁技术，通过竞争，得到锁的线程执行同步区代码，未得到锁的线程自旋、阻塞等待。下面分为四个部分来对synchronized进行分析： 三种使用方式 实例讲解 单例中的使用 原理浅析 请您站稳扶好，开车了… 三种使用方式 分别是修饰实例方法，修饰静态方法，修饰代码块...
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 224
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 464
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
synchronized使用
09-06
在Java中，synchronized关键字用于实现线程之间的同步。它可以应用于方法或代码块上。在方法上使用synchronized关键字，可以确保同一时间只有一个线程可以访问该方法。而在代码块上使用synchronized关键字，可以确保同一时间只有一个线程可以访问被同步的代码块。 在引用中，演示了在同步代码块中使用synchronized关键字的情况。在SynchronizedDemo类的method方法中，使用synchronized关键字来同步代码块，以保证线程安全。 引用展示了子类继承父类，并重写了同步方法的情况。在SynchronizedUsageChild类的synchronizedMethod1方法中，通过使用synchronized关键字来同步方法，确保在多线程环境下，同一时间只有一个线程可以访问该方法。在该方法中，还演示了可重入锁的概念，即子类在同步方法中调用父类的同步方法。 总结来说，synchronized关键字用于实现线程之间的同步，可以应用于方法或代码块上，以确保多线程环境下的线程安全性。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [Synchronized 详解](https://blog.csdn.net/qq_43322057/article/details/104258758)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 33.333333333333336%"] - *2* [Java synchronized使用案例](https://download.csdn.net/download/visionliao/8368107)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 33.333333333333336%"] - *3* [synchronized用法详解](https://blog.csdn.net/ganmaotong/article/details/124501478)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 33.333333333333336%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值