java03_线程同步（volatile、 synchronized）

最新推荐文章于 2023-01-04 21:39:04 发布
最新推荐文章于 2023-01-04 21:39:04 发布
阅读量141 收藏
点赞数
分类专栏： java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/youtiao_hulatang/article/details/111937847
版权

1、volatile

概念：轻量级锁。

使用场景：多个线程同时对未加volatile 的变量读写，会导致数据不准确。

使用：

 volatile boolean status = false;

volatile特性：

  • 保证共享变量对所有线程的可见性（只对原子操作有效，针对复合操作无效（比如：num++））。

    1）当写一个volatile变量时，JMM会把该线程对应的本地内存中的变量强制刷新到主内存中去；

    2）这个写会操作会导致其他线程中的缓存无效。

  • 禁止指令重排序优化

其他概念：

Java内存模型（JMM）：JMM定义了线程和主内存之间的抽象关系：共享变量存储在主内存(Main Memory)中，每个线程都有一个私有的本地内存（Local Memory），本地内存保存了被该线程使用到的主内存的副本拷贝，线程对变量的所有操作都必须在工作内存（副本）中进行，而不能直接读写主内存中的变量。这三者之间的交互关系如下：

 

可见性：是指当一条线程修改了共享变量的值，新值对于其他线程来说是可以立即得知的。

重排序：是指编译器和处理器为了优化程序性能而对指令序列进行排序的一种手段。

原子操作：

注意：

(1) 对复合类操作无效：

num++不是个原子性的操作，而是个复合操作。（读取、加一、赋值）

public class Counter {
    public static volatile int num = 0;
    //使用CountDownLatch来等待计算线程执行完
    static CountDownLatch countDownLatch = new CountDownLatch(30);
    public static void main(String []args) throws InterruptedException {
        //开启30个线程进行累加操作
        for(int i=0;i<30;i++){
            new Thread(){
                public void run(){
                    for(int j=0;j<10000;j++){
                        num++;//自加操作 复和操作
                    }
                    countDownLatch.countDown();
                }
            }.start();
        }
        //等待计算线程执行完
        countDownLatch.await();
        System.out.println(num); //执行结果小于300000
    }
}

在多线程环境下，有可能线程A将num读取到本地内存中，此时其他线程可能已经将num增大了很多，线程A依然对过期的num进行自加，重新写到主存中，最终导致了num的结果不合预期，而是小于30000。

解决num++操作的原子性问题：

针对num++这类复合类的操作，可以使用java并发包中的原子操作类解决。

原子操作类：是通过循环CAS的方式来保证其原子性的。

public class Counter {
　　//使用原子操作类
    public static AtomicInteger num = new AtomicInteger(0);
    //使用CountDownLatch来等待计算线程执行完
    static CountDownLatch countDownLatch = new CountDownLatch(30);
    public static void main(String []args) throws InterruptedException {
        //开启30个线程进行累加操作
        for(int i=0;i<30;i++){
            new Thread(){
                public void run(){
                    for(int j=0;j<10000;j++){
                        num.incrementAndGet();//原子性的num++,通过循环CAS方式
                    }
                    countDownLatch.countDown();
                }
            }.start();
        }
        //等待计算线程执行完
        countDownLatch.await();
        System.out.println(num); //执行结果300000
    }
}

（2）禁止指令重排序优化

处理器为了优化程序性能而对指令序列进行排序的一种手段

重排序也需要遵守一定规则：

​             1）重排序操作不会对存在数据依赖关系的操作进行重排序。

​                   比如：a=1;b=a; 这个指令序列，由于第二个操作依赖于第一个操作，所以在编译时和处理器运行时这两个操作不会被重排序。

​             2）重排序是为了优化性能，但是不管怎么重排序，单线程下程序的执行结果不能被改变。

​                   比如：a=1;b=2;c=a+b这三个操作，第一步（a=1)和第二步(b=2)由于不存在数据依赖关系，所以可能会发生重排序，但是c=a+b这个操作是不会被重排序的，因为需要保证最终的结果一定是c=a+b=3。

注意：重排序在单线程模式下是一定会保证最终结果的正确性，但是在多线程环境下，问题就出来了，来开个例子，我们对第一个TestVolatile的例子稍稍改进，再增加个共享变量a。

比如：假设线程A执行changeStatus后，线程B执行run，我们能保证在4处，b一定等于3么？

答案依然是无法保证！ 也有可能b仍然为2。（上面我们提到过，为了提供程序并行度，编译器和处理器可能会对指令进行重排序，而上例中的1和2由于不存在数据依赖关系，则有可能会被重排序，先执行status=true再执行a=2。而此时线程B会顺利到达4处，而线程A中a=2这个操作还未被执行，所以b=a+1的结果也有可能依然等于2。）

public class TestVolatile {
    int a = 1;
    boolean status = false;

    /**
     * 状态切换为true
     */
    public void changeStatus(){
        a = 2;//1
        status = true;//2
    }

    /**
     * 若状态为true，则running。
     */
    public void run(){
        if(status){//3
            int b = a+1;//4
            System.out.println(b);
        }
    }
}

volatile禁止指令重排序也有一些规则，简单列举一下：

　　1.当第二个操作是voaltile写时，无论第一个操作是什么，都不能进行重排序

　　2.当地一个操作是volatile读时，不管第二个操作是什么，都不能进行重排序

　　3.当第一个操作是volatile写时，第二个操作是volatile读时，不能进行重排序**

总结：

volatile是一种轻量级的同步机制，主要有两个特性：

  • 一是保证共享变量对所有线程的可见性；
  • 二是禁止指令重排序优化。（同时需要注意的是，volatile对于单个的共享变量的读/写具有原子性，但是像num++这种复合操作，volatile无法保证其原子性，当然文中也提出了解决方案，就是使用并发包中的原子操作类，通过循环CAS地方式来保证num++操作的原子性。）

 2、synchronized

概念：线程同步锁。

分类：

  • 对象锁：用于对象实例方法（普通方法）或对象实例。

    范围：synchronized修饰的实例方法被一个线程占用后，所有被synchronized修改的对象方法（包括代码块修饰），其他线程都不能访问。未被synchronized修饰的方法，其他线程可以访问。

  • 类锁：用于类静态方法或类class对象上。

    范围：：synchronized修饰的静态方法被一个线程占用后，所有被synchronized修饰的静态方法（包括代码块修饰），其他线程都不能访问。未被synchronized修饰的静态方法，其他线程可以访问。

用法：

  • 非静态方法的同步

  • 静态方法同步

  • 代码块

注意：类锁和对象锁是不一样的锁，是互相独立的。

类锁和对象锁其实是一样的，由于静态方法是类所有对象共用的，所以进行同步后，该静态方法的锁也是所有对象唯一的。每次只能有一个线程来访问对象的该非静态同步方法。

  • 不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。

  • 类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的。

其他概念：

  • 内置锁

一、对象锁

(1) 非静态方法使用 synchronized 修饰，锁定的是当前对象：

(2) 代码块使用 synchronized 修饰，如果传入的参数是 this，那么锁定的也是当前的对象：

public synchronized void test(){
        ...
}

public void test(){
    synchronized (this) { //注意传入this
        ...
    }
}

实例：

public class MySynchronized {
    public static void main(String[] args) {

        final MyTest mt = new MyTest();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                mt.Min1();
            }
        }, "t1");

        //同一个实例+同一个synchronized
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                mt.Min1();
            }
        }, "t2");

        //同一个实例+不同synchronized
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                mt.Min2();
            }
        }, "t3");

        //同一实例+不同synchronized(代码块)
        Thread t4 = new Thread(new Runnable() {
            @Override
            public void run() {
                mt.Min3();
            }
        }, "t4");

        //同一实例+非synchronized
        Thread t5 = new Thread(new Runnable() {
            @Override
            public void run() {
                mt.Min4();
            }
        }, "t5");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}


class MyTest{
    //synchronized修改实例方法
    public synchronized void Min1(){
        int c = 5;
        for (int i = 0; i < Num; i++) {
            c--;
            System.out.println(Thread.currentThread().getName() + " - " + c);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
        }
    }

    public synchronized void Min2(){
        int c2 = 5;
        for (int i = 0; i < Num; i++) {
            c2--;
            System.out.println(Thread.currentThread().getName() + " - " + c2);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
        }
    }

    public void Min3(){
        synchronized (this){
            int c3 = 5;
            for (int i = 0; i < Num; i++) {
                c3--;
                System.out.println(Thread.currentThread().getName() + " - " + c3);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                }
            }
        }
    }

    public void Min4(){
        int c4 = 5;
        for (int i = 0; i < Num; i++) {
            c4--;
            System.out.println(Thread.currentThread().getName() + " - " + c4);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
        }
    }
}

输出：

 

结论：对象锁是对象唯一的。（两个线程 t1 和 t2，同时访问对象 synchronized 修饰的普通方法，t1 对象锁后，t2访问对象所有synchronized 修饰的方法都必须等待。但t2可以可以访问对象的未被synchronized修饰的方法。）

二、类锁

（1） 修饰静态 static 方法或代码块

（2）使用代码块，需引用当前的类

public static synchronized void test(){
       ...
}

public static void test(){
    synchronized (TestSynchronized.class) { //注意传入的是TestSynchronized.class
        ...
    }
}

实例：

public class MySynchronized {
    public static void main(String[] args) {

        Thread t6 = new Thread(new Runnable() {

            @Override
            public void run() {
                MyTest.Min5();
            }
        }, "t6");

        Thread t7 = new Thread(new Runnable() {

            @Override
            public void run() {
                MyTest.Min5();
            }
        }, "t7");
        
        Thread t8 = new Thread(new Runnable() {
            @Override
            public void run() {
                MyTest.Min6();
            }
        }, "t8");
        
        t6.start();
        t7.start();
        t8.start();
    }
}


class MyTest{
    static  final  int Num = 3;
    
    public static synchronized void Min5() {
        int c5 = 5;
        for (int i = 0; i < Num; i++) {
            c5--;
            System.out.println(Thread.currentThread().getName() + " - " + c5);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }
    
     public static synchronized void Min6() {
        int c6 = 5;
        for (int i = 0; i < Num; i++) {
            c6--;
            System.out.println(Thread.currentThread().getName() + " - " + c6);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }
}

输出：

结论：静态方法的锁是所有对象唯一的。每次只能有一个线程来访问。（t1线程拥有锁之后，t2不能访问所有被synchronized修饰的静态方法，但是可以访问**未**被synchronized修改的静态方法。）

 三、对象锁和类锁不会相互影响

类锁和对象锁是不一样的锁，是互相独立的。

实例：

/*
静态方法synchronized和实例synchronized互相独立
*/
public class MySynchronized {
    public static void main(String[] args) {

        final MyTest mt = new MyTest();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                mt.Min1();
            }
        }, "t1");

        Thread t7 = new Thread(new Runnable() {
            @Override
            public void run() {
                MyTest.Min5();
            }
        }, "t7");

        t1.start();
        t7.start();
    }
}


class MyTest{

    static final int Num = 3;

    //synchronized静态方法
    public static synchronized void Min5() { 
        int c5 = 5;
        for (int i = 0; i < Num; i++) {
            c5--;
            System.out.println(Thread.currentThread().getName() + " - " + c5);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }

    //synchronized实例方法
    public synchronized void Min1(){
        int c = 5;
        for (int i = 0; i < Num; i++) {
            c--;
            System.out.println(Thread.currentThread().getName() + " - " + c);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
        }
    }
}

输出：

 

 

 

 

 

大锅菜～
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java线程之线程同步synchronized和volatile详解
08-28
Java线程之线程同步synchronized和volatile详解 Java线程同步是Java多线程编程中...Java线程同步是Java多线程编程中非常重要的一个方面，需要正确地使用synchronized和volatile关键字来保证线程安全、可见性和有序性。
java多线程中的volatile和synchronized用法分析
09-04
synchronized关键字提供了更强大的线程同步能力。它可以通过修饰方法或同步代码块来实现。在`SynchronizedTest`类中，`count++`操作被包含在一个synchronized块内，这意味着同一时间只有一个线程能够执行这段代码，...
Java中的并发：线程安全性
c1776167012的博客
10-11 307
一.什么是线程安全性？ 当多个线程访问某个类时，不管运行时环境采用何种调度方式，或者这些进程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，则这个类是线程安全的。 二.线程安全性具体体现在哪儿？ 1.原子性：提供互斥访问，同一时刻只能有一个线程对它进行操作。 java中如何体现原子性的： Atomic包中的类主要通过CAS实现原子性 CAS的含义是：CompareAndSwap 原理是： public final int getAndAddInt(Object va
一文教会你什么线程安全以及如何实现线程安全
qq_39350172的博客
12-16 2358
title: 一文教会你什么线程安全以及如何实现线程安全 tags: 线程安全 Java并发 Java内存模型 synchronized volatile Lock 文章目录一、线程安全的概念二、导致线程不安全的原因三、线程安全问题3.1 原子性3.2 可见性3.3 有序性案例：抢票四、如何确保线程安全？4.1 synchronized关键字4.1.1 同步代码块4.1.2 同步函数4.1.3 多线程死锁线程4.2 Lock4.3 volatile关键字解决办法：4.4 synchronized、vol.
如何保证线程按顺序执行
weixin_30627341的博客
12-01 605
Thread类构造方法：1.Thread（）；2.Thread（String name）；3.Thread（Runable r）；4.Thread（Runable r, String name）； thread类常用方法：start();//启动线程getId();//获得线程IDgetName();//获得线程名字getPriority();//获得优先权isAlive();//判断线程是否活...
JVM-02-运行时数据区概述及线程
Coding~Farmer
10-13 273
运行时数据区概述及线程 翻译自–>尚硅谷_宋红康讲解的JVM课程 这里讲的是HotSpot虚拟机！ 运行时数据区 阿里手册中的运行时数据区图 运行时数据区简图 Java虚拟机定义了若干种程序运行期间会使用到的运行时数据区，其中有一些会随着虚拟机启动而创建，随着虚拟机退出而销毁。另外一些则是与线程一一对应的，这些线程对应的数据区会随着线程开始和结束而创建和销毁。 灰色的为单独线程私有的，红色的为多个线程共享的： 每个线程：独立包括程序计数器、栈、本地栈。 线程间共享：堆、堆外内存（永久代或元空间、
线程安全中的原子性，有序性和可见性
最新发布
z_ssyy的博客
01-04 241
对于Java并发编程，一般来说有以下的关注点：线程安全性，正确性。线程的活跃性(死锁，活锁)性能其中线程的安全性问题是首要解决的问题，线程不安全，运行出来的结果和预期不一致，那就连基本要求都没达到了。保证线程的安全性问题，本质上就是保证线程同步，实际上就是线程之间的通信问题。我们知道，在操作系统中线程通信有以下几种方式：信号量信号管道共享内存消息队列socketjava中线程通信主要使用共享内存的方式。共享内存的通信方式首先要关注的就是可见性和有序性。
学习Java多线程之volatile域
09-02
Java多线程中的volatile关键字是Java提供的一个较弱的同步机制，用于解决多线程环境下的数据一致性问题。volatile确保了变量在多个线程之间的可见性，并限制了指令重排序，但并不保证原子性。 首先，理解Java内存...
Java关键字volatile和synchronized作用和区别
08-30
Java关键字volatile和synchronized是Java语言中两个常用的关键字，它们都是用来解决多线程编程中的同步问题的，但它们的作用和用法却有所不同。 volatile关键字是变量修饰符，它的作用是确保变量在多个线程之间的...
深入探讨Java多线程中的volatile变量
09-02
总的来说，volatile变量是Java多线程编程中的一种轻量级同步机制，适用于那些不需要复杂同步控制的简单场景。理解和正确使用volatile变量，可以有效地提高多线程程序的性能和正确性。然而，需要注意的是，它不能完全...
多线程-使线程具有有序性
weixin_34081595的博客
09-04 122
使线程具有有序性： 线程在运行时多个线程之间执行的时机是无序的，下面通过改造代码实现运行具有有序性： 1 /** 2 * 线程类 3 */ 4 public class MyThread extends Thread { 5 private Object lock; 6 private String showChar; 7 pri...
php线程安全和非线程安全_线程安全和保证线程安全的两个方法
weixin_39882948的博客
11-20 191
之前讲了什么是线程和多线程，接下来敲黑板：线程安全。什么是线程安全？线程安全就是确保程序在多线程运行的情况下，程序能够按照预期运行，不会存在二义性的结果。比如上一篇我们提到的火车票的售票问题，预期的情况下，我们需要确保同一张票只能被唯一的窗口售出一次。下面我们用代码说明：（我们这里调用Runnable实现多线程，不保证线程安全的情况）Class1:实现一个Runnable接口public Clas...
读《Java并发编程的艺术》（二）
Bug君的博客
10-06 268
作者： 方腾飞 魏鹏 程晓明 第三章、Java内存模型 1、Java内存模型的抽象结构 （1）所有实例域、静态域和数组元素都存储在堆内存中，堆内存在线程之间共享 （2）局部变量和异常处理器参数不会在线程之间共享，它们不会有内存可见性问题，也不受内存模型的影响 （3）Java内存模型JMM巨鼎一个线程对共享变量的写入何时对另一个线程可见 （4）JMM通过控制主内存与每个线程的本地内存之间的交互，来为Java程序提供内存可见性保证 2、从源代码到指令序列的重排序类型 （1）编译器优化的重排
如何保障有序性（零碎笔记）
weixin_49894931的博客
03-11 195
如何保障有序性 硬件如何保障： 乱序问题 如何保证特定的情况下不乱序 硬件的有序性保障 Java的汇编指令 JVM的如何规范
如何保证消息的有序性呢？
weixin_44224292的博客
10-13 303
如何保证消息的有序性呢？ 在部分场景中，消息的消费有可能存在强制的上下关联性，这个时候我们怎么去保证消息队列的消息消费是有序的呢？ 可以根据消息标识，讲统一标识的消息统一推送到同一个队列，并且由一个服务单独消费一个消息队列，这样我们就可以保证消息消费的有序性。 ...
怎么让线程运行具有有序性
绅士jiejie的博客
08-03 758
多线程运行，基于CPU的时间片调度机制，线程运行的情况也会不同，优先级也不能够做到控制线程之间的运行顺序，所以如果需要让几个线程间有序的执行，需要根据运行的规则，自己定义一个线程类。 代码demo： public class SortThread extends Thread { //锁 private Object lock; //要打印的字母 private String printChar; //需要打印字母的顺序所对应的取余值 private int
final域、Atomic和ThreadLocal
a_higher的博客
11-17 783
解决并发2种方式 对于并发工作,需要某种方式来防止两个任务同时访问相同的资源，至少在关键阶段不能出现这种冲突情况。 资源被一个任务使用时，在其上加锁 根除对变量的共享。线程本地存储是一种自动化机制，可以为使用相同变量的每个不同的线程都创建不同的存储。因此，如果你有5个线程都要使用变量x所表示的对象，那线程本地存储就会生成5个用于x的不同的存储块。它使得你可以将状态与线程关联起来。创建和管理线程本地存储可以由java.lang.ThreadLocal类来实现。 final 对于final域，编译器和处
保证线程的有序性，使用jion方法
IAProgramer的博客
05-20 548
public class GuaranteeOrder implements Runnable{  static int count = 0;  @Override  public void run() {   try{    Thread.sleep(100);    setCount();    System.out.println("count结果为："+getCount()+

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

大锅菜～

谢谢鼓励~

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

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

打赏作者

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

抵扣说明：

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

余额充值