【Java多线程】总结（二）线程状态 线程安全问题 可重入锁ReentrantLock 与 内存锁synchronized

已于 2023-03-15 13:25:46 修改
阅读量317 收藏
点赞数 1
分类专栏： 笔记 多线程 文章标签： java 开发语言 后端
于 2022-04-03 09:30:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54184658/article/details/123932799
版权
1 线程状态

1 打印线程的所有状态

private static void printState() {
    for(Thread.State item:Thread.State.values())
        System.out.println(item);
}
NEW
RUNNABLE
BLOCKED
WAITING 等待
TIMED_WAITING 超时等待 有明确结束时间
TERMINATED

2 线程状态：

  1. new:新建状态，当线程被创建，但未启动（start（）之前
  2. runnable:运行状态
    1. 运行：得到时间片运行中状态
    2. 就绪：未得到时间片就绪状态 （保存了上下文
  3. blocked:阻塞状态，如果遇到锁线程就会变为阻塞状态，等到另一个线程释放锁
  4. waiting：休眠 等待状态（无明确等待时间
  5. timed_waiting：休眠 等待状态（有明确结束时间
  6. terminated：销毁状态，线程结束之后会变成此状态

3 获取线程状态：

public static void main(String[] args) throws InterruptedException {
        //printState();
        Thread t1=new Thread(()->{
            System.out.println("当前线程状态2："+Thread.currentThread().getState());
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("当前线程状态："+t1.getState());
        t1.start();
        //让主线程休眠1秒
        Thread.sleep(1000);
        System.out.println("当前线程状态3："+t1.getState());
        //等子线程执行完
        t1.join();
        System.out.println("当前线程状态4："+t1.getState());
    }
2 线程安全

1 线程安全问题：多线程执行环境下，程序执行结果和预期不符；

2 导致线程不安全的原因：

  1. 抢占式执行（狼多肉少

  2. 多个线程同时修改同一个变量

  static class Counter{
        private int number=0;
        private int MAX_COUNT=0;
        public Counter(int MAX_COUNT){
            this.MAX_COUNT=MAX_COUNT;
        }
        //++方法
        public void increment(){
            for (int i = 0; i < MAX_COUNT; i++) {
                number++;
            }
        }
        public void decrement(){
            for (int i = 0; i < MAX_COUNT; i++) {
                number--;

            }
        }
        public int getNumber(){
            return number;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Counter c=new Counter(100000);
        Thread th=new Thread(()->{
            c.increment();
        });
        Thread th1=new Thread(()->{
            c.decrement();
        });
        // c.increment();单线程时++——没问题
        // c.decrement();

        //启动多线程进行执行
        th.start();
        th1.start();
        //等待两个线程执行完
        th.join();
        th1.join();
        System.out.println("最终结果"+ c.getNumber());
    }
结果应该是0
最终结果8100

换种方式 使用全局变量接受结果后 结果为0

static class Counter{
        private int number=0;
        private int MAX_COUNT=0;
        public Counter(int MAX_COUNT){
            this.MAX_COUNT=MAX_COUNT;
        }

        //++方法
        public int increment(){
            int tep=0;
            for (int i = 0; i < MAX_COUNT; i++) {
//                number++;
                tep++;
            }
            return tep;
        }
        public int decrement(){
            int tep=0;
            for (int i = 0; i < MAX_COUNT; i++) {
//                number--;
                tep--;
            }
            return tep;
        }
        public int getNumber(){
            return number;
        }
    }
    //全局变量接收线程执行结果
    static int n1=0;
    static int n2=0;
    public static void main(String[] args) throws InterruptedException {
        Counter c=new Counter(100000);
        Thread th=new Thread(()->{
          n1 = c.increment();
        });
//        th.start(); th.join();
        Thread th1=new Thread(()->{
            n2=c.decrement();
        });
//        c.increment();
//        c.decrement();
        th.start();
        th1.start();
        th.join();
        th1.join();
//        System.out.println("最终结果"+ c.getNumber());
        System.out.println("最终结果"+ (n1+n2));
    }
}
0
  1. 操作是非原子性操作（tep++ 1.查询当前tep的值 2.tep-1操作 3.刷新tep的最新值
    1 线程从主内存读出最新的值Value
    2 放到线程的虚拟机栈的栈帧中的操作栈先压入，再弹出，供CPU计算+1，计算完再压入再弹出
    3 线程新值只写回到内存中

请添加图片描述

  1. 内存可见性问题

是指当某个线程正在使用对象状态而另一个线程在同时修改该状态，需要确保当一个线程修改了对象状态后，其他线程能够立即看到发生的状态变化。 由于线程之间的交互都发生在主内存中，但对于变量的修改又发生在自己的工作内存中，经常会造成读写共享变量的错误，我们也叫可见性错误。

使用 volatile解决内存可见性问题（也可解决指令重排序问题

package ThreadSafe;

import java.time.LocalDateTime;

/**
 * 内存可见性问题
 * 
 */
public class ThreadSafe1 {
    private static volatile boolean flag=true;

    public static void main(String[] args) {
        //创建子线程
        Thread t1=new Thread(()->{
            System.out.println("线程1：开始执行"+ LocalDateTime.now());
            while(flag){
            }
            System.out.println("线程1：执行结束"+LocalDateTime.now());
        });
        t1.start();
        Thread t2=new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程2修改flag=false"+LocalDateTime.now());
            flag=false;
        });
        t2.start();
    }
}
/**
 * 线程1：开始执行2022-04-03T10:40:54.170
 * 线程2修改flag=false2022-04-03T10:40:55.126
 */

JMM Java Memory Model (JAVA 内存模型 ）：
是描述线程之间如何通过内存来进行交互。 具体说来， JVM中存在一个主存区（Main Memory或Java Heap Memory），对于所有线程进行共享，而每个线程又有自己的工作内存（Working Memory），工作内存中保存的是主存中某些变量的拷贝，线程对所有变量的操作并非发生在主存区，而是发生在工作内存中，而线程之间是不能直接相互访问，变量在程序中的传递，是依赖主存来完成的。其⽬的是屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到⼀致的并发效果.

Java内存模型的抽象示意图如下
请添加图片描述

  1. 指令重排序：编译或运行指令重排序（”jvm自作聪明（优化）“）

    编译器优化的本质是调整代码的执⾏顺序，在单线程下没问题，但在多线程下容易出现混乱，从⽽造成
    线程安全问题。
    请添加图片描述

3 解决线程安全问题的手段：

1 使用Volatile解决内存可见性问题和指令重排序问题
在这里插入图片描述

  1. 代码在写⼊ volatile 修饰的变量的时候：

    改变线程⼯作内存中volatile变量副本的值,将改变后的副本的值从⼯作内存刷新到主内存

  2. 代码在读取 volatile 修饰的变量的时候：

    从主内存中读取volatile变量的最新值到线程的⼯作内存中,从⼯作内存中读取volatile变量的副本

  3. 缺点：
    volatile 虽然可以解决内存可⻅性和指令重排序的问题，但是解决不了原⼦性问题，因此对于 ++ 和 --操作的线程⾮安全问题依然解决不了

4 使用锁是java中解决线程安全问题最主要的手段：

  1. 内存锁：synchronized

  2. 可重入锁：ReentrantLock

5 synchronized基本用法（非公平锁 互斥锁 可重入锁）：

1 修饰静态方法：

public class TreadDemo_synchronized {
    private static int number=0;
    static class Counter{
        private static int MAX_COUNT=200000;
        //++方法
        public synchronized static void increment(){
            for (int i = 0; i < MAX_COUNT; i++) {
                number++;
            }
        }
        public synchronized static void decrement(){
            for (int i = 0; i < MAX_COUNT; i++) {
                number--;
            }
        }
        public static int getNumber(){
            return number;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread th=new Thread(()->{
            Counter.increment();
        });
        th.start();
        Thread th1=new Thread(()->{
            Counter.decrement();
        });
        th1.start();
        th.join();th1.join();
        System.out.println("最终结果"+ number);
    }
}

2 修饰普通方法：

package ThreadSafe;

public class TreadDemo_synchronized2 {
    private static int number=0;
    static class Counter{
        private int MAX_COUNT=0;
        public Counter(int MAX_COUNT){
            this.MAX_COUNT=MAX_COUNT;
        }

        //++方法
        public synchronized void increment(){
            for (int i = 0; i < MAX_COUNT; i++) {
                number++;
            }
        }
        public synchronized  void decrement(){
            for (int i = 0; i < MAX_COUNT; i++) {
                number--;
            }
        }
        public  int getNumber(){
            return number;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Counter c=new Counter(100000);

        Thread th=new Thread(()->{
            c.increment();
        });
        th.start();
        Thread th1=new Thread(()->{
            c.decrement();
        });
        th1.start();
        th.join();th1.join();
        System.out.println("最终结果"+ number);
    }

}

3 修饰代码块：

  1. 修饰类:synchronized（类名.class)

  2. 修饰类实例：synchronized(this)

public class ThreadSynchronized3 {
    private static int number = 0;
 
    static class Counter {
        private static final int count = 100000;
 
        // 自定义锁对象
        final Object myLock = new Object();
 
        // ++方法
        public void increase() {
            for (int i = 0; i < count; i++) {
                synchronized (myLock) {
                    number++;
                }
            }
        }
 
        // --方法
        public void desc() {
            for (int i = 0; i < count; i++) {
                synchronized (myLock) {
                    number--;
                }
            }
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread thread1 = new Thread(counter::increase);
        thread1.start();
        Thread thread2 = new Thread(counter::desc);
        thread2.start();
 
        thread1.join();
        thread2.join();
        System.out.println("最终结果：" + number);
    }
}

注意事项：对于同一个业务的多个线程加锁对象，一定要是同一个对象加同一把锁

public class ThreadSynchronized {
    private static final int count = 100000;
    static int num = 0;
 
    public static void main(String[] args) throws InterruptedException {
        Object obj = new Object();
        Object obj2 = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (obj) {
                for (int i = 0; i < count; i++) {
                    num++;
                }
            }
        }, "线程1");
        t1.start();
        Thread t2 = new Thread(() -> {
            synchronized (obj2) {
                for (int i = 0; i < count; i++) {
                    num--;
                }
            }
        }, "线程2");
        t2.start();
        t1.join();
        t2.join();
        System.out.println("最终执⾏结果：" + num);
    }
}
6 syntronized特性：

1 互斥性（排他性

synchronized 会起到互斥效果, 某个线程执⾏到某个对象的 synchronized 中时, 其他线程如果也
执⾏到同⼀个对象 synchronized 就会阻塞等待.

  1. 进⼊ synchronized 修饰的代码块, 相当于 加锁
  2. 退出 synchronized 修饰的代码块, 相当于 解锁

2 刷新内存（内存可见性问题

3 synchronized 的⼯作过程:

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

4 可重入：
synchronized⽤的锁是存在Java对象头⾥的，里面有是否加锁的标志，以及拥有当前🔒的id

  1. 查询当前对象头是否加锁
  2. 判断隐藏对象头中的线程id是否等于当前线程的id
 public class ThreadDemo_synchronized5 {
     public static void main(String[] args) {
         synchronized( ThreadDemo_synchronized5.class){
             System.out.println("当前主线程获得了🔒");
 a b: (true) synchronized( ThreadDemo_synchronized5.class){
                 System.out.println("当前主线程再次获得🔒");
             }
         }
     }
 }
7 synchronized实现原理：

保证任何时候只有一个线程能够执行指定区域的代码

1 jvm层面依靠监视器Monitor实现(使用了一个对象的隐藏对象头 里面的两个a,b属性实现)

  1. jdk1.6之前使用比较少（默认重量级锁实现，所以性能较差）

  2. jdk1.6优化了
    无锁（没有线程）——>偏向锁（一个线程）——>轻量级锁（少量线程）——>重量级锁（较多线程 锁升级）

2 从操作系统的层面实现，基于操作系统的互斥锁（Mutax）

8 公平锁和非公平锁的区别：

1 公平锁一定要执行的步骤：

  1. 上一个线程释放线程后执行唤醒操作
  2. 自旋后 最前面阻塞休眠的线程 从阻塞状态切换为运行状态

2 非公平锁：来得早不如来得巧

9 ReentrantLock

1 Lock的实现步骤：

// 1.创建锁对象
Lock lock=new ReentrantLock();
// 2.加锁操作
lock.lock();
try{
    //业务代码（可能会非常复杂 -> 导致异常）
    System.out.println("你好！ ReentrantLock");
}finally {
    // 3.释放锁
    lock.unlock();
}

2 Lock注意事项：

  1. 释放锁的unlock() 操作一定要放在finally里面，若没有放在这里可能会导致永久占用资源问题

  2. 加锁操作lock() 一定要放在try之前，或者try首行
    1. 未加锁却执行了释放锁的操作
    2. 释放锁的错误信息会覆盖掉业务代码的报错信息，从而增加调试代码的复杂度

  3. 指定Lock类型：

    1. 非公平锁：默认会创建非公平锁，性能高 new ReentrantLock()
    2. 公平锁：new ReentrantLock(true)
10 synchronized VS Lock
  1. Lock 粒度可以更⼩ ，更灵活。有更多方法比如：tryLock();
  2. 锁类型不同：Lock默认是非公平锁，但可以指定为公平锁；synchronized只能为公平锁
  3. 调用lock方法和synchronized方法线程等待状态不同；lock -》waiting synchronized-》blocked
  4. Lock 需要⼿动操作锁，⽽ Synchronized 是 JVM ⾃动操作的
  5. Lock 只能修饰代码块，⽽ Synchronized 可以修饰⽅法、静态⽅法、代码块
Huyuzru
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
Java多线程并发的程序中使用互斥锁有synchronized和ReentrantLock两种方式,这里我们来详解Java多线程编程中互斥锁ReentrantLock类的用法:
Java 线程状态之 BLOCKED
Just do IT
03-30 1848
深入探讨了 Java 线程的 BLOCKED 状态, 特别是对 enter 及 reenter 两种情形进行了深入分析.
Java锁机制[深入多线程]
weixin_40815218的博客
05-08 196
文章目录一、锁分类二、锁机制三、面试题 一、锁分类 二、锁机制 三、面试题
Java多线程学习之重入锁
bernardGao94的博客
05-07 107
可重入锁的概念 可重入：某个线程(Thread-A)已经获取到某个锁(lock-A)，在该线程(Thread-A)未解锁前又再次获取到此锁(lock-A)而不出现死锁。 可重入锁：能被某个线程在未解锁前重复获取而不出现死锁现象的锁。 可重入锁的例子 synchronized 示例代码： public class ReentryLock1 { public static void mai...
ReentrantLock和synchronized两种锁定机制的对比
zzdurkjava的专栏
06-28 683
多线程和并发性 synchronized 不能中断锁 ReentrantLock还多了 锁投票，定时锁等候和中断锁等候，是可重入锁 在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态； Synchronized锁原理 属于JVM层面的 分为：方法同步和代码块同步 比如： //下列两个方法有什么区别 public synchron.
synchrnized和 ReentrantLock 比较
m0_57659908的博客
04-13 256
目录 1、两者都是可重入锁 2、实现方式 3、ReentrantLock 比 synchronized 增加了一些高级功能 1、两者都是可重入锁 “可重入锁” 指的是自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增 1，所以要等到锁的计数器下降为 0 时才能释放锁。 2、实现方式 synchronized 依赖于 JVM 而.
java多线程安全性基础介绍.pptx
07-25
java多线程安全性基础介绍 线程安全 正确性 什么是线程安全性 原子性 竞态条件 i++ 读i ++ 值写回i 可见性 JMM 由于cpu和内存加载速度的差距，在两者之间增加了多级缓存导致，内存并不能直接对cpu可见。 ...
深入理解java内置锁(synchronized)和显式锁(ReentrantLock)
08-28
主要介绍了Java多线程之内置锁(synchronized)和显式锁(ReentrantLock)的深入理解新的和用法，具有一定参考价值，需要的朋友可以了解下。
4种常用Java线程锁的特点，性能比较、使用场景.pdf
09-24
4种常用Java线程锁的特点，性能比较、使用场景 线程（thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发...
Java多线程源码笔记.pdf
05-08
1.什么是多线程 2.Thread类解析 3.使用多线程需要注意的问题 4.synchronized锁和lock锁 5.AQS 6.ReentrantLock和ReentrantReadWriteLock 7.线程池 8.死锁 9.线程常用的工具栏 10.Atomic 11.ThreadLocal
Java多线程，对锁机制的进一步分析
weixin_44627014的博客
02-02 121
1 可重入锁 可重入锁，也叫递归锁。它有两层含义，第一，当一个线程在外层函数得到可重入锁后，能直接递归地调用该函数，第二，同一线程在外层函数获得可重入锁后，内层函数可以直接获取该锁对应其它代码的控制权。之前我们提到的synchronized和ReentrantLock都是可重入锁。 通过ReEnterSyncDemo.java，我们来演示下synchronized关键字的可重入...
线程状态转换
小鲁蛋的博客
10-13 805
4）当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时，当前线程从 RUNNABLE --> TIMED_WAITING，调用 LockSupport.unpark(目标线程)，或调用了线程的 interrupt()，或是等待超时，会让目标线程从 TIMED_WAITING--> RUNNABLE。当前线程等待时间超过了 n 毫秒，当前线程从 TIMED_WAITING --> RUNNABLE。
并发编程4 - 线程状态、死锁及ReentrantLock
weixin_39505091的博客
07-27 559
文章目录一. park VS unpark1. 用法2. 原理简述二. 再述线程状态转换 一. park VS unpark 1. 用法 用于使线程等待，属于 LockSupport 的静态方法，使线程进入 Wait 状态。 与 Object 的 wait/notify 的区别： wait/notify 必须配合对象锁一起使用，而 pack/unpack 不必； park/unpark 能做到精准阻塞和唤醒某个线程，而notify只能随机唤醒一个线程，notifyAll是唤醒所有线程，不能做到精准通知；
重入锁ReentrantLock详解
贾欣晓的博客
08-07 1184
重入锁ReentrantLock，顾名思义，就是支持重进入的锁，。除此之外，该锁的还支持获取锁时的公平和非公平性选择。在AQS实现中，当一个线程调用Mutex的lock()方法获取锁之后，如果再次调用lock()方法，则该线程将会被自己所阻塞，原因是Mutex在实现tryAcquire(int acquires)方法时没有考虑占有锁的线程再次获取锁的场景，。简单的说，Mutex是一个不支持重进入的锁。......
ReentrantLock学习（四）lock&unlock过程中sync队列及状态变化
laoxilaoxi_的博客
08-30 358
一、AQS中的队列 ReentrantLock锁的实现依赖于AQS，而AQS内部实现锁是依赖于 volatile int state状态 跟volatile Node head，volatile Node tail链表， 模型大致如下 AQS中的队列 status：记录当前锁是否被占用，lock的次数，例如0代表未被占用，2代表lock了2次 exclusiveOwne...
Synchronized、Volatile和ReentrantLock
njh1147394013的博客
01-07 586
各种常用的锁： 重入锁（递归锁）：递归调用自己加锁方法的时候，可以再次进入该方法，优点就是相 同线程不需要在等待锁，而是可以直接进行相应操作。 不可重入锁：即使是本身，也只能进入一次方法。 悲观锁：对每次线程都认为会进行写操作，每次只让一个线程进入。(认为读少写多（synchronized实现）) 乐观锁：都不加锁，在更新的时候判断是否发生改变。！CAS实现的：它是一种更新原子操作，比较当前值是否和传入值一致，一样就更新。 公平锁：大家排好队，一个一个来获得锁，但是需要排队机制，而且效率不
线程学习（19）-ReentrantLock基础
key_wu的博客
05-31 1211
终于写到这了，记录下ReentrantLock的特性。 ReetentLock与Synchronized的特点比较： ReetentLock支持zhon
【Java】synchronized和ReentrantLock分析
L_MaFia的博客
05-30 311
文章目录synchronized和ReentrantLock分析代码需求：思路：代码：缺点：ReentrantLock、Condition的await和signal思路ReentrantLock用法代码：synchronized分析线程的6个状态当线程竞争不到锁时阻塞时代码：输出：当线程调用wait时代码：输出：ReentrantLock分析当线程竞争不到锁时阻塞时代码：输出：当线程调用await时代码：输出： synchronized和ReentrantLock分析 参考： 子路老师博客： https:
用java使用同步方法、同步代码块和ReentrantLock可重入锁（任选两种办法）解决第二问中的线程同步问题
最新发布
06-06
好的，针对第二个问题的线程同步问题，我们可以使用同步方法和ReentrantLock可重入锁两种方式来解决。 ### 1. 同步方法 使用同步方法可以保证在同一时刻只有一个线程能够访问被synchronized关键字修饰的方法。在本...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值