多线程与高并发编程

已于 2022-12-26 15:24:48 修改
阅读量294 收藏 1
点赞数
分类专栏： Java基础 文章标签： jvm java 单例模式
于 2022-08-27 22:35:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lfssst/article/details/126563495
版权

多线程与高并发编程2

volatile

public class VolatileDemo {
    /*volatile*/ boolean running = true;
    void m(){
        System.out.println("m start");
        while (running) {
            /*try {
                TimeUnit.MICROSECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
        }
        System.out.println("m end");
    }

    public static void main(String[] args) {
        VolatileDemo volatileDemo = new VolatileDemo();
        new Thread(volatileDemo::m,"t1").start();
         try {
                TimeUnit.MICROSECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
         volatileDemo.running = false;
    }
}

上面的程序模拟的是一个类似于服务器的流程，只要runing这个标志位的数据是ture，这个线程就会一直执行，创建线程之后会执行m.start之后会输出m start，线程启动后使其睡眠1s，希望可以把running改编为false，之后输出m end

image-20220815213634935

public class VolatileDemo {
    volatile boolean running = true;
    void m(){
        System.out.println("m start");
        while (running) {
            /*try {
                TimeUnit.MICROSECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
        }
        System.out.println("m end");
    }

    public static void main(String[] args) {
        VolatileDemo volatileDemo = new VolatileDemo();
        new Thread(volatileDemo::m,"t1").start();
         try {
                TimeUnit.MICROSECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
         volatileDemo.running = false;
    }
}

现在给标志running加上volatile

image-20220815213322248

volatile是可变的易变的

image-20220815235719177

饿汉模式（创建一个单例模式的对象不再销毁）

/**
 * @Date: 2022/08/16/00:02
 * @Description:饿汉式
 * 类加载到内存后，就是实例化一个单例，JVM保证线程安全
 * 简单实用，推荐使用
 * 唯一缺点：无论用到与否，类加载时就完成实例化
 * Class.forName("")
 * (话说你不用他，为什么要装载他)
 **/

/**
 * 使用场景 ：有一些类只需要创建一次不需要多次多个创建
 */
public class StarvingHanMode {
//    class加载到内存到内存到时候 static（由JVM来帮忙初始化的） 创建时就new 而且无参构造是私有方法别人不能new
    private static final StarvingHanMode INSTANCE = new StarvingHanMode();

    private StarvingHanMode(){};

    public static StarvingHanMode getInstance(){return INSTANCE;}

    public static void main(String[] args) {
        StarvingHanMode m1 = StarvingHanMode.getInstance();
        StarvingHanMode m2 = StarvingHanMode.getInstance();
        System.out.println(m1 == m2);
    }
}

懒汉模式（用的时候看看存不存在，不存在再创建）

/**
 * @Author: 
 * @Date: 2022/08/16/21:33
 * @Description:lazy loading
 * 也称懒汉模式
 * 虽然达到了按需初始化到目的，但却带来线程不安全到问题
 * 可以通过synchronized解决，但也带来效率的下降
 **/
public class LazyHanMode {
    private static LazyHanMode INSTANCE;
    private LazyHanMode(){

    }
    public static LazyHanMode getInstance(){
        //此时没有实例化但是两个线程同时去判断 就会同时实例化多个LazyHanMoudle
        //虽然达到了按需初始化到目的，但却带来线程不安全到问题
        //可以通过synchronized解决，但也带来效率的下降
        if (INSTANCE == null){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new LazyHanMode();
        }
        return INSTANCE;
    }
    public void m(){
        System.out.println("M");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++){
            new Thread(()->
                    System.out.println(LazyHanMode.getInstance().hashCode())).start();
        }
    }
}

image-20220816220325829

可见根据不同的hash值说明创建了多个对象

增加synchronized可以解决这个问题

/**
 * @Author: 
 * @Date: 2022/08/16/21:33
 * @Description:lazy loading
 * 也称懒汉模式
 * 虽然达到了按需初始化到目的，但却带来线程不安全到问题
 * 可以通过synchronized解决，但也带来效率的下降
 **/
public class LazyHanMode1 {
    private static LazyHanMode1 INSTANCE;
    private LazyHanMode1(){

    }
    public static synchronized LazyHanMode1 getInstance(){
        //此时没有实例化但是两个线程同时去判断 就会同时实例化多个LazyHanMoudle
        //虽然达到了按需初始化到目的，但却带来线程不安全到问题
        //可以通过synchronized解决，但也带来效率的下降
        if (INSTANCE == null){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new LazyHanMode1();
        }
        return INSTANCE;
    }
    public void m(){
        System.out.println("M");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++){
            new Thread(()->
                    System.out.println(LazyHanMode1.getInstance().hashCode())).start();
        }
    }
}

image-20220816220804166

锁定了getInstance整个代码块有人会说这样锁定的代码太多了，可能影响业务的效率

就有提出了更细粒度的锁的方案

/**
 * @Author: 
 * @Date: 2022/08/16/21:33
 * @Description:lazy loading
 * 也称懒汉模式
 * 虽然达到了按需初始化到目的，但却带来线程不安全到问题
 * 可以通过synchronized解决，但也带来效率的下降
 **/
public class LazyHanModeWrong {
    private static LazyHanModeWrong INSTANCE;
    private LazyHanModeWrong(){

    }
    public static LazyHanModeWrong getInstance(){
        //此时没有实例化但是两个线程同时去判断 就会同时实例化多个LazyHanMoudle
        //虽然达到了按需初始化到目的，但却带来线程不安全到问题
        //可以通过synchronized解决，但也带来效率的下降
        if (INSTANCE == null){
            synchronized (LazyHanMode.class){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new LazyHanModeWrong();
            }
        }
        return INSTANCE;
    }
    public void m(){
        System.out.println("M");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++){
            new Thread(()->
                    System.out.println(LazyHanModeWrong.getInstance().hashCode())).start();
        }
    }
}

image-20220816223747037

只把实例化的代码锁住但是这样是错误的 也会线程不安全

原因：线程A判断完没有 INSTANCE 准备创建线程的时候，线程B同时也判断的话就会创建出多个INSTANCE

/**
 * @Author: 
 * 双重校验
 * @Date: 2022/08/16/21:33
 * @Description:lazy loading
 * 也称懒汉模式
 * 虽然达到了按需初始化到目的，但却带来线程不安全到问题
 * 可以通过synchronized解决，但也带来效率的下降
 **/
public class LazyHanModeWrongDoubleCheck {
    private static LazyHanModeWrongDoubleCheck INSTANCE;
    private LazyHanModeWrongDoubleCheck(){

    }
    public static LazyHanModeWrongDoubleCheck getInstance(){
        //此时没有实例化但是两个线程同时去判断 就会同时实例化多个LazyHanMoudle
        //虽然达到了按需初始化到目的，但却带来线程不安全到问题
        //可以通过synchronized解决，但也带来效率的下降
        if (INSTANCE == null){
            synchronized (LazyHanMode.class){
                if(INSTANCE == null){
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new LazyHanModeWrongDoubleCheck();
                }
                return INSTANCE;
            }
        }
        return INSTANCE;
    }
    public void m(){
        System.out.println("M");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++){
            new Thread(()->
                    System.out.println(LazyHanModeWrongDoubleCheck.getInstance().hashCode())).start();
        }
    }
}

双重校验就会解决准备实例化的时候已经被实例化过，在双重校验的前提下，100台机器10000个线程同时调用也不太可能出现问题

过程是线程A和线程B首先判断是否已经实例化，A尝试获得锁成功，B未能获得锁，自旋等待（锁升级）不会创建实例，线程A获得了锁，会实例化，实例化结束后让出锁，线程B自旋等待后获得锁，但是在开始实例化之前会再次检测是否已经实例化，这样就避免了重复实例化一个对象造成内存的浪费和系统性能的损耗，可见双重检查可以保证线程安全

但是INSTANCE是否需要加volatile

实际的压测过程中很难发现加volatile与不加volatile的区别，有些人因此就不加volatile，但是实际上是需要加的，原因和禁止指令重排序有关

new一个对象的时候分三步，1申请内存，2初始化成员变量 3 内存的内容赋值给INSTANCE

image-20220819003854491

如果没有volatile呢么就有可能申请完内存后没有初始化成员变量，直接把这块内存赋值给INSTANCE，会在极高并发的情况下产生问题，比如申请完内存后没有初始化成员变量，直接把这块内存赋值给INSTANCE，就会读到0

如果使用了volatile，保证了指令不可重拍讯，则不会出现上述的问题

volatile是否可以替代sync

不加volatile

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: 
 * @Date: 2022/08/22/23:06
 * @Description:
 **/
public class DifVolatileWithSync {
    int count = 0;
    void m(){
        for (int i = 0;i < 10000;i++)
            count++;
    }

    public static void main(String[] args) {
        DifVolatileWithSync difVolatileWithSync = new DifVolatileWithSync();
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 10;i++){
            threads.add(new Thread(difVolatileWithSync::m,"thread-" + i));
        }
        threads.forEach((o)->o.start());
        threads.forEach((o)->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(difVolatileWithSync.count);
    }
}

image-20220823000458958

可见结果不是10w

加volatile


import java.util.ArrayList;
import java.util.List;

/**
 * @Author: 
 * @Date: 2022/08/22/23:06
 * @Description:
 **/
public class DifVolatileWithSync {
    volatile int count = 0;
    void m(){
        for (int i = 0;i < 10000;i++)
            count++;
    }

    public static void main(String[] args) {
        DifVolatileWithSync difVolatileWithSync = new DifVolatileWithSync();
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 10;i++){
            threads.add(new Thread(difVolatileWithSync::m,"thread-" + i));
        }
        threads.forEach((o)->o.start());
        threads.forEach((o)->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(difVolatileWithSync.count);
    }
}

image-20220823000614605

可见还是没有达到预期

为什么最后的值不是10w，第一个线程吧count修改成1，这时候线程2和3都都看到count是1，于是都加了1，count都是2，写回内存，这样就已经少了一次，这是因为count++是满足原子性的，但是内部的指令有很多不一个

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: 
 * @Date: 2022/08/22/23:06
 * @Description:
 **/
public class DifVolatileWithSync {
    /*volatile*/ int count = 0;
    synchronized void m(){
        for (int i = 0;i < 10000;i++)
            count++;
    }

    public static void main(String[] args) {
        DifVolatileWithSync difVolatileWithSync = new DifVolatileWithSync();
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 10;i++){
            threads.add(new Thread(difVolatileWithSync::m,"thread-" + i));
        }
        threads.forEach((o)->o.start());
        threads.forEach((o)->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(difVolatileWithSync.count);
    }
}

image-20220823001553134

锁优化

细化锁

import java.util.concurrent.TimeUnit;

/**
 * @Author: 
 * @Date: 2022/08/23/20:57
 * @Description:同步代码块中语句越少越好
 **/
public class FineCoarseLock {
    int count = 0;
    synchronized void m1(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count ++;
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    void m2(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //不是锁住整个代码块，而是只锁住count++
        synchronized (this){
            count ++;
        }
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

粗力度锁

有很多锁，每行都有锁，不如用一个大的锁锁住，减少锁的获取

object被改变了

import java.util.concurrent.TimeUnit;

/**
 * @Author: 
 * @Date: 2022/08/23/22:38
 * @Description:
 **/
public class LockObjChange {
   final Object o = new Object();
    void m() {
        synchronized (o){
            while (true) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }
        }
    }

    public static void main(String[] args) {
        LockObjChange lockObjChange = new LockObjChange();
        new Thread(lockObjChange::m,"t1").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread thread = new Thread(lockObjChange::m, "t2");
        lockObjChange.o = new Object();
        thread.start();

    }

}

image-20220823230427826

import java.util.concurrent.TimeUnit;

/**
 * @Author: 
 * @Date: 2022/08/23/22:38
 * @Description:
 **/
public class LockObjChange {
   final Object o = new Object();
    void m() {
        synchronized (o){
            while (true) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }
        }
    }

    public static void main(String[] args) {
        LockObjChange lockObjChange = new LockObjChange();
        new Thread(lockObjChange::m,"t1").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread thread = new Thread(lockObjChange::m, "t2");
//        lockObjChange.o = new Object();
        thread.start();

    }

}

​ image-20220823231652135

加final，让o不能被改变

CAS

CASAtomicInteger

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author: 
 * @Date: 2022/08/24/20:40
 * @Description:
 **/
public class CASAtomicInteger {
    AtomicInteger count = new AtomicInteger(0);
    void m(){
        for (int i = 0;i<10000;i++){
            count.incrementAndGet();
        }
    }

    public static void main(String[] args) {
        CASAtomicInteger casAtomicInteger = new CASAtomicInteger();
        List<Thread> threads = new ArrayList<>();
        for (int i = 0;i<10;i++){
            threads.add(new Thread(casAtomicInteger::m,"thread-" + i));
        }
        threads.stream().forEach((o)->o.start());
        threads.stream().forEach((o)->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(casAtomicInteger.count);

    }
}

线程安全的自增类有jdk提供

image-20220825231348945

因为是cpu指令的操作，由cpu原语支持，所以在判断 V==E的时候不能插别的操作

ABA问题

简单说基础类型不影响，应用类型属性不变，内容已经改变

image-20220827164246260

image-20220827175256566

可见不影响基础类型，两次Thread读到的数据都是8，所以不影响他的操作

image-20220827175826445

如果是对象，对象的地址不变，但是内部引用的对象已经发生了改变

解决办法增加版本号

提升

image-20220827211859486

lfssst
关注
专栏目录
高并发模拟~多个线程同时发起请求
一只打杂的码农
07-09 5854
高并发模拟，多个线程同时发起请求 两种方案： CyclicBarrier：栅栏，所有的线程必须同时到达栅栏位置，才能继续执行。 CountDownLatch：计数器，一个线程或多个线程一直等待，直到其他线程执行的操作完成。 1、CyclicBarrier 适用在多线程相互等待，直到到达一个屏障点。并且CyclicBarrier是可重用的。 下面的列子，设置线程阻塞200个，但发起线程400个...
多线程&高并发
u013529468的博客
04-25 918
注：JDK1.6前：默认10次自旋，-XX:PreBlockSpin配置，或者超过CPU核数的一半，自动升级重量级锁。JDK1.6之后，自适应自旋（Adaptive Self Spinning），JVM自动调整；jdk早期版本中，synchronized的底层实现是重量级的，都是去找操作系统去申请锁的地步。偏向锁判断，该位置有标记，是偏向锁，升级到自旋锁，否则存下档前线程ID，执行对应代码块。轻量级锁判断，自旋尝试获取锁，尝试10次还未获取到，就升级重量级锁，否则执行对应代码块。
多线程高并发编程
qq_34505594的博客
09-04 163
1.countDownLatch 阻塞，countDown到零，结束阻塞继续执行。可以时一个线程countDown，可以是多个线程countDown public static void usingCountDownLatch(){ Thread[] threads = new Thread[100]; CountDownLatch latch = new CountDownLatch(threads.length); for (int i = 0;
多线程篇（ 并发编程 - 认识多线程）（持续更新迭代）
wlcass zhengge blog
08-27 945
认识多线程
编写高质量代码 - 多线程和并发（1）
及时当勉励，岁月不待人
12-10 577
编写高质量代码 - 多线程和并发（1）
使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】
九七的博客
03-28 1680
package com.gitee.taven.test; import com.gitee.taven.ApiResult; import com.gitee.taven.aop.RepeatSubmitAspect; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframew.
基于Java的多线程与高并发编程设计源码
最新发布
10-03
该项目是一款基于Java语言开发的多线程与高并发编程设计源码，包含71个文件，其中包括62个Java源代码文件、7个XML配置文件以及1个.gitignore文件。该设计源码全面展示了多线程和高并发编程的实践应用，适用于对并发...
多线程与高并发编程笔记、源码等
09-05
标题“多线程与高并发编程笔记、源码等”表明了资源的核心内容，涵盖了多线程和高并发编程的理论与实践。多线程允许一个应用程序同时执行多个任务，而高并发则指系统能够处理大量并发请求的能力。这两个概念在现代...
多线程与高并发-电子.pdf
05-03
多线程与高并发是计算机科学中非常重要的两个概念，它们在提高软件程序的性能、响应速度和资源利用率方面起着至关重要的作用。在当今的互联网时代，特别是在产业互联网和5G技术的推动下，多线程和高并发的应用变得...
C#多线程开发之并发编程经典实例.zip
10-13
在C#编程中，多线程是一个至关重要的概念，尤其对于开发高性能、高并发的应用程序而言。本资源“C#多线程开发之并发编程经典实例”提供了丰富的实例，旨在帮助C#开发者深入理解并掌握多线程技术。以下是关于C#多线程...
多线程与高并发实战手册.rar
03-20
综上所述，《多线程与高并发实战手册》是一本全面的指南，它将帮助开发者理解和掌握多线程编程和构建高并发系统的实践技巧。通过深入学习，我们可以提高软件的性能和用户体验，为复杂的企业级应用提供坚实的基础。
多线程 高并发
06-27
在开发过程中自己编写的多线程并发程序组件源代码共享给大家，里面有测试的例子，提供给大家学习，希望大家多提宝贵意见~
多线程并发测试代码及解决方法
dfsafsd32323的博客
04-04 188
1.解决方法 Executors.newSingleThreadExecutor()取得的Executor实例有以下特性:任务顺序执行.比如：executor.submit(task1);executor.submit(task2);必须等task1执行完，task2才能执行。task1和task2会被放入一个队列里，由一个工作线程来处理。即：一共有2个线程(主线程、处理任务的工作线...
Java-使用多线程模拟真实高并发业务并保证安全性（一）
weixin_42113716的博客
08-24 1280
Java-使用多线程模拟真实高并发业务并保证安全性
Thread 运行状态
weixin_34347651的博客
03-08 435
2019独角兽企业重金招聘Python工程师标准>>> ...
多线程高并发编程(1) -- 基础及详解
07-14 389
进程和线程的区别：进程的内存大小为：**堆内存+线程数量*栈内存，即线程数量 =（ 最大地址空间[MaxProcessMemory] - JVM堆内存 - 系统保留内存[ReservedOsMemory] ）/ ThreadStackSize(XSS)，**从中可以看出，线程的数量随栈内存的增多而减少。线程是程序执行的一个路径，每一个线程都有自己的局部变量表、程序计数器(指向正在执行的指令指针)以及各自的生命周期。当启动了一个Java虚拟机(JVM)时，从操作系统开始就会创建一个新的进程(JVM进程)，JV
Java多线程高并发编程代码笔记(二)
C.
01-05 552
文章目录ReentrantLock可以用来代替synchronizedReentrantLock可以进行尝试锁定tryLock()ReentrantLock的lockInterruptibly方法ReentrantLock可以指定为公平锁面试题使用wait和notifyAll方法来实现使用Lock和Condition来实现ThreadLocal线程局部变量参考源代码 ReentrantLock可以...
【java学习】多线程之高并发编程：线程&任务&启动任务
午后阳光
01-24 4245
1，synchronized（同步块）（1）概念用synchronized 关键字来实现同步块，所有加上synchronized 的块语句，在多线程访问的时候，同一时刻只能有一个线程能够访问，另一个线程必须等到当前线程访问完毕才能访问此代码块，解决了多线程的安全问题。即：加锁。（2）缺陷多个线程判断锁，耗费资源，降低代码执行效率。（3）作用①实现操作的原子性什么是原子性？原子操作即：不可分割的单一的...............
Java多线程与并发编程详解
"Java多线程与并发编程的深度总结" 在计算机科学中，多线程和并发编程是提升系统性能和效率的关键技术。Java语言提供了丰富的支持来处理多线程场景，使得开发者能够充分利用现代多核处理器的计算能力。 首先，多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值