Java关键字synchronized

最新推荐文章于 2024-06-14 14:08:37 发布
最新推荐文章于 2024-06-14 14:08:37 发布
阅读量92 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/Vaxy/p/11413430.html
版权

目录

Java关键字synchronized

一、用途

synchronized可以实现线程同步，保证线程安全。被synchronized修饰的代码块或方法在同一时刻只允许一个线程进入临界区。

二、用法

  1. 修饰普通方法，即同步方法
  2. 修饰静态方法，即静态同步方法
  3. 修饰代码块，即同步代码块

三、例子

1、同步方法

代码中用synchronized修饰了method，启动线程t0和线程t1。我们的预期结果是某一线程进入临界区，另一个线程在等待。进入临界区的线程睡眠2s后退出临界区，另一个线程再进入临界区。

public class Sync {
    
    public synchronized void method() {
        System.out.println(Thread.currentThread().getName() + ": in");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": out");
    }
    
    public static void main(String[] args) {
        final Sync s = new Sync();
        Thread t0 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                s.method();
            }
        });
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                s.method();
            }
        });
        t0.start();
        t1.start();
    }
    
}

运行结果：

1496348-20190826163958011-714855622.gif

可以看到是预期的结果。

现在只有一个方法，下面我们测试一下多个方法。

public class Sync {
    
    public synchronized void method1() {
        System.out.println(Thread.currentThread().getName() + ": in method1");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": out method1");
    }
    
    public void method2() {
        System.out.println(Thread.currentThread().getName() + ": in method2");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": out method2");
    }
    
    public static void main(String[] args) {
        final Sync s = new Sync();
        Thread t0 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                s.method1();
            }
        });
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                s.method2();
            }
        });
        t0.start();
        t1.start();
    }
    
}

现在有两个方法分别是method1和method2，method1是由synchronized修饰的，method2则是一个普通方法。

来看一下运行结果：

1496348-20190826164006797-1303595085.gif

似乎并不影响其他线程调用对象的非synchronized修饰的方法。

那么如果两个方法都是synchronized修饰的方法呢？

public class Sync {
    
    public synchronized void method1() {
        System.out.println(Thread.currentThread().getName() + ": in method1");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": out method1");
    }
    
    public synchronized void method2() {
        System.out.println(Thread.currentThread().getName() + ": in method2");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": out method2");
    }
    
    public static void main(String[] args) {
        final Sync s = new Sync();
        Thread t0 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                s.method1();
            }
        });
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                s.method2();
            }
        });
        t0.start();
        t1.start();
    }
    
}

1496348-20190826164013448-1586796867.gif

看到运行结果我们会发现同一个对象的两个被synchronized修饰的不同方法不能同时被调用。

再试试不同对象

public class Sync {
    
    public synchronized void method1() {
        System.out.println(Thread.currentThread().getName() + ": in method1");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": out method1");
    }
    
    public synchronized void method2() {
        System.out.println(Thread.currentThread().getName() + ": in method2");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": out method2");
    }
    
    public static void main(String[] args) {
        final Sync s0 = new Sync();
        final Sync s1 = new Sync();
        Thread t0 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                s0.method1();
            }
        });
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                s1.method1();
            }
        });
        t0.start();
        t1.start();
    }
    
}

1496348-20190826164026653-973768629.gif

从运行结果可以看出调用不同对象的method1()方法是可以同时调用的。

那么不同对象的不同名字的方法依然是互不影响的。
1496348-20190826164034314-375307427.gif

那么是不是可以总结得到：synchronized修饰普通方法的时候是对对象进行加锁，即对象锁。

2、静态同步方法

把method1和methd2都改成静态方法，两个线程都去调用method1。

public class Sync {
    
    public static synchronized void method1() {
        System.out.println(Thread.currentThread().getName() + ": in method1");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": out method1");
    }
    
    public static synchronized void method2() {
        System.out.println(Thread.currentThread().getName() + ": in method2");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": out method2");
    }
    
    public static void main(String[] args) {
        Thread t0 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                Sync.method1();
            }
        });
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                Sync.method1();
            }
        });
        t0.start();
        t1.start();
    }
    
}

1496348-20190826164047866-688670215.gif

两个线程调用method1不能同时进入临界区，只有等到一个退出临界区后另一个才能进入。

再试试调用不同静态方法。

public class Sync {
    
    public static synchronized void method1() {
        System.out.println(Thread.currentThread().getName() + ": in method1");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": out method1");
    }
    
    public static synchronized void method2() {
        System.out.println(Thread.currentThread().getName() + ": in method2");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": out method2");
    }
    
    public static void main(String[] args) {
        Thread t0 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                Sync.method1();
            }
        });
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                Sync.method2();
            }
        });
        t0.start();
        t1.start();
    }
    
}

1496348-20190826164057566-1376706706.gif

依然是同样的结果，两个进程不能同时进入临界区。

synchronized修饰静态方法是是对类进行加锁，即类锁。

3、同步代码块

同步代码块的都是这样的：

synchronized (...) {
    ...
}
①对象锁
synchronized (this) {
    ...
}

像这样的写法是不能写在静态方法里的，效果与同步方法类似。

②类锁
synchronized (XXX.class) {
    ...
}

XXX指的是类名。

像这样的写法可以写在静态方法和普通方法中。①②两种写法是不能写成构造代码块的，但是能写在构造方法中。

③私有锁
Object lock
synchronized (lock) {
    ...
}

私有锁的粒度更小，不会与对象锁和类锁竞争。

代码演示一下：

public class Sync {
    
    public Integer a = new Integer(1);
    public void method() {
        System.out.println(Thread.currentThread().getName() + ": in method");
        synchronized (a) {
            System.out.println(Thread.currentThread().getName() + ": in synchronized block");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ": out synchronized block");
        }
        System.out.println(Thread.currentThread().getName() + ": out moetod");
    }
    
    public static void main(String[] args) {
        final Sync s = new Sync();
        
        Thread t0 = new Thread(new Runnable() {
            @Override
            public void run() {
                s.method();
            }
        });
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                s.method();
            }
        });
        t0.start();
        t1.start();
    }
    
}

1496348-20190826164110569-661796351.gif

运行结果可以看到两个线程可以同时进入方法，但是不能同时进入synchronized (a){...}所包含的代码块。

当synchronized (lock){...}中的lock是不同的对象时结果是不一样的。

举个例子：小明和小红两人可以同时走进房间，但是小明（或小红）进入房间后必须走出房间才能再次进入房间。

public class Sync {
    class Person {
        String name;
        Person(String name) {
            this.name = name;
        }
        void enterRoom() {
            System.out.println(Thread.currentThread().getName() + "-->" + name + ": 我准备好了！");
            synchronized (name) {
                System.out.println(Thread.currentThread().getName() + "-->" + name + ": 我进入房间了，并且我要在房间里待2秒！");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                exitRoom();
            }
            
        }
        void exitRoom() {
            System.out.println(Thread.currentThread().getName() + "-->" + name + ": 我退出了房间！");
        }
    }
    public static void main(String[] args) {
        final Person p1 = new Sync().new Person("小明");
        final Person p2 = new Sync().new Person("小明");
        Thread t0 = new Thread(new Runnable() {
            @Override
            public void run() {
                p1.enterRoom();
            }
        });
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                p2.enterRoom();
            }
        });
        t0.start();
        t1.start();
    }
    
}

1496348-20190826164118928-896562075.gif

姓名相同，即lock是同一个对象时，两个线程是不能同时进入的。

把p2改名叫小红

final Person p1 = new Sync().new Person("小明");
final Person p2 = new Sync().new Person("小红");

1496348-20190826164126104-905623767.gif

可以看到小明小红几乎同时进入房间，也就是这两个线程同步进行的。

转载于:https://www.cnblogs.com/Vaxy/p/11413430.html

dongfuai0192
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java_fun:个人 Java 项目 - 游戏、安全等
07-02
java_fun 这些只是我在业余时间完成的有趣的 Java 项目
Java并发编程（四）synchronized
heng615975867的专栏
09-12 152
Java并发编程（四）synchronized 一.synchronized同步方法或者同步块 在了解synchronized关键字的使用方法之前，我们先来看一个概念：互斥锁，顾名思义：能到达到互斥访问目的的锁。 举个简单的例子：如果对临界资源加上互斥锁，当一个线程在访问该临界资源时，其他线程便只能等待。 在Java中，每一个对象都拥有一个锁标记（monitor），也称为监视器，多线程同时访问某个对象时，线程只有获取了该对象的锁才能访问。 在Java中，可以使用synchronized...
java fun 关键字_Java关键字synchronized
weixin_30366957的博客
02-28 550
Java关键字synchronized一、用途synchronized可以实现线程同步，保证线程安全。被synchronized修饰的代码块或方法在同一时刻只允许一个线程进入临界区。二、用法修饰普通方法，即同步方法修饰静态方法，即静态同步方法修饰代码块，即同步代码块三、例子1、同步方法代码中用synchronized修饰了method，启动线程t0和线程t1。我们的预期结果是某一线程进入临界区，另...
fun 关键字
FIGHTING的专栏
03-18 1481
Swift 使用func关键字声明函数：  func greet (name: String, day: String) -> String { return "Hello \(name), today is \(day)." } greet ("Bob", "Tuesday") 　　通过元组（Tuple）返回多个值：  func getGasPrices
Java中的关键字总结
weixin_30810583的博客
10-03 206
Java中的关键字总结 Java中的关键字总结 1. final关键字 Java中的final关键字可以用来修饰类、方法和变量（包括实例变量和局部变量） Tip: 实例变量是类中方法外定义的变量，实例变量可以使用访问修饰符public和private修饰，使用public修饰说明该变量对子类可见，使用private修饰则子类不可见，该变量只...
java关键字Synchronized详解
07-04
ava中的关键字synchronized是一种用于实现线程同步的机制。它可以确保在同一时刻，只有一个线程能够访问被synchronized修饰的代码块或方法。这种机制可以有效地避免多线程环境下的数据竞争和不一致问题。 在Java中...
Java中的关键字synchronized 详解
08-26
主要介绍了Java中的关键字synchronized，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java关键字volatile和synchronized作用和区别
08-30
主要为大家详细介绍了Java关键字volatile和synchronized的作用和区别，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java synchronized关键字的用法
09-02
synchronized关键字我们大家都知道是线程同步关键字.总结一下日常的使用方法,还有一个坑.
举例讲解Java中synchronized关键字的用法
09-02
主要介绍了Java中synchronized关键字的用法,针对synchronized修饰方法的使用作出了简单讲解和演示,需要的朋友可以参考下
java fun 关键字,为何有的语言要声明function关键字，有的却不需要呢？
weixin_30767323的博客
03-19 728
很赞的一个问题。我也看过很多语言源代码，也对不同的语言的语法感兴趣，所以简单的聊聊这个问题。首先出场的是 LISP 语言。 LISP 语言以逼格高闻名于世。他属于函数式编程语言，所有的语句都是函数，因此不需要 function 这个关键词。随后的 Fortran 语言，公式翻译的意思 FormulaTranslation。既然是公式翻译语言，因此 数学公式 f(x) = a + b 在 Fortr...
（总结）Java相关_关键字总结
SteinsJiang的博客
09-14 157
（总结）Java相关_关键字总结 final、volatile、this、super、static 借鉴：Guide哥文章：final,static,this,super 关键字总结 1.final final关键字可以用于三个地方： 用于修饰类 被final关键字修饰的类不能被继承； final类中的所有成员方法都会被隐式的指定为final方法； 类属性 被final关键字修饰的类属性，子类就不能重新赋值； 对于一个final变量如果是基本数据类型变量，数值一旦在初始化之后就不能更改，如果是
java中fun_详解Java中的synchronized
weixin_30709043的博客
03-07 825
SynchronizedSynchronized methods enable a simple strategy for preventing thread interference and memory consistency errors: if an object is visible to more than one thread, all reads or writes to that...
java中的fun函数_使用Kotlin开发Android--常见的fun函数定义
weixin_39540704的博客
03-02 1283
上一篇具体讲了在Android Studio中怎么搭建Kotlin环境的搭建，以及简单的写了一个Hello World的DEMO。那么今天我们一起来学习一下常见的fun函数定义。我大概定义了11个比较常见的函数，一起来看看，喜欢的话，记得支持一下~~~返回值为String的类型，代码如下：/*** 返回值为String的函数 2017/3/31 14:38*/fun hello() : Strin...
Java中常见的关键字的作用
m0_69855013的博客
08-14 1941
java中常见的关键字的作用
JAVA系列: Java基本数据类型及关键字(2)
rosefun96的博客
02-02 1055
1、简介 在之前学习python的时候，之前就养成了结合编程书和网上的教学网站一起来学习。 毫无例外，这一次用了 JAVA编程语言 和网站how2J 书是实验室的，按道理，应该是师兄师姐们精心挑选的，应该是好书。 2、斐波那契数列编写 class Fibonacci{ public static void main(String args[]){ int
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 493
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
【仿真建模-anylogic】FlowchartPort原理解析
最新发布
zhaoyaxuan001的博客
06-14 338
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 609
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
 java关键字synchronized
04-10
synchronized关键字用于Java中实现线程同步，以确保多个线程不会同时访问共享资源。在synchronized块中，只能有一个线程访问共享资源，其他线程必须等待该线程释放锁，才能进入synchronized块。这可以防止并发访问共享资源导致的数据不一致或竞态条件的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值