JavaWeb 并发编程与高并发解决方案

最新推荐文章于 2024-05-18 10:46:38 发布

glamour2015

最新推荐文章于 2024-05-18 10:46:38 发布

阅读量910

点赞数

分类专栏： java并发编程

原文链接：https://blog.csdn.net/young_1004/article/details/82637264

版权

java并发编程专栏收录该内容

3 篇文章 1 订阅

订阅专栏

并发的概念

**并发：**同时拥有两个或多个线程，如果程序在单核处理器上运行，多个线程将交替地换入或者换出内存，这些线程是同时“存在”的，每个线程都处于执行过程中的某个状态，如果运行在多核处理器上，此时，程序中的每个线程都将分配到一个处理器上，因此可以同时运行。

**高并发：**高并发（High Concurrency）是互联网分布式系统架构设计中必须考虑的因素之一，它通常是指，通过保证系统能够并行处理很多请求。

并发和高并发的侧重点其实还是有一些细微的不同，在谈到并发时候，我们侧重于多个线程操作相同的资源，保证线程安全，合理利用资源。高并发是在系统运行的过程中短时间内遇到大量操作请求的情况，要求服务可以同时处理很多请求，提高程序性能。

知识技能

总体架构：SpringBoot、Maven、JDK8、MySQL

基础组件：Mybatis、 Guava、Lombok、Redis、Kafka

高级组件：Joda-Time、Atomic包、J.U.C、AQS、ThreadLocal、RateLimiter、Hystrix、threadPool、shardbatis、elastic-job...

并发编程的三大核心

并发编程旨在最大限度的利用计算机的资源，提高程序执行的性能，这需要线程之间的分工和同步来实现，在保证性能的同时，又需要保证线程的安全，这就又需要保证线程之间的互斥性。而并发编程的难点问题，往往又是由可见性、原子性和有序性问题导致的。所以，我们在学习并发编程时，一定要先弄懂线程之间的分工、同步和互斥。

在这里插入图片描述

并发的优势与风险

在这里插入图片描述

线程安全性

定义：当多个线程访问某个类的时候，不管运行环境采用何种调度方式或者这些进程如何交替执行，并且在主调代码中不需要采用额外的同步或者是协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的

原子性：提供了互斥访问，同一时刻只能有一个线程来对它进行操作。

Atomic包

Atomic:CAS、Unsafe.compareAndSwapInt

AtmomicLong、LongAdder

AtomicReference、AtomicReferenceFieldUpdater

AtomicStampReference:CAS的ABA问题



锁

Synchronized:依赖JVM

Lock:依赖特殊的CPU指令，代码实现，ReentrantLock



Synchronized

修饰代码块：大括号括起来的代码，作用于调用的对象。

修饰方法：整个方法，作用于调用的对象。

修饰静态方法：整个静态方法，作用于所有对象。

修饰类：括号括起来的部分，作用于所有对象。



对比

synchronized：不可中断锁，适合竞争不激烈，可读性好。

Lock：可中断锁，多样化同步，竞争激烈时候能够维持常态。

Atomic：竞争激烈时候可以维持常态，比Lock性能好；只能同步一个值。

可见性：可见性是指当一个线程修改了共享变量的值，其他线程可以立即得知这个修改。

导致共享变量在线程间不可见的原因

1)线程交叉执行。

2）重排序结合线程交叉执行。

3）共享变量更新后的值没有在工作内存与主内存间及时更新



synchronized

1)线程解锁前，必须把共享变量的最新值刷新到主内存。

2）线程加锁时，将清空工作内存中的值，从而使用共享变量时需要从主内存中重新读取最新的值（加锁解锁是同一把锁）。



volatile（通过加入内存屏障和禁止重排序优化实现）

1）对volatile变量写操作时，会在写操作后面加入一条store屏障指令，将本地内存中的共享变量刷新到主内存。

不可保障在多线程计算中修饰值的安全性，不过它可以作为 一个标识量。

有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序的存在，该观察结果一般都是杂乱无序。

java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

volatile、synchronized、Lock

先行发生原则

程序次序规律：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作。

锁定规则：一个unlock操作先行发生于后面对同一个锁的lock操作。

volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作。

传递规则：操作A先行发生于操作B，而操作B又先行发生于操作C、则可以得出A先行发生于C。

线程启动规则：Thread对象的start()方法先行发生于此线程的每一个动作。

线程中断规则：对线程interrupt()方法调用先行发生于被中断线程的代码检测到中断事件的发生。

线程终止规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()返回值手段检测线程已经终止执行。

对象终结规则：一个对象的初始化完成先行发生于它的finalize()方法的开始。

发布对象：使一个对象能够被当前范围之外的代码所使用。

对象逸出：一种错误的发布。当一个对象还没有构造完成时，就使用它被其他线程所见。

安全发布对象

在静态初始化函数中初始化一个对象引用。

将对象的引用保存到volatile类型域或者AtomicRefereence对象中。

将对象的引用保存到某个正确构造对象的final类型域中。

将对象的引用保存到一个由锁保护的域中。

不可变对象

对象创建以后其状态就不改变

对象所有域都是final类型

对象是正确创建的（在对象创建期间，this引用没有逸出）



final关键字：类、方法、变量

修饰类：不能被继承

修饰方法：1、锁定方法不能被继承类修改；2、效率

修饰变量：1、基本数据类型变量；2、引用类型（引用不可再引用，值还是可以变化）。

线程封闭

栈封闭：局部变量，无并发问题。

ThreadLocal线程封闭：特别好的封闭方法。

线程安全（并发容器 J.U.C）

在这里插入图片描述
ArrayList->CopyOnWriteArrayList(适合读多写少的场景、读写分离、读不加锁、写加锁)

HashSet、TreeSet->CopyOnWriteArraySet、ConcurrentSkipListSet

HashMap、TreeMap->ConcurrentHashMap、ConcurrentSkipListMap

AbstractQuenedSynchronizer-AQS(重中之重)

1）使用Node实现FIFO队列、可以用于构建锁或者其他同步装置的基础框架。

2）利用了一个int类型表示状态。

3）使用方法是继承。

4）子类通过继承实现它的方法管理其状态{acquire和release}的方法操纵状态。

5）可以同时实现排它锁和共享锁（独占、共享）

AQS实现的大致思路：

AQS内部维护了一个CLH队列来管理锁，线程会首先尝试获取锁，如果失败，会将当前线程以及等

待状态的信息包装成一个Node节点加入到同步队列，接着不断循环尝试获取锁，它的条件是当前节

点为head的直接后继，如果失败就会阻塞自己，直到自己被唤醒，当持有锁的线程释放锁的时候会

唤醒队列中的后继线程。

AQS同步组件

CountDownLatch(闭锁，通过一计数来保证线程是否需要一直阻塞)

Semaphore(可以控制线程并发数目)

CyclicBarrier

ReentrantLock(重点)

Condition

FutureTask

CountDownLath
CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信（而不是用作互斥的作用）。

CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计

数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减

 一。当计数器的值 为0时，表示所有的线程都已经完成了任务，然后在CountDownLatch上等待
 
 的线程就可以恢复执行任务。

应用场景
一个典型应用场景就是

1.启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。

2.实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程在某一  
时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开 跑。做法是初
始化一个共享的CountDownLatch(1)，将其计数器初始化为1，多个线程在开始执行任务前首先 
coundownlatch.await()，当主线程调用 countDown() 时，计数器变为0，多个线程同时被唤醒。

Semaphore

Semaphore是计数信号量。Semaphore管理一系列许可证。每个acquire方法阻塞，直到有一个许可证可以获得然后拿走一个许可证；每个release方法增加一个许可证，这可能会释放一个阻塞的acquire方法。然而，其实并没有实际的许可证这个对象，Semaphore只是维持了一个可获得许可证的数量。

Semaphore经常用于限制获取某种资源的线程数量。

CyclicBarrier

类似于CountDownLatch，不过可以循环。

CountDownLatch描述的是一个或n个线程需要等待其他线程完成某个操作之后才能往下执行；CyclicBarrier描述的是多个线程之间等待直到所有线程都满足条件后才可执行。

ReentrantLock 与锁

ReentrankLock(可重入锁)和synchronized 的区别

可重入性

锁的实现

性能区别

功能区别

ReentrantLock独有的功能

可以指定公平锁或是非公平锁。

提供了一个Condition类，可以分组唤醒需要唤醒的线程。

提供能够中断等待锁的线程的机制，Lock.lockInterruptibly()。

Condition

实现一个简单的有界队列，队列为空时，队列的删除操作将会阻塞直到队列中有新的元素，队列已 
满时，队列的插入操作将会阻塞直到队列出现空位。

FutureTask

比较各种线程实现

package thread;

import java.util.concurrent.*;

public class Thread1{
    public static void main(String[] args) {
        System.out.print(Thread.currentThread().getName());
       // ===========继承thread
        ThreadDemo threadDemo1 = new ThreadDemo();
        threadDemo1.start();
        //================实现runable接口
        Threademo2 threademo2 = new Threademo2();
        Thread thread = new Thread(threademo2);
        thread.start();
        thread.run();
        //==================实现runable接口
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {

            }
        });
        thread1.start();
        //===============callable线程返回值
        FutureTask<String> futureTask = new FutureTask<String>(new Threaddemo3());
        Thread thread2 = new Thread(futureTask);
        thread2.start();
        //================线程池实现
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new Thread(new Threademo2()));
        Future<String> future = executorService.submit(new Threaddemo3());
        try {
           System.out.println("fu = [" + future.get() + "]");
        }catch (Exception e){
        }finally {
            executorService.shutdown();
        }
    }
}

class ThreadDemo extends Thread {
    @Override
    public void run(){
        for (int i = 0;i<10;i++){
            System.out.print(Thread.currentThread().getName());

        }
    }
}
class Threademo2 implements Runnable{
    @Override
    public void run(){
        System.out.print(Thread.currentThread().getName());
    }

}
class Threaddemo3 implements Callable<String> {
    @Override
    public String call(){
        System.out.print(Thread.currentThread().getName());
        return "a";
    }

}

BlockingQueue(阻塞队列)

在这里插入图片描述
实现类

ArrayBlockingQueue(有界的阻塞队列，数据结构数组)

DelayQueue

LinkedBlockingQueue(数据结构链表)

PriorityBlockingQueue(无界)

SynchronousQueue(同步只能放一个元素)

线程池

new Thread 弊端

每次new Thread 新建对象，性能差。

线程缺乏统一管理，可能无限制的新建线程，相互竞争，有可能占用过多系统资源导致死机或OOM。

缺少更多功能，如更多执行定期执行，线程中断。

线程池的好处

重用存在的线程，减少对象的创建，消亡的开销，性能佳。

可有效控制最大并发线程数，提高系统资源利用率，同时可以避免过多资源竞争，避免阻塞。

提供定时执行，定期执行，单线程，并发数控制等功能。

ThreadPoolExecutor

corePoolSize：核心线程数
maximumPoolSize：线程最大线程数
workQueue：阻塞队列，存储等待执行的任务，很重要，会对线程池运行过程产生重大影响
（任务提交时可以分三种情况：1、当任务提交时线程数小于corePoolSize不管有没有空闲线程直接 
新建线程；2、如果线程数量大于等于corePoolSize且小于maximumPoolSize则只有当workQueue
满的时候新建线程去处理任务；3、若corePoolSize和maximumPoolSize设置大小一样时，说明线程
池大小固定，有新任务时看workQueue中任务是否有空余，若有：放任务进去，若没有且线程数大
于maximumPoolSize则通过一个叫做“拒绝策略的参数”指定策略去处理任务。）
keepAliveTime：线程没有任务执行时最多保持多久时间终止
（当线程池中的数量大于corePoolSize时，如果没有新的任务提交，核心线程不会立即销毁，会等待一段时间。）
util：keepAliveTime 的时间单位
threadFactory：线程工厂，用来创建线程
rejectHandler：当拒绝任务时的策略
（直接抛出异常、用调用者所在的线程执行任务、丢弃队列最靠前的任务并执行当前任务、直接丢
弃这个任务）

看完了这几个参数之后我们再来看看下面的几个方法：

execute()：提交任务，交给线程池执行

submit()：提交任务，能够返回结果 execute+Future

shutdown()：关闭线程池，等待任务都执行完

shutdownNow：关闭线程池，不等待任务执行完

getTaskCount()：线程池已执行和未执行的任务总数

getCompletedTaskCount()：已完成的任务数量

getPoolSize()：线程池当前线程数量

getActiveCount()：当前线程池中正在执行任务的线程总数

在这里插入图片描述
Executor框架接口

Executors.newCachedThreadPool(可缓存线程池)

Executors.newFixedThreadPool(定长线程池)

Executors.newScheduledThreadPool(定长线程池，支持定时周期执行)        

Executors.newSingleThreadExcutor(单线程线程池)

线程池-合理配置

CPU密集型任务，就需要尽量压榨CPU，参考值可以设为NCPU+1

IO密集型任务，参考值可以设为2*NCPU

死锁

两个或两个以上进程在执行任务的时候由于争夺资源等待资源而发生互相等待的状态。

四个必要条件

互斥条件（进程对锁分配的资源排他性的使用，即在一段时间内某资源只由一个进程占用，如果还有其他进程想要获得资源只能等待）

请求和保持条件（进程已经保持了至少一个资源但还申请了新的资源请求，而该资源已被其他进程占有，此时请求进程阻塞，但又对自己保持资源保持不放）

不剥夺条件（进程占用的资源在未使用完之前不可被剥夺，自己使用完之后释放）

环路等待条件（发生死锁时一定有进程存在资源环形的链）

如何避免死锁

1）线程按顺序加锁时候注意顺序

2）加锁实现

3）死锁检测

以上并发编程的部分我们已经学到了不少的知识，接下来我们聊聊多线程并发在实践中采用哪些方式较好

1）使用本地变量

2）使用不可变类

3）最小化锁的作用域范围：S=1/(1-a+a/n) a:并行处理所占的比例；n:并行节点的个数；S:加速比

4）使用线程池的Executor,而不是直接 new Thread 操作

5）宁可使用同步也不要使用线程的wait和notify

6）使用BlockingQueue实现生产-消费模式

7）使用同步集合而不是加了锁的同步集合

8）使用Semaphore创建有界的访问

9）宁可使用同步代码块也不使用同步方法

10）避免使用静态变量

在这里插入图片描述

高并发的解决方案

扩容
垂直扩容（纵向扩展）：提高系统部件能力
水平扩容（横向扩容）：增加更多系统成员来实现（集群）
扩容-数据库
读操作扩展：memcache、redis、CDN等缓存
写操作扩展：Cassandra、Hbase等
缓存特征
命中率：命中数/（命中数+没有命中数）
最大元素（空间）
清空策略：FIFO（先进先出）、LFU（最少使用）、LRU（最近最少使用）、过期时间、随机等
缓存命中率的影响因素
业务场景和业务需求
缓存的设计（粒度和策略）
缓存容量和基础设施
缓存分类和应用场景
本地缓存：编程实现（成员变量、局部变量、静态变量）Guava Cache
分布式缓存：Memcache、Redis
高并发场景下缓存常见问题
缓存一致性
在这里插入图片描述
缓存并发问题（热点key失效，高并发操作）

在这里插入图片描述
缓存穿透问题（布隆过滤器，过滤没有的值，恶意攻击）

缓存的雪崩现象

在这里插入图片描述
消息队列

在这里插入图片描述
消息队列的特性
业务无关：只做消息分发

FIFO：先投递先到达

容灾：节点的动态增删和消息的持久化

性能：吞吐量提升、系统内部通信效率提高

为什么需要消息队列

【生产】和【消费】的速度或稳定性等因素不一致

消息队列的好处

业务解耦

最终一致性

广播

错峰有流控

Kafka

在这里插入图片描述
应用拆分-原则

业务优先

循序渐进

兼顾技术：重构、分层

可靠测试

应用拆分-思考

应用之间通信：RPC(dubbo等)、消息队列

应用之间数据库设计：每个应用都有独立的数据库

避免事务操作跨应用

Dubbo

在这里插入图片描述
微服务

在这里插入图片描述
应用限流

在这里插入图片描述
应用限流-算法
计数器法

在这里插入图片描述
滑动窗口

在这里插入图片描述
漏捅算法

在这里插入图片描述
令牌通算法

在这里插入图片描述
数据库切库、分库、分表
数据库瓶颈

单个库数据量太大（1T-2T）：多个库

单个数据库服务器压力过大、读写瓶颈：多个库

单个表数据量过大：分表

高可用的一些手段

在这里插入图片描述

glamour2015

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
JavaWeb 并发编程与高并发解决方案

并发的概念**并发：**同时拥有两个或多个线程，如果程序在单核处理器上运行，多个线程将交替地换入或者换出内存，这些线程是同时“存在”的，每个线程都处于执行过程中的某个状态，如果运行在多核处理器上，此时，程序中的每个线程都将分配到一个处理器上，因此可以同时运行。**高并发：**高并发（High Concurrency）是互联网分布式系统架构设计中必须考虑的因素之一，它通常是指，通过保证系统能够并...
复制链接

扫一扫