synchronized知识点小结

最新推荐文章于 2024-06-21 21:18:30 发布
最新推荐文章于 2024-06-21 21:18:30 发布
阅读量4.6k 收藏
点赞数
分类专栏： java开发 web开发 文章标签： 多线程 synchroniz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljx1204/article/details/52966374
版权

Java的多线程编程中常用的关键字是synchronized，当然也经常用到java.util.concurrent.locks包下的一些类，比如ReentrantLock，还有java.util.concurrent.atomic包下的以Atomic开头的类。这个后续有机会再来探讨。
synchronized关键字，它可以用于声明方法，也可以用于声明代码块，以下是具体场景。
synchronized关键字修饰方法

package thread;

public class SynchronizedTest {

    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        Thread threadA = new ThreadA(demo);
        Thread threadB = new ThreadB(demo);
        threadA.setName("A");
        threadB.setName("B");
        threadA.start();
        threadB.start();
    }
}

class ThreadA extends Thread{

    private SynchronizedDemo demo;
    public ThreadA(SynchronizedDemo demo){
        this.demo = demo;
    }

    @Override
    public void run() {
        try {
            demo.foo1();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread{

    private SynchronizedDemo demo;
    public ThreadB(SynchronizedDemo demo){
        this.demo = demo;
    }

    @Override
    public void run() {
        try {
            demo.foo1();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class SynchronizedDemo{

    public synchronized void foo1() throws InterruptedException{
        System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                +"进入方法foo1");
        Thread.sleep(3000);
        System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                +"离开方法foo1");;
    }
}

运行结果：

线程A在1477807162663进入方法foo1
线程A在1477807165665离开方法foo1
线程B在1477807165665进入方法foo1
线程B在1477807168665离开方法foo1

synchronized关键字修饰代码块
synchronized关键字作用在代码块效果和作用在方法上类似，区别是作用在代码块上的参数是自己设置的，可以根据自己的需求设置锁定的对象，当一个类中有很多个synchronized方法时，使用同步代码块锁定非this对象，则可以避免和其他的同步方法争抢this锁，提高运行效率。 synchronized（非this对象x）格式是将x对象本身作为“对象监视器”，所以当多个线程同时执行synchronized（x）{}同步代码块和synchronized同步方法呈同步效果；当其他线程执行x对象方法里面的synchronized关键字的方法时，也呈同步效果。

public class SynchronizedTest {

    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo("123");
        Thread threadA = new ThreadA(demo);
        Thread threadB = new ThreadB(demo);
        threadA.setName("A");
        threadB.setName("B");
        threadA.start();
        threadB.start();
    }
}

class ThreadA extends Thread{

    private SynchronizedDemo demo;
    public ThreadA(SynchronizedDemo demo){
        this.demo = demo;
    }

    @Override
    public void run() {
        try {
            demo.foo2();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread{

    private SynchronizedDemo demo;
    public ThreadB(SynchronizedDemo demo){
        this.demo = demo;
    }

    @Override
    public void run() {
        try {
            demo.foo2();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class SynchronizedDemo{

    private String obj;

    public SynchronizedDemo(String str){

        this.obj = str;
    }
    public void foo2() throws InterruptedException{
        synchronized (obj){
            System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                    +"进入方法foo2");
            Thread.sleep(3000);
            System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                    +"离开方法foo2");;
        }
    }

}

运行结果：

线程A在1477807251436进入方法foo2
线程A在1477807254437离开方法foo2
线程B在1477807254437进入方法foo2
线程B在1477807257438离开方法foo2

synchronized锁重入
关键字Synchronized拥有锁重入的功能，也就是使用synchronized时，当一个线程得到一个对象锁后，再次请求对象锁时是可以再次获得对象的锁的，这也证明看在一个synchronized方法/代码块内部调用同一个对象的其他synchronized方法/代码块时，是永远可以得到锁的。

public class SynchronizedTest {

    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo("123");
        Thread threadA = new ThreadA(demo);
        Thread threadB = new ThreadB(demo);
        threadA.setName("A");
        threadB.setName("B");
        threadA.start();
        threadB.start();
    }
}

class ThreadA extends Thread{

    private SynchronizedDemo demo;
    public ThreadA(SynchronizedDemo demo){
        this.demo = demo;
    }

    @Override
    public void run() {
        try {
            demo.foo1();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread{

    private SynchronizedDemo demo;
    public ThreadB(SynchronizedDemo demo){
        this.demo = demo;
    }

    @Override
    public void run() {
        try {
            demo.foo1();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class SynchronizedDemo{

    private String obj;

    public SynchronizedDemo(String str){

        this.obj = str;
    }

    public synchronized void foo1() throws InterruptedException{
        System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                +"进入方法foo1");
        foo2();
        System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                +"离开方法foo1");
    }

    public void foo2() throws InterruptedException{
        synchronized (obj){
            System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                    +"进入方法foo2");
            Thread.sleep(3000);
            System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                    +"离开方法foo2");;
        }
    }   
}

运行结果：

线程A在1477807446886进入方法foo1
线程A在1477807446886进入方法foo2
线程A在1477807449887离开方法foo2
线程A在1477807449887离开方法foo1
线程B在1477807449887进入方法foo1
线程B在1477807449887进入方法foo2
线程B在1477807452887离开方法foo2
线程B在1477807452887离开方法foo1

出现异常，锁自动释放
当一个线程执行的代码出现异常时，其所持有的锁会自动释放，这个较好理解，线程出现异常后，线程会停止，其拥有的锁自然会释放，我们在实际开发过程中要停止线程，一般不用stop方法，而是用其他方式，常用的方式有中断线程，捕获异常来停止线程。

public class SynchronizedTest {

    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo("123");
        Thread threadA = new ThreadA(demo);
        Thread threadB = new ThreadB(demo);
        threadA.setName("A");
        threadB.setName("B");
        threadA.start();
        threadB.start();
        threadA.interrupt();
    }
}

class ThreadA extends Thread{

    private SynchronizedDemo demo;
    public ThreadA(SynchronizedDemo demo){
        this.demo = demo;
    }

    @Override
    public void run() {
            demo.foo1();
    }
}

class ThreadB extends Thread{

    private SynchronizedDemo demo;
    public ThreadB(SynchronizedDemo demo){
        this.demo = demo;
    }

    @Override
    public void run() {
            demo.foo1();
    }
}

class SynchronizedDemo{

    private String obj;

    public SynchronizedDemo(String str){

        this.obj = str;
    }

    public synchronized void foo1() {
        System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                +"进入方法foo1");
        try{
            foo2();
        }catch(InterruptedException e){
            System.out.println("线程"+Thread.currentThread().getName()+"中断了");
        }
        System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                +"离开方法foo1");
    }

    public void foo2() throws InterruptedException{
        synchronized (obj){
            System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                    +"进入方法foo2");
            Thread.sleep(3000);
            System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                    +"离开方法foo2");;
        }
    }

}

运行结果：

线程A在1477807745022进入方法foo1
线程A在1477807745022进入方法foo2
线程A中断了
线程A在1477807745023离开方法foo1
线程B在1477807745023进入方法foo1
线程B在1477807745023进入方法foo2
线程B在1477807748024离开方法foo2
线程B在1477807748024离开方法foo1

同步不具有继承性
同步不可以继承，因此我们重写父类的synchronized方法时也要加上synchronized关键字，子类的方法才能实现同步。

静态同步synchronized方法与synchronized（class）代码块
关键字synchronized应用在static静态方法上，则是对Class类进行加锁，它与Class对应的对象锁不是同一个锁，Class锁可以对类的所有对象实例起作用，即同一个类的两个不同对象也是互斥的。

public class SynchronizedTest {

    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        Thread threadA = new ThreadA(demo);
        Thread threadB = new ThreadB(demo);
        threadA.setName("A");
        threadB.setName("B");
        threadA.start();
        threadB.start();
    }
}

class ThreadA extends Thread{

    private SynchronizedDemo demo;
    public ThreadA(SynchronizedDemo demo){
        this.demo = demo;
    }

    @Override
    public void run() {
        try {
            demo.foo1();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread{

    private SynchronizedDemo demo;
    public ThreadB(SynchronizedDemo demo){
        this.demo = demo;
    }

    @Override
    public void run() {
        try {
            SynchronizedDemo.foo2();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class SynchronizedDemo{

    public synchronized void foo1() throws InterruptedException {
        System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                +"进入方法foo1");
        Thread.sleep(3000);
        System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                +"离开方法foo1");
    }

    public static synchronized void foo2() throws InterruptedException{
            System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                    +"进入方法foo2");
            Thread.sleep(3000);
            System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                    +"离开方法foo2");;
    }

}

运行结果：

线程A在1477808224594进入方法foo1
线程B在1477808224594进入方法foo2
线程B在1477808227595离开方法foo2
线程A在1477808227595离开方法foo1
public class SynchronizedTest {

    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        SynchronizedDemo demo1 = new SynchronizedDemo();
        Thread threadA = new ThreadA(demo);
        Thread threadB = new ThreadB(demo1);
        threadA.setName("A");
        threadB.setName("B");
        threadA.start();
        threadB.start();
    }
}

class ThreadA extends Thread{

    private SynchronizedDemo demo;
    public ThreadA(SynchronizedDemo demo){
        this.demo = demo;
    }

    @Override
    public void run() {
        try {
            demo.foo2();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread{

    private SynchronizedDemo demo;
    public ThreadB(SynchronizedDemo demo){
        this.demo = demo;
    }

    @Override
    public void run() {
        try {
            demo.foo2();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class SynchronizedDemo{

    public void foo1() throws InterruptedException {
        synchronized(SynchronizedDemo.class){
            System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                    +"进入方法foo1");
            Thread.sleep(3000);
            System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                    +"离开方法foo1");
        }
    }

    public  void foo2() throws InterruptedException{
        synchronized(SynchronizedDemo.class){
            System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                    +"进入方法foo2");
            Thread.sleep(3000);
            System.out.println("线程"+Thread.currentThread().getName()+"在"+ System.currentTimeMillis()
                    +"离开方法foo2");;
        }
    }

}

运行结果：

线程A在1477808373225进入方法foo2
线程A在1477808376226离开方法foo2
线程B在1477808376226进入方法foo2
线程B在1477808379227离开方法foo2
候鸟_
关注
专栏目录
深入理解synchronized
程序员世杰
07-11 1444
1.synchronize关键字用于加锁，用来解决多线程中，多个线程对同一资源访问所造成的数据不安全的问题 2.使用synchronized修饰，相当于加了一把锁，对于synchronized锁定的资源，同一时间，只能有一个线程访问，保证了原子性。 线程不安全的代码示例： class Ticket implements Runnable { private int num; //...
synchronized详解
laijinxiang0108的博客
12-23 309
前言     一直想写自己的博客，真正动手了才知道难啊。但没办法，博客总要写的，今天就从Java中最常用的synchronized开始吧！我想从三个方面写synchronized： 用法。 原理。 优化。 第一次写博客，可能会有一些错误，欢迎指出。 用法 synchronized的用法主要有三种： 使用普通同步方法中。 默认锁的是当前对象。即this。...
Synchronized详细知识点
PINKMIAO的博客
09-05 225
Synchronized 简介 synchronized 关键字解决的是多个线程之间访问资源的同步性，它可以保证被它修饰的方法或者代码块在任意时刻都只会是一个线程执行。 在 Java 早期1.2版本中，synchronized属于重量级锁，效率低，因为监视器锁（monitor）是依赖于底层的操作系统OS的 Mutex Lock 来实现的，Java 的线程是映射到操作系统的原生线程之上的，所以每次将挂起或者唤醒一个线程，都需要操作系统帮助完成。而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之
Java面试题：讨论synchronized关键字和java.util.concurrent包中的同步工具，如Lock和Semaphore
最新发布
码农超哥的博客
06-21 331
在 Java 中，关键字和包中的同步工具都是用来控制多线程环境下的并发访问，以防止数据竞争和确保线程安全。下面是对关键字和包中的一些同步工具的讨论，包括它们的特点和使用场景。
Synchronized面试常见知识点
mengqingming1的博客
10-23 425
### synchronized关键字最主要的三种使用方式的总结 - **修饰实例方法，作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁** - **修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁** 。 也就是给当前类加锁，会作用于类的所有对象实例，因为静态成员不属于任何一个实例对象， 是类成员（ static 表明这是该类的一个静态资源，不管ne...
面试：Synchronized知识点
燕然一勒的博客
01-08 131
1.Synchronized如何保证原子性、可见性和有序性 原子性：确保线程互斥的访问同步代码； 可见性：保证共享变量的修改对其他线程能够及时可见。 线程解锁前，必须把共享变量的最新值刷新到主内存中 线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新获取最新的值 有序性：对一个监视器锁的释放操作先行发生（happens-before）与后面对该监视器锁的获取操作 2.Synchronized使用形式 对于普通同步方法，锁对象是当前实例对象。 对于静态同步方法，锁..
Synchronized相关知识点大全
weixin_43484977的博客
05-31 149
synchronized 有以下三种作用范围： 在静态方法上加锁； 在非静态方法上加锁； 在代码块上加锁； 如下： public class SynchronizedSample { private final Object lock = new Object(); private static int money = 0; //非静态方法 public synchronized void noStaticMethod(){
Synchronized_锁升级知识点总结
11-17
在多线程编程中，为了保证共享资源的一致性和...因此，在进行Java高并发开发时，掌握Synchronized锁升级的知识点是非常必要的。在面试中，这也是一个常见的面试问题，考察应聘者对Java并发编程的深入理解和实践经验。
JAVA核心知识点总结.pdf
10-02
《JAVA核心知识点总结》 Java作为一款广泛应用的编程语言，其核心知识点对于开发者来说至关重要。本资料旨在为准备面试或者系统学习Java的人员提供一个全面的复习框架。以下是对其中部分关键知识点的详细阐述： **...
知识点总结word.zip
06-18
这份名为"知识点总结word.zip"的压缩包文件，很可能包含了一份精心整理的Java技术学习指南，帮助我们系统地理解和掌握这个强大的编程语言。下面，我们将详细探讨Java的核心概念和技术点，希望能为你的学习之路提供...
java知识点总结思维导图(xmind)
11-12
这份"java知识点总结思维导图(xmind)"是为帮助学习者系统性地理解和掌握Java核心技术而精心整理的资料。思维导图作为一种有效的学习工具，能够帮助我们更好地组织和记忆信息，提高学习效率。 首先，让我们从基础...
Java多线程-知识点梳理和总结-超详细-面试知识点.docx
12-17
"Java多线程-知识点梳理和总结-超详细-面试知识点" Java多线程是Java编程语言中最基本也是最重要的概念之一。多线程编程可以提高程序的执行效率、改善用户体验和提高系统的可扩展性。但是，多线程编程也存在一些...
synchronized 锁膨胀及相关知识点
城中行
10-22 643
synchronized 关键字在jdk1.6之前使用的是重量级锁,在1.6之后引入自旋与锁膨胀机制,降低了性能损耗.这里以jdk1.6以后版本为前提. CAS操作 CAS的全称为Compare And Swap，直译就是比较交换。是一条CPU的原子指令,作用就是先比较两个值是否相等,如果相等则原子的更新某个位置的值,基于硬件平台的汇编指令实现. CAS 操作包含三个操作数 ：内存偏移量位置...
Java 中synchronized的知识点
lz_N_one的博客
10-27 189
1.Synchronized升级的原理是什么？ Synchronized锁升级原理：在锁对象里有一个threadid字段，在第一次访问的时候threadid为空，jvm让其持有偏向锁，并将threadid设置为其线程id，再次进入的时候会判段threadid 是否与其线程id一致，如果一致则可以直接使用此对象，如果不一致，则升级偏向锁为轻量级锁，通过自旋循环一定次数来获取锁，执行一定次数之后，如...
线程安全 知识点（synchronized）
Dwayne的博客
06-06 279
1 出现线程安全问题的条件 1）是否多线程环境 2）是否有共享数据 3）是否有多条语句操作共享数据 1)2)没法儿改，只能改3）：把多条语句包成一个整体，让某个线程执行的时候其它线程不能进去执行 --> 同步机制。 2 同步（synchronized） 2.1 同步 代码块 synchronized(对象){需要同步的代码} 注：同步可以解决安全问题的根本就在这个“对象”上，该对象如同...
synchronize锁知识点
DKPT的博客
08-20 261
synchronize （偏向锁）markword 记录线程ID； （自旋锁）线程争用升级到自旋锁； （重量级锁）10次自旋后升级为重量级锁； 执行时间短（加锁代码），线程数量少，使用自旋锁。 执行时间长，线程数量多。使用系统锁重量级锁。 synchronize（object）加锁时 object不使用string常量，integer，Long. ...
关于synchronized的几种用法和相关知识。
mortal_li的博客
12-21 535
synchronized，是java中多线程编程重要的内容，而在应用中多线程并发更是必不可少的，那么对于synchronized，我把这几天学习的内容记录下来。 synchronized是一种加锁同步机制，这就好比一栋房子只有一把钥匙，而只有拥有这把钥匙的人才能够进入，在出来之后，再将钥匙放置原处，等待下一个人来拿。在这种机制下，我们的多线程安全也就有了保证。 那么synchr
synchronized 知识图解
weixin_30821731的博客
06-24 209
转载于:https://juejin.im/post/5d107d79f265da1bb003caa9
Java面试宝典：基础知识点总结
知识点：Java中的break和continue语句。在Java中，可以使用break语句跳出当前循环，可以使用标签跳出指定的循环。例如： ```java loop1: for (int i = 0; i ; i++) { for (int j = 0; j ; j++) { if (j == 3) { ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值