多线程基础(三)——Synchronized

最新推荐文章于 2024-06-14 14:08:37 发布
最新推荐文章于 2024-06-14 14:08:37 发布
阅读量146 收藏
点赞数 1
分类专栏： JavaEE 文章标签： java jvm 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53223625/article/details/128940252
版权

目录

1.解决线程不安全

2.关键字Synchronized特性

1.互斥

2.刷新内存

3.可重入

3.synchronized的使用        

1.修饰实例方法

2.修饰代码块 

3.修饰静态方法

4.锁对象

5.总结：

 

根据上篇文章多线程基础(二)——线程安全我们了解到在实际的开发中，会出现线程不安全现象，但是通过加锁就可以避免线程不安全，主要应用关键字Synchronized来解决。

1.解决线程不安全

 class Counter02 {
        public int count = 0;
       synchronized void increase() {
            count++;
        }
    }
public class Demo02 {
    public static void main(String[] args) throws InterruptedException {
         Counter02 counter = new Counter02();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}

2.关键字Synchronized特性

1.互斥

synchronized会起到互斥的作用，某个线程执行到某个对象的synchronized中时，此时如果其他线程也执行到同一个对象synchronized就会阻塞等待

  • 进入synchronized修饰的代码块，相当于加锁
  • 退出synchronized修饰的代码块，相当于解锁

 synchronized用的锁是存在对象头里的

  • 可以粗略理解成, 每个对象在内存中存储的时候, 都存有一块内存表示当前的 "锁定" 状态
  • 如果当前是 "无人" 状态, 那么就可以使用, 使用时需要设为 "有人" 状态.
  • 如果当前是 "有人" 状态, 那么其他人无法使用, 只能排队

注意:

  • 上一个线程解锁之后, 下一个线程并不是立即就能获取到锁. 而是要靠操作系统来 "唤醒". 这也就是操作系统线程调度的一部分工作.
  • 假设有 A B C 三个线程, 线程 A 先获取到锁, 然后 B 尝试获取锁, 然后 C 再尝试获取锁, 此时 B和 C 都在阻塞队列中排队等待. 但是当 A 释放锁之后, 虽然 B 比 C 先来的, 但是 B 不一定就能获取到锁, 而是和 C 重新竞争, 并不遵守先来后到的规则. 

2.刷新内存

synchronized实现内存可见机制是通过原子性完成的

synchronized 的工作过程:

  1. 获得互斥锁
  2. 从主内存拷贝变量的最新副本到工作的内存
  3. 执行代码
  4. 将更改后的共享变量的值刷新到主内存
  5. 释放互斥锁

在一系列工作完成之后，下一个线程读到的值是上一个线程写入的最新值。

3.可重入

已经获得锁对象的线程针对当前锁加了多次锁，不产生互斥现象，这就是可重入特性

static class Counter {
    public int count = 0;

    synchronized void increase() {
            count++;
        }

    synchronized void increase2() {
            increase();
        }
}
  • increase 和 increase2 两个方法都加了 synchronized, 此处的 synchronized 都是针对 this 当前对象加锁的.
  • 在调用 increase2 的时候, 先加了一次锁, 执行到 increase 的时候, 又加了一次锁. (上个锁还没释放, 相当于连续加两次锁)

但是此时代码正确。

在可重入锁的内部, 包含了 "线程持有者" 和 "计数器" 两个信息：

  • 如果某个线程加锁的时候, 发现锁已经被人占用, 但是恰好占用的正是自己, 那么仍然可以继续获取到锁, 并让计数器自增.
  • 解锁的时候计数器递减为 0 的时候, 才真正释放锁. (才能被别的线程获取到) 

3.synchronized的使用        

1.修饰实例方法

作用于当前实例加锁：

public synchronized void method(){
   // todo
}

此时加锁为锁定了整个方法的内容。

synchronied关键字不能继承，虽然可以定义方法，但是并不属于方法定义的一部分，因此不能被继承。如果父类方法使用synchronied修饰，而在子类方法中重写这个方法，此时是不同步的，必须显示的在子类方法中添加 synchronied关键字。还可以在子类调用父类的方法，此时子类方法中不同步，但是子类调用了父类的同步方法，因此子类方法相当于同步。

子类方法加上synchronied:

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代码块来进行同步。

2.修饰代码块 

指定加锁对象，给给定对象加锁
锁当前对象:

public void method(){

   synchronized(this) {
      // todo
   }
}

3.修饰静态方法

作用于当前类对象加锁：

public synchronized static void method() {
    //TODO
}

4.锁对象

  • 一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞，竞争同一把锁，线程安全

public class Demo_405 {
    private static int num = 50000;

    public static void main(String[] args) throws InterruptedException {

        Counter06 counter  = new Counter06();
        // 创建线程完成自增
        // 创建两个线程
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < num; i++) {
                // 这里调用了counter1的自增方法
                counter.increase();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < num; i++) {
                // 这里调用了counter2的自增方法
                counter.increase();
            }
        });
        // 启动线程
        t1.start();
        t2.start();
        // 等待两个线程执行完成
        t1.join();
        t2.join();

        // 获取自增后的count值
        System.out.println("count结果 = " + counter.count);

    }
}

class Counter06 {
    public int count = 0;

    /**
     * 执行自增操作
     */
    public void increase() {
        // 指定自定义的锁对象
        synchronized (this) {
            count++;
        }
    }
}
  • 没有明确的对象作为锁，可以创建一个特殊的对象作为锁，同一个对象使用同一把锁，线程安全

public class Demo_405 {
    private static int num = 50000;

    public static void main(String[] args) throws InterruptedException {

        Counter06 counter  = new Counter06();
        // 创建线程完成自增
        // 创建两个线程
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < num; i++) {
                // 这里调用了counter1的自增方法
                counter.increase();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < num; i++) {
                // 这里调用了counter2的自增方法
                counter.increase();
            }
        });
        // 启动线程
        t1.start();
        t2.start();
        // 等待两个线程执行完成
        t1.join();
        t2.join();

        // 获取自增后的count值
        System.out.println("count结果 = " + counter.count);

    }
}

class Counter06 {
    public int count = 0;

    //  自定义一个锁对象
    Object locker = new Object();
    /**
     * 执行自增操作
     */
    public void increase() {
        // 指定自定义的锁对象
        synchronized (locker) {
            count++;
        }
    }
}
  • 静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象，线程安全
public class Demo_407 {
    private static int num = 50000;

    public static void main(String[] args) throws InterruptedException {

        Counter07 counter  = new Counter07();
        Counter07 counter1  = new Counter07();

        // 创建线程完成自增
        // 创建两个线程
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < num; i++) {
                // 这里调用了counter1的自增方法
                counter.increase();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < num; i++) {
                // 这里调用了counter2的自增方法
                counter.increase();
            }
        });
        // 启动线程
        t1.start();
        t2.start();
        // 等待两个线程执行完成
        t1.join();
        t2.join();

        // 获取自增后的count值
        System.out.println("count结果 = " + counter.count);

    }
}

class Counter07 {
    public static int count = 0;

    //  自定义一个锁对象
//    public Object locker = new Object();
    /**
     * 执行自增操作
     */
    public synchronized void increase() {
        // 指定自定义的锁对象
            count++;
    }
}
  • 自定义一个静态锁对象，也是全局唯一，线程安全

public class Demo_408 {
    private static int num = 50000;

    public static void main(String[] args) throws InterruptedException {

        Counter08 counter  = new Counter08();
        Counter08 counter1  = new Counter08();
        counter.count = 1;
//        System.out.println(counter.count);
//        System.out.println(counter1.count);
//        System.out.println(counter);
//        System.out.println(counter1);
//        System.out.println(counter.locker);
//        System.out.println(counter1.locker);

        // 创建线程完成自增
        // 创建两个线程
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < num; i++) {
                // 这里调用了counter1的自增方法
                counter.increase();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < num; i++) {
                // 这里调用了counter2的自增方法
                counter1.increase();
            }
        });
        // 启动线程
        t1.start();
        t2.start();
        // 等待两个线程执行完成
        t1.join();
        t2.join();

        // 获取自增后的count值
        System.out.println("count结果 = " + counter.count);

    }
}

class Counter08 {
    public static int count = 0;

    //  自定义一个锁对象
    public static Object locker = new Object();
    /**
     * 执行自增操作
     */
    public void increase() {
        // 指定自定义的锁对象
        synchronized (locker) {
            count++;
        }
    }
}
  • 使用类对象持有的所信息，全局唯一，存在锁竞争，线程安全
public class Demo_410 {
    private static int num = 50000;

    public static void main(String[] args) throws InterruptedException {

        Counter10 counter  = new Counter10();
        Counter10 counter1  = new Counter10();

        // 创建线程完成自增
        // 创建两个线程
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < num; i++) {
                // 这里调用了counter1的自增方法
                counter.increase();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < num; i++) {
                // 这里调用了counter2的自增方法
                counter1.increase();
            }
        });
        // 启动线程
        t1.start();
        t2.start();
        // 等待两个线程执行完成
        t1.join();
        t2.join();

        // 获取自增后的count值
        System.out.println("count结果 = " + counter.count);

    }
}

class Counter10 {
    public static int count = 0;

    public void increase() {
        // 使用这个类对象持有锁信息
        synchronized (Counter10.class) {
            count++;
        }
    }

}

5.总结：

  1. 只有一个线程要获取锁，直接可以拿到，没有锁竞争

  2. 两个线程同时竞争一把锁，谁先拿到就执行自己的逻辑，另一个线程就是阻塞等待，等释放锁之后，再次竞争锁

  3. 两个线程竞争的不是同一把锁，两者没有竞争关系

  4. 要保证线程之间存在锁竞争，必须要使用相同的锁

  5. synchronized可以修饰方法，可以修饰代码块：

  • 修饰静态方法，用到的锁对象是类对象.class

  • 修饰普通方法，用到的锁对象是当前的实例对象，new

  • 修饰代码块，用到的锁对象是当前对象this new 

  • 在 synchronized(locker){},此处locker可以为任意对象 

wileda
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JVM内置锁synchronized
qq_49281137的博客
01-06 272
今天学习了CPU缓存一致性协议MESI,这里记录一下学习笔记，有错误，还望指出。 文章目录设计同步器的意义如何解决线程并发安全问题？synchronized原理synchronized底层原理Monitor监视器锁什么是monitor？对象的内存布局对象头对象头分析工具锁的膨胀升级过程偏向锁轻量级锁自旋锁锁消除逃逸分析 设计同步器的意义 多线程编程中，有可能会出现多个线程同时访问同一个共享、可变资源的情况，这个资源我们称之其为临界资源；这种资源可能是： 对象、变量、文件等。 共享：资源可以由多个线程同时
Java中Synchronized的用法（简单介绍）
NeiHan2020的博客
03-04 6043
简单介绍 synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 　　1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 　　2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 　　3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 　　4. 修改一个类，其作用的范围是synchronized后面括号括起来的...
一篇说清楚synchronized的类锁、对象锁、方法锁、代码块锁和它们的阻塞情况、死锁由来。
AndroidDeveloper的专栏
05-10 1216
那么就会出现thread1占有mLock锁，需要访问mLock2锁，就需要等待thread2释放mLock2锁。c1.test()和c1.test2()、c1.test3使用的是同一个锁。c1.test()和c2.test()使用的是不同的两个对象锁，所以不同的线程可以同时访问c1.test()和和c2.test()。//非静态方法锁，使用的是对象锁。//非静态方法种的代码块，如果用.class类来加锁，也是类锁。//非静态方法种的代码块，如果用this来加锁，也是对象锁。//静态方法锁，使用的是类锁。
synchronized详解
Meiko记录
05-08 137
线程安全是并发编程中的重要关注点，应该注意到的是，造成线程安全问题的主要诱因有两点，一是存在共享数据(也称临界资源)，二是存在多条线程共同操作共享数据。因此为了解决这个问题，我们可能需要这样一个方案，当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行，这种方式有个高尚的名称叫互斥锁，即能达到互斥访问目的的锁，也就是说当一个共享数据...
多线程—synchronized
qq_42251944的博客
10-20 767
synchronized俗称对象锁，它采用互斥的方式让同一时刻至多只有一个线程持有对象锁，其他线程想获取这个对象锁时就会阻塞，这样就不用担心上下文切换。 关系：synchronized使用对象锁保证了临界区（下面有介绍）内代码的原子性（完整性），临界区内的代码对外是不可分割的，不会被线程上下文切换所打断。 注意：同一个临界区，线程访问的对象锁应该是一致的，就好比进入同一个房间，钥匙必须都是那一把，才能达到锁住的目的。 Java中互斥和同步都可以采用synchronized来完成，但有区别： （1）互
Java多线程基础——Lock类
08-31
Lock类是Java类来提供的功能，丰富的api使得Lock类的同步功能比synchronized的同步更强大。本文对此进行详细介绍，下面跟着小编一起来看下吧
【后端】 java基础（5.8）java高级基础之线程——synchronized关键字
03-29
java基础（5.8）java高级基础之线程——synchronized关键字 本章主要讲线程，至于带上进程的原因是为了方便大家对进程和线程有个概念（咳，主要原因是鄙人也不太会进程~）。 首先简单说下我个人对进程和线程的理解。...
Java多线程之synchronized&volatile基础篇
12-20
一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel ...
Java——多线程编程技术.pdf
12-31
Java多线程编程技术的同步机制是通过Synchronized关键字和Volatile关键字来实现的。Synchronized关键字可以使线程之间同步执行，而Volatile关键字可以使线程之间共享变量。 Java多线程编程技术的应用场景非常广泛，...
Java并发学习笔记（二）——Synchronized关键字与ReetrantLock同步锁
12-20
被Synchronized 关键字描述的方法或代码块在多线程环境下同一时间只能由一个线程进行访问，因为在持有当前锁的线程执行完成之前，其他线程想要调用相关方法就必须进行排队，直到当前线程执行完成才释放锁给其他线程...
多线程编程 synchronized 阻塞独占锁
AndroidDeveloper的专栏
02-16 1527
我们在进行多线程编程的时候往往需要进行线程同步或者防止重入。这个时候使用不同的机制，不仅处理逻辑不一样，运行效率也有很大的区别。 synchronized 我们一般用 synchronized 来做独占锁，而且线程是阻塞的。比如在设计单例的时候，同步代码块或者同步方法。 ...
Java synchronized阻塞的同步队列现象分析
Ethan Zeng 博客空间
03-12 2110
public class Singleton { public static void main(String[] args) throws InterruptedException { for (int i=0; i&lt;10; i++){ new Thread(new QueueThread()).start(); ...
Java多线程之七：用Lock、synchronized、阻塞队列三种方法实现生产者消费者模式
猪猪
05-11 1078
一、阻塞队列实现生产者消费者模式package com.lock.producerandconsumer; import java.util.Random; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.logging.Lev...
线程并发学习----线程阻塞（synchronized）
eos2009的博客
11-28 5524
线程并发学习线程并发学习—-核心概念（转载） 线程并发学习—-线程阻塞（sleep、wait、notifyAll、notify） 线程并发学习—-线程阻塞（synchronized） 线程并发学习—-线程阻塞（concurrent包） 线程并发学习—-Thread、Runnable、Callable spring学习—-线程池 简介在并发编程中，我们需要处理两个关键问题：线程之间如何通信及
使用synchronized阻塞后台服务进程，使之一直运行
阿狸_桃子
08-19 2555
使用synchronized（XXX.class）锁类对象 阻塞后台服务进程，使之一直运行
JUC多线程：synchronized锁机制原理 与 Lock锁机制
热门推荐
张维鹏的博客
08-26 1万+
synchronized 通过当前线程持有对象锁，从而拥有访问权限，而其他没有持有当前对象锁的线程无法拥有访问权限，保证在同一时刻，只有一个线程可以执行某个方法或者某个代码块，从而保证线程安全。synchronized 锁机制在 Java 虚拟机中的同步是基于进入和退出监视器锁对象 monitor 实现的
【仿真建模-anylogic】FlowchartPort原理解析
最新发布
zhaoyaxuan001的博客
06-14 352
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
synchronized内核线程
08-03
- *1* *3* [多线程——synchronized详解](https://blog.csdn.net/Pluto372/article/details/127304464)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值