Synchronized在不同位置的用法

最新推荐文章于 2023-05-24 15:33:33 发布
最新推荐文章于 2023-05-24 15:33:33 发布
阅读量1.7k 收藏 8
点赞数 6
分类专栏： java 文章标签： java 锁 synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43167873/article/details/121578654
版权

目录

介绍

Synchronized是java内置的一个关键字，是一种同步锁，可以用有几种用法：

  • 修饰一个代码块，被修饰的代码块称为同步代码块；
  • 修饰一个实例方法，被修饰方法称为同步方法，作用范围为整个方法本身，作用对象为调用这个方法的实例对象；
  • 修饰一个静态方法，其作用范围是整个静态方法，作用的对象为这个类（个人理解：因为静态方法是通过类名.的方式调用的，所以Synchronized锁的是整个类而不是对象）；
  • 修饰一个类，其作用范围是synchronized后面括号的部分，作用的对象是这个类的所有对象。

修饰一个代码块

synchronized (this){//this,锁
    //同步代码块；
}

例子：创建一个对象时，使用synchronized时

package Synchronized;

public class Demo01 {
    public static void main(String[] args) {
        Syc syc = new Syc();
        Thread thread1 = new Thread(syc,"t1");
        Thread thread2 = new Thread(syc,"t2");
        thread1.start();
        thread2.start();
    }
}
class Syc implements Runnable{
    private static  int count;

    public Syc() {
        count = 0;
    }

    @Override
    public void run() {
        synchronized (this){
            for (int i =0; i< 5;i++){
                try {
                    System.out.println("线程" + Thread.currentThread().getName() + "," + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static int getCount() {
        return count;
    }
}

image-20211127151844347

创建一个对象时，不使用Synchronized

package Synchronized;

public class Demo01 {
    public static void main(String[] args) {
        Syc syc = new Syc();
        Thread thread1 = new Thread(syc,"t1");
        Thread thread2 = new Thread(syc,"t2");
        thread1.start();
        thread2.start();
    }
}
class Syc implements Runnable{
    private static  int count;

    public Syc() {
        count = 0;
    }

    @Override
    public void run() {
            for (int i =0; i< 5;i++){
                try {
                    System.out.println("线程" + Thread.currentThread().getName() + "," + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        
    }

    public static int getCount() {
        return count;
    }
}

image-20211127151926731

Thread2必须等到Thread1执行完毕之后，释放锁，才可以执行并获得这个锁

创建两个对象使用synchronized时

package Synchronized;

public class Demo01 {
    public static void main(String[] args) {
        Syc syc = new Syc();
        Syc syc1 = new Syc();
        Thread thread1 = new Thread(syc,"t1");
        Thread thread2 = new Thread(syc1,"t2");
        thread1.start();
        thread2.start();
    }
}
class Syc implements Runnable{
    private static  int count;

    public Syc() {
        count = 0;
    }

    @Override
    public void run() {
        synchronized (this){
            for (int i =0; i< 5;i++){
                try {
                    System.out.println("线程" + Thread.currentThread().getName() + "," + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static int getCount() {
        return count;
    }
}

image-20211127152319856

因为创建了两个Syn的对象，两个线程执行的是两个对象的run方法lsynchronized锁定是的this这个对象，这时候因为创建了两个对象会有两把锁，分别锁定thread1和thread2，两把锁互不干扰，所以可以同时执行

当一个线程访问synchronized代码块是，另一个线程访问不带有synchronized时

package Synchronized;

public class Demo02 {
    public static void main(String[] args) {
        Syc2 syc = new Syc2();
        Thread thread1 = new Thread(syc,"t1");
        Thread thread2 = new Thread(syc,"t2");
        thread1.start();
        thread2.start();
    }
}
class Syc2 implements Runnable{
    private static  int count;

    public Syc2() {
        count = 0;
    }

    public void add(){
        synchronized (this){
            for (int i =0; i< 5;i++){
                try {
                    System.out.println("线程" + Thread.currentThread().getName() + "," + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void print(){
        for (int i =0; i< 5;i++){
            try {
                System.out.println("线程" + Thread.currentThread().getName() + "," + count);
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    @Override
    public void run() {
       String thraedstr = Thread.currentThread().getName();
       if (thraedstr.equals("t1")){
           add();
       }else if (thraedstr.equals("t2")){
           print();
       }
    }

    public static int getCount() {
        return count;
    }
}

image-20211127153230323

thread1访问带有synchronized代码块时，thread2可以访问不带有synchronied的代码块，不会受到阻塞

修饰一个实例方法

public synchronized void method(){

}

注意：synchronized关键字修饰的方法不能被继承

虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。这两种方式的例子代码如下：
在子类方法中加上synchronized关键字

class Parent {
   public synchronized void method() { }
}
class Child extends Parent {
   public synchronized void method() { }
}

class Parent {
   public synchronized void method() {   }
}
class Child extends Parent {
   public void method() { super.method();   }
}

定义接口时不能使用Synchronized

构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。

修饰一个静态方法

public synchronized static void method(){

}

使用synchronized时

package Synchronized;

public class Demo03 {
    public static void main(String[] args) {
        Syn3 syn3 = new Syn3();
        Thread thread1 = new Thread(syn3,"t1");
        Thread thread2 = new Thread(syn3,"t2");
        thread1.start();
        thread2.start();
    }
}
class Syn3 implements Runnable{
    private static int count;

    public Syn3() {
        count =0;
    }

    public static int getCount() {
        return count;
    }

    public synchronized static void add(){
        for (int i =0; i< 5; i++){
            try {
                System.out.println("线程" + Thread.currentThread().getName() + "," + (count++));
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    @Override
    public void run() {
        add();
    }
}

image-20211127154626814

Thread1和Thread2是Syn3的两个线程，但在thread1和thread2并发执行时却保持了线程同步。这是因为run中调用了静态方法method，而静态方法是属于类的，所以Thread1和Thread2相当于用了同一把锁。这与使用关键字synchronized运行结果相同

修饰一个类

class ClassN {
    public void method() {
        synchronized(ClassN.class) {

        }
    }
}

package Synchronized;

import java.util.ArrayList;
import java.util.List;

public class Demo04 {
    public static void main(String[] args) {
        Sync sync = new Sync();
        Thread thread1 = new Thread(sync, "Thread1");
        Thread thread2 = new Thread(sync, "Thread2");
        thread1.start();
        thread2.start();
    }
}

class Sync implements Runnable {
    private static int count;

    public Sync() {
        count = 0;
    }

    public static void method() {
        synchronized(Sync.class) {
            for (int i = 0; i < 5; i ++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public synchronized void run() {
        method();
    }
}

image-20211127155124408

和静态方法一样，synchronized作用于一个类的时候，是给这个类加了一把锁

总结：

  • 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
  • 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
  • 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制

Synchronized放在不同的位置总结代码

package ThreadExam1;
/*
t2不需要等到t1执行，只有doSome有锁
*/

public class Test01 {
    public static void main(String[] args) {
        M m = new M();
        Thread t1 = new MyThread(m);
        Thread t2 = new MyThread(m);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        try {
            Thread.sleep(1000);//保证t1线程先执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();

    }

}
class MyThread extends Thread{
    private M m;
    public MyThread(M m){
        this.m = m;
    }
    public void run(){
        if(Thread.currentThread().getName() == "t1"){
            m.doSome();
        }
        if(Thread.currentThread().getName() == "t2"){
            m.doOther();
        }

    }

}
class M {
    public synchronized void doSome(){//线程安全的方法
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000*10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }
    public void doOther(){//非线程安全的方法
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

package ThreadExam2;
/*
t2需要等t1执行结束，doSome和doOther都是this这把锁
*/

public class Test01 {
    public static void main(String[] args) {
        M m = new M();
        Thread t1 = new MyThread(m);
        Thread t2 = new MyThread(m);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        try {
            Thread.sleep(1000);//保证t1线程先执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();

    }

}

class MyThread extends Thread{
    private M m;
    public MyThread(M m){
        this.m = m;
    }
    public void run(){
        if(Thread.currentThread().getName() == "t1"){
            m.doSome();
        }
        if(Thread.currentThread().getName() == "t2"){
            m.doOther();
        }

    }

}

class M {
    public synchronized void doSome(){//锁 是 this
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000*10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }
    public synchronized void doOther(){//锁 是 this
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

package ThreadExam3;
/*
两个线程对象，所以t2不需要等t1执行
*/
public class Test01 {
    public static void main(String[] args) {
        M m = new M();
        M m1 = new M();
        Thread t1 = new MyThread(m);
        Thread t2 = new MyThread(m1);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        try {
            Thread.sleep(1000);//保证t1线程先执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();

    }

}

class MyThread extends Thread{
    private M m;
    public MyThread(M m){
        this.m = m;
    }
    public void run(){
        if(Thread.currentThread().getName() == "t1"){
            m.doSome();
        }
        if(Thread.currentThread().getName() == "t2"){
            m.doOther();
        }

    }

}

class M {
    public synchronized void doSome(){//锁 是 this
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000*10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }
    public synchronized void doOther(){//锁 是 this
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

package ThreadExam4;
/*
静态方法是类锁，所以t2需要等t1执行
*/
public class Test01 {
    public static void main(String[] args) {
        M m = new M();
        M m1 = new M();
        Thread t1 = new MyThread(m);
        Thread t2 = new MyThread(m1);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        try {
            Thread.sleep(1000);//保证t1线程先执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();

    }

}

class MyThread extends Thread{
    private M m;
    public MyThread(M m){
        this.m = m;
    }
    public void run(){
        if(Thread.currentThread().getName() == "t1"){
            m.doSome();
        }
        if(Thread.currentThread().getName() == "t2"){
            m.doOther();
        }

    }

}

class M {
    public synchronized static void doSome(){//锁 是 this
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000*10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }
    public synchronized static void doOther(){//锁 是 this
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}
    m.doSome();
        }
        if(Thread.currentThread().getName() == "t2"){
            m.doOther();
        }

    }

}

class M {
    public synchronized static void doSome(){//锁 是 this
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000*10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }
    public synchronized static void doOther(){//锁 是 this
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}
小七rrrrr
关注
  • 6
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
synchronized 应用于静态方法
Steve Guo
09-23 892
多线程 synchronized 静态方法
synchronized 用法总结
热门推荐
a999wt的专栏
08-30 2万+
synchronized用到不同地方对代码产生的影响： 1. synchronized关键字修饰方法 假设P1、P2是同一个类的不同对象，这个类中定义了以下几种情况的同步块或同步方法，P1、P2就都能够调用他们。 public synchronized void method(){     //  } 这也就是同步方法，那这时synchronized锁定的是调用这个同步方法对象。也就
synchronized不同位置的实现原理
qq_36707152的博客
11-25 559
1、synchronized加在不同位置的区别 普通同步方法，锁的是当前实例对象 对于同步代码块，锁的是Synchronized括号中的代码块 静态同步方法，锁的是当前Class对象 2、synchronized加在不同位置的实现方式 1、不用锁 首先用一个简单的代码来测试一下，有啥区别，首先是不加锁的正常代码，代码如下： public class Test { public static void main(String[] args) { new Test()
【多线程】synchronized的位置总结
wjx_jasin的博客
09-14 1128
在JAVA中synchronized关键字可以加载很多位置。您可以在一个方法定义上加synchronized关键字、也可以在方法体中加synchronized关键字、还可以在static块中加synchronized关键字。如下的代码都是正确的： // 代码片段1 static { synchronized(ThreadLock.class) { } } // 代码片段2 ...
关于多线程中synchronized的使用位置
光耀天下
12-23 1715
在练习多线程之售票的时候，对于synchronized的使用有些困惑，因为我是用以下代码： public class ThreadDemo5 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub saleTicket_5 st =
Java中synchronized正确使用方法解析
08-25
Java 中 synchronized 正确使用方法解析 Java 中 synchronized 关键字是解决线程安全问题的重要手段，它可以确保在多线程环境下，共享资源的访问安全性。本文将详细介绍 Java 中 synchronized 的正确使用方法，通过...
java里面synchronized用法.doc
05-09
synchronized 关键字不能被继承，即基类的 synchronized 方法在继承类中不自动变成 synchronized 方法。例如： ```java public class MyClass { public synchronized void myMethod() { // ... } } public class...
如何在JAVA中使用Synchronized
08-19
以下是关于`synchronized`在Java中使用的详细解释： 1. **修饰代码块**： 当`synchronized`关键字用于修饰一个代码块时，它创建了一个同步语句块。例如： ```java synchronized(this) { // 代码块 } ``` 在...
Java 中 synchronized的用法详解(四种用法)
09-03
在这个例子中，`a1` 是锁对象，不同线程可以同时访问 `sharedVar`，只要它们不同时访问包含 `synchronized` 代码块的部分。 3. **锁定对象实例**： 当 `synchronized` 后面跟一个对象时，线程获取的是该对象的锁...
java synchronized用法详解
09-01
本文将深入探讨`synchronized`的使用方法、工作原理以及相关示例。 1. **基本用法** `synchronized`可以修饰方法或代码块，确保同一时间只有一个线程能执行特定的代码。对于方法，只需在方法声明前加上`...
synchronized修饰不同位置的作用
alwaysBrother的博客
03-31 2293
synchronized修饰不同位置的作用 例1：修饰多个方法 public class SynchronizedTest { public static void main(String[] args) { Hello hello = new Hello(); new Thread(hello::printA, "线程A").start(); ...
synchronized的位置该怎么放?
3k油：知道的越多，不知道的越多
12-01 1026
（1）疑问:synchronized的位置应该怎么放? 实现接口的线程类 // 苹果对象实现Runnable接口 class Apple implements Runnable{ private int num = 50; @Override public void run() { for (int i = 0; i < 50; i++) { ...
【Java】解析synchronized中的锁对象
qq_43243800的博客
05-24 490
synchronized中的锁对象解析
【并发】java中synchronized各种加锁场景的作用范围
sfh2018的博客
08-10 1204
java中synchronized的加锁场景
synchronized 锁加的地方的说明
kzcming的博客
06-08 1366
synchronize 锁加的地方的说明 传统mvc 分层模式下,事务一般是加在service 服务层 加锁地方不同: 1. 加在controller 层: 如果锁的代码的最终流程是数据入库,事务和数据库操作也能及时执行 系统设置: springboot 架构,mysql 数据库,事务加在 service 层, 使用了mybatisPlus 框架 2. 加在service 层: 也能按照预想的来执行,但由于事务一般是加在service 层,可能会造成锁的代码确实是按预想的来执行,但是事务数据库
Java关于Synchronized关键字在不同位置使用的理解
技海拾贝
03-10 4126
Java中的Syncronized关键字可以用来修饰同步方法：像这样synchronized void f() {/*body*/}和同步语句块：像这样synchronized(object){/*body*/}。 其中修饰同步方法可以分为修饰static方法和实例方法。 其中修饰同步语句块还可以分为修饰instance变量，Object Reference对象引用，class 字面常量。
Synchronized锁
T_karine的博客
12-06 3458
Synchronized锁原理及锁的升级过程
Java中Synchronized修饰不同位置的用法
ivalue的博客
11-23 4784
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是
[java] synchronized关键字用法及实现原理详解
topdeveloperr的博客
06-07 6613
目录 synchronized修饰方法 synchronized代码块 static静态synchronized方法与synchronized(class)代码块对比 synchronized底层实现原理 同步代码块实现原理 同步方法实现原理 线程私有的变量 锁重入是什么？如何实现的？ Synchronized优化 自旋锁 锁消除 锁粗化 偏向锁 轻量级锁 Synch...
synchronized 在impl 层使用案例
最新发布
05-27
在 impl 层中，我们可以使用 synchronized 关键字来实现多线程同步，以确保线程安全。 下面是一个简单的示例，演示了如何在 impl 层中使用 synchronized 关键字： ``` public class MyServiceImpl implements ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小七rrrrr

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值