高级JAVA必会系列二：多线程经常使用的3个关键字：synchronized、ReentrantLock、volatile

最新推荐文章于 2023-03-02 20:49:36 发布
最新推荐文章于 2023-03-02 20:49:36 发布
阅读量296 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/it_monkey_ali/article/details/80511467
版权

一.synchronized

(1)用法:

1.修饰实例方法:

package com.retail.sync;

/**
 * @author Tom
 */
public class AccountingSync implements Runnable {

    /**
     * 共享资源(临界资源)
     */
    static int i = 0;

    /**
     * synchronized 修饰实例方法
     */
    public synchronized void increase() {
        i++;
    }

    @Override
    public void run() {
        for (int j = 0; j < 1000000; j++) {
            increase();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        AccountingSync instance = new AccountingSync();
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
    /**
     * 输出结果:
     * 2000000
     */
}

 

package com.retail.sync;

/**
 * @author Tom
 */
public class AccountingSyncBad implements Runnable {
    static int i = 0;

    public synchronized void increase() {
        i++;
    }

    @Override
    public void run() {
        for (int j = 0; j < 1000000; j++) {
            increase();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //new新实例
        Thread t1 = new Thread(new AccountingSyncBad());
        //new新实例
        Thread t2 = new Thread(new AccountingSyncBad());
        t1.start();
        t2.start();
        //join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
        t1.join();
        t2.join();
        System.out.println(i);

        /**
         * 输出结果:
         * 1225662
         */
    }
}

2.修饰静态方法:

package com.retail.sync;

public class AccountingSyncClass implements Runnable {
    static int i = 0;

    /**
     * 作用于静态方法,锁是当前class对象,也就是
     * AccountingSyncClass类对应的class对象
     */
    public static synchronized void increase() {
        i++;
    }

    /**
     * 非静态,访问时锁不一样不会发生互斥
     */
    public synchronized void increase4Obj() {
        i++;
    }

    @Override
    public void run() {
        for (int j = 0; j < 1000000; j++) {
            increase();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //new新实例
        Thread t1 = new Thread(new AccountingSyncClass());
        //new心事了
        Thread t2 = new Thread(new AccountingSyncClass());
        //启动线程
        t1.start();
        t2.start();

        t1.join();
        t2.join();
        System.out.println(i);

        /**
         * 输出结果:
         * 2000000
         */
    }
}

3.修饰代码块: 

package com.retail.sync;

/**
 * @author Tom
 */
public class AccountingSyncBlock implements Runnable {

    static AccountingSyncBlock instance = new AccountingSyncBlock();
    static int i = 0;

    @Override
    public void run() {
        //省略其他耗时操作....
        //使用同步代码块对变量i进行同步操作,锁对象为instance
        synchronized (instance) {
            for (int j = 0; j < 1000000; j++) {
                i++;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }

    /**
     * 输出结果:
     * 2000000
     */

}

(1)底层: 

Java 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现， 无论是显式同步(有明确的 monitorenter 和 monitorexit 指令,即同步代码块)还是隐式同步都是如此。在 Java 语言中，同步用的最多的地方可能是被 synchronized 修饰的同步方法。同步方法 并不是由 monitorenter 和 monitorexit 指令来实现同步的，而是由方法调用指令读取运行时常量池中方法的 ACC_SYNCHRONIZED 标志来隐式实现的，关于这点，稍后详细分析。下面先来了解一个概念Java对象头，这对深入理解synchronized实现原理非常关键。
 

 在JVM中，对象在内存中的布局分为三块区域：对象头、实例数据和对齐填充

  • 实例变量：存放类的属性数据信息，包括父类的属性信息，如果是数组的实例部分还包括数组的长度，这部分内存按4字节对齐。

  • 填充数据：由于虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的，仅仅是为了字节对齐，这点了解即可。

 

二.ReentrantLock

在JDK5.0版本之前，重入锁的性能远远好于synchronized关键字，JDK6.0版本之后synchronized 得到了大量的优化，二者性能也不分伯仲，但是重入锁是可以完全替代synchronized关键字的。除此之外，重入锁又自带一系列高逼格UBFF：可中断响应、锁申请等待限时、公平锁。另外可以结合Condition来使用，使其更是逼格满满。

1.

package com.retail.lock;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author Tom
 */
public class ReentrantLockTest implements Runnable {
    public static ReentrantLock lock = new ReentrantLock();
    public static int i = 0;

    @Override
    public void run() {
        for (int j = 0; j < 10000; j++) {
            lock.lock();  // 看这里就可以
            //lock.lock(); ①
            try {
                i++;
            } finally {
                lock.unlock(); // 看这里就可以
                //lock.unlock();②
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLockTest test = new ReentrantLockTest();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.start();
        t2.start();
        t1.join();
        t2.join(); // main线程会等待t1和t2都运行完再执行以后的流程
        System.err.println(i);
    }
}

2.可中断

package com.retail.lock;


import java.util.concurrent.locks.ReentrantLock;

/**
 * @author Tom
 */
public class KillDeadlock implements Runnable {
    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();
    int lock;

    public KillDeadlock(int lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            if (lock == 1) {
                lock1.lockInterruptibly();  // 以可以响应中断的方式加锁
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
                lock2.lockInterruptibly();
            } else {
                lock2.lockInterruptibly();  // 以可以响应中断的方式加锁
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
                lock1.lockInterruptibly();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock1.isHeldByCurrentThread()) lock1.unlock();  // 注意判断方式
            if (lock2.isHeldByCurrentThread()) lock2.unlock();
            System.err.println(Thread.currentThread().getId() + "退出！");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        KillDeadlock deadLock1 = new KillDeadlock(1);
        KillDeadlock deadLock2 = new KillDeadlock(2);
        Thread t1 = new Thread(deadLock1);
        Thread t2 = new Thread(deadLock2);
        t1.start();
        t2.start();
        Thread.sleep(1000);
        t2.interrupt(); // ③
    }
}

3.锁申请等待超时

可以使用 tryLock()或者tryLock(long timeout, TimeUtil unit) 方法进行一次限时的锁等待。

package com.retail.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author Tom
 */
public class TryLockTest implements Runnable {
    public static ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            if (lock.tryLock(1, TimeUnit.SECONDS)) { // 等待1秒
                Thread.sleep(2000);  //休眠2秒
            } else {
                System.err.println(Thread.currentThread().getName() + "获取锁失败！");
            }
        } catch (Exception e) {
            if (lock.isHeldByCurrentThread()) lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TryLockTest test = new TryLockTest();
        Thread t1 = new Thread(test);
        t1.setName("线程1");
        Thread t2 = new Thread(test);
        t1.setName("线程2");
        t1.start();
        t2.start();
    }
}
/**
 * 运行结果:
 * 线程2获取锁失败！
 */

4.公平锁:

所谓公平锁，就是按照时间先后顺序，使先等待的线程先得到锁，而且，公平锁不会产生饥饿锁，也就是只要排队等待，最终能等待到获取锁的机会。

package com.retail.lock;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author Tom
 */
public class FairLockTest implements Runnable {
    public static ReentrantLock lock = new ReentrantLock(true);

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                System.err.println(Thread.currentThread().getName() + "获取到了锁！");
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        FairLockTest test = new FairLockTest();
        Thread t1 = new Thread(test, "线程1");
        Thread t2 = new Thread(test, "线程2");
        t1.start();
        t2.start();
    }
}
/**
 * 运行结果:
 * 线程1获取到了锁！
 * 线程2获取到了锁！
 * 线程1获取到了锁！
 * 线程2获取到了锁！
 * 线程1获取到了锁！
 * 线程2获取到了锁！
 * 线程1获取到了锁！
 * 线程2获取到了锁！
 * 线程1获取到了锁！
 * 线程2获取到了锁！
 * 线程1获取到了锁！
 * 线程2获取到了锁！
 * 线程1获取到了锁！
 * 线程2获取到了锁！
 * 线程1获取到了锁！
 * 线程2获取到了锁！
 * ......（上边是截取的一段）
 */

 

三.volatile

java内存分为工作内存和主存
工作内存：即java线程的本地内存，是单独给某个线程分配的，存储局部变量等，同时也会复制主存的共享变量作为本地
的副本，目的是为了减少和主存通信的频率，提高效率。
主存：存储类成员变量等

可见性:线程访问变量是否是最新值

 

 

 

package com.retail.vol;

/**
 * @author Tom
 */
public class Task implements Runnable {

    volatile boolean running = true;

    int i = 0;


    @Override
    public void run() {
        while (running) {
            i++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Task task = new Task();
        Thread th = new Thread(task);
        th.start();
        Thread.sleep(10);
        task.running = false;
        Thread.sleep(10);
        System.out.println(task.i);

    }
}

 

it_monkey_ali
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程安全性基础介绍.pptx
07-25
java多线程安全性基础介绍 线程安全 正确性 什么是线程安全性 原子性 竞态条件 i++ 读i ++ 值写回i 可见性 JMM 由于cpu和内存加载速度的差距，在两者之间增加了多级缓存导致，内存并不能直接对cpu可见。 ...
ReentrantLock 、synchronized和volatile比较
suncat的博客
10-21 686
Lock 作用：显式加锁 原理 (1)通过同步器AQS（AbstractQueuedSynchronized类）来实现的，AQS根本上是通过一个双向队列来实现的 (2)线程构造成一个节点，一个线程先尝试获得锁，如果获取锁失败，就将该线程加到队列尾部 (3)非公平锁的lock方法,调用的sync（NonfairSync和fairSync的父类）的lock方法 public Reent...
synchronized、volatile、ReentrantLock简单了解与对比
iwanttostudyok的博客
03-02 182
Java 关键字
简单对比一下synchronized、volatile、ReentrantLock
做一个有思想的技术人
02-08 356
面试必背
高级java必会系列二：多线程经常使用的3个关键字：synchronized、ReentrantLock、volatile...
博客园搬家测试账号
03-15 180
系列一讲解了多线程，本章讲解多线程开发中经常使用到的3个关键字synchronized、ReentrantLock、volatile。 一、synchronized 　　互斥锁，即操作互斥，并发线程过来，串行获得锁，串行执行代码。就像一个房间一把钥匙，一个人进去后，下一个人得等第一个人出来得到钥匙才能进入。如果代码写的不好（A），可能出现死锁！（A得到锁，B等待A释放锁，A不释放，B死锁） 示例代...
Java面试题二：synchronized 和 volatile 、ReentrantLock 、CAS 的区别
songzi1228的博客
08-21 3930
目录 0、相关文章： 1、synchronized关键字的作用 2、volatile关键字的作用 3、volatile和synchronized的作用和区别是什么？ 4、CAS机制详解 5、ReentrantLock(重入锁)详解 六、ReenTrantLock可重入锁（和synchronized的区别）总结 0、相关文章： Java中线程安全的体现（原子性、可见性、有序性）（自...
【2018最新最详细】并发多线程教程
11-15
【2018最新最详细】并发多线程教程，课程结构如下 1.并发编程的优缺点 2.线程的状态转换以及基本操作 3.java内存模型以及happens-before规则 4.彻底理解synchronized 5.彻底理解volatile 6.你以为你真的了解final吗...
java8集合源码分析-Notes:笔记
06-04
java8 集合源码分析 [TOC] 0. 项目构建 0.1 版本控制 0.1.1 Git 0.2 ...多线程：synchronized 关键字（修饰类，方法，静态方法，代码块）] [Java 多线程：Lock 接口（接口方法分析，ReentrantLock，
Java理论与实践:JDK 5.0中更灵活、更具可伸缩性的锁定机制
03-04
本文介绍了多线程和并发性并不是什么新内容，但是Java语言设计中的创新之一就是，它是第一个直接把跨平台线程模型和正规的内存模型集成到语言中的主流语言。核心类库包含一个Thread类，可以用它来构建、启动和操纵...
汪文君高并发编程实战视频资源全集
08-08
 高并发编程第三阶段30讲 使用Condition实现一个多线程下的Producer-Consumer_.mp4  高并发编程第三阶段31讲 JDK8-StampedLock详细介绍-上_.mp4  高并发编程第三阶段32讲 JDK8-StampedLock详细介绍-下.mp4  高...
ReentrantLock与synchronized区别
03-02
java语言 并发编程 ReentrantLock与synchronized区别 详解
synchronized、ReentrantLock和volatile关键字的比较
weixin_41904925的博客
06-28 162
Synchronized和ReentrantLock的区别？ ①两者都是可重入锁 ②Synchronized依赖于JVM，而ReentrantLock依赖于API。 ③ReentrantLock比Synchronized增加了一些高级功能。比如：等待可中断、可实现公平锁、可实现选择性通知。 ④性能已经不是选择标准了。 Synchronized关键字和Volatile关键字的比较？ 1、volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是vola
多线程基础---线程安全(原因及解决方法),synchronized,volatile关键字
weixin_43939602的博客
06-07 196
1. 中断线程 1) 使用标志位的方式 public class FlagStop { private static volatile boolean isStop; public static void main(String[] args) throws InterruptedException { new Thread(new Runnable() { @Override public void run() {
volatile、synchronized、ReentrantLock与CAS
amunamuna
06-18 546
摘自: https://blog.csdn.net/zxh476771756/article/details/78685581 https://blog.csdn.net/tiandao321/article/details/80811103 文章目录一、**JVM内存模型：**二、**volatile关键字**1、**volatile保证内存可见性。**2、**能禁止指令重排序**3、**不能保...
同步相关：volatile synchronized Lock ReentrantLock
一气道盟王富贵儿
03-21 705
零、基本概念 1、并发编程中的三个概念: 原子性：即一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。 可见性:是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。 有序性：即程序执行的顺序按照代码的先后顺序执行。 要想并发程序正确地执行，必须要保证原子性、可见性以及有序...
synchronized和ReentrantLock 、volatile关键字的区别
yiyiyuebing的博客
04-26 372
谈谈 synchronized和ReentrantLock 的区别 ① 两者都是可重入锁 两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。 ② synch...
java多线程：ReentrantLock的使用，实现共享变量线程安全
ko8be24的博客
11-29 837
1.ReentrantLock的介绍 ReentrantLock是独占锁且是可重入的 ReentrantLock可以实现公平锁 ReentrantLock可中断响应 ReentrantLock可获取锁时限时等待 2.使用ReentrantLock的lock方法获取锁，unlock方法释放锁，模拟多线程实例如下： public class LockDemo { pr...
java多线程关键字volatile、lock、synchronized
pengfeijiuwanli的博客
10-07 155
一、volatile volatile写和volatile读的内存语义： 线程A写一个volatile变量，实质上是线程A向接下来将要读这个volatile变量的某个线程发出了（其对共享变量所在修改的）消息。 线程B读一个volatile变量，实质上是线程B接收了之前某个线程发出的（在写这个volatile变量之前对共享变量所做修改的）消息。 线程A写一个volatile变量，随后线程B读这个...
java并发编程synchronized、volatile关键字及ReentrantLock类总结
abasen的专栏
03-25 2324
1、java为解决并发问题引入的关键字synchronized, volatile ，怎么用？ synchronized 修饰的方法 或者 代码块（保证可见性和排他性）； synchronized修饰静态方法时（或方法时）同步的是这个对象类级别的；synchronized修饰方法时，同步的是对象实例级别的 volatile修饰变量（仅保证可见性）； 每个线程运行时都有一个线程栈，线程栈
使用synchronized 关键字、volatile、ReentrantLock 类与阻 操作系统原理 塞列队 LinkedBlockingQueue<E>几种同步方法，完成主线程与子线程的同步，写出实验小结
最新发布
05-27
volatile 是一个关键字，用于修饰变量，用于实现多线程之间的可见性，即当一个线程修改了一个 volatile 变量的值时，其他线程可以立即看到这个修改。 ReentrantLock 类是一个可重入的互斥锁，可以用来实现线程间的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值