多线程并发内容开发经验分享

关键字synchronized取得的锁都是对象锁，而不是把一段代码或者方法当作锁

如果是两个对象，线程获得的就是两个不同的锁，互不影响

如果在静态方法上加synchronized，表示锁定.class类，那么该类不同对象获得的则是相同的锁

修饰代码块：作用于调用的对象

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

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

修饰类：作用于所有对象

锁this

非this

静态同步synchronized方法和synchronized(class)代码块都是锁对应的Class类

String常量池

同步（synchronized）：同步的概念就是共享，如果不是共享段资源，就没有必要同步

异步（asynchronized）：异步的概念是独立，相互之间不受任何制约

如果A线程先持有object对象的LOCK锁，B线程在此时调用该对象中的同步方法则需要等待，即同步

如果A线程先持有object对象的LOCK锁，B线程在此时调用该对象中的异步方法即非synchronized方法修饰时，则无需等待

在对一个对象的方法加锁时，要考虑业务的一致性，比如 get/set方法同时加锁，保证数据的原子性，不然会出现业务错误

当一个线程得到了一个对象锁后，再次请求此对象时是可以再次或者该对象的锁

一个实体里面有多个方法加锁，且一个方法调其他的方式时，锁可以重入，方法仍可以继续进行，如果子类和父类方法均有加锁那么，这也是线程安全的

synchronized是公平锁

web应用中，异常释放锁的情况，如果不及时处理，很可能对业务逻辑产生严重错误，比如现在执行一个队列任务，很多对象都在等待第一个对象正确执行完毕再去释放锁，单第一个对象由于异常的出现，导致业务逻辑没有执行完毕，就释放了锁，那么后续对象执行的都是错误的。

不要对String 常量进行加锁 会出现死循环

执行时间方面：比如当A线程执行需要很长时间时，那么B线程就必须要等待很长时间才能执行。此时可以使用synchronized代码块去优化执行时间，也就是减少锁的粒度

锁对象的改变问题。当使用一个对象进行加锁，如果对象本身发生变化，那么持有的锁就不同。如果对象本身不发生变化，那么依然是同步的，即使对象的属性发生了变化

死锁

其他解决方法，在该变量上加锁，别的线程在修改该变量时，其他线程在此等候

保证主内存与线程内存中变量值的一致性

程序.png

程序内存图.png

修饰的值不适合参与运算

在java中每一个线程都会有一块工作内存区，存放着所有线程共享的主内存中的变量值的拷贝。当线程执行时，他在自己的工作内存中操作这些变量。为了存取一个共享的变量，一个线程通常先获取锁定并去清除他的工作内存区，当线程解锁时保证该工作内存区中变量的值写回到共享内存中

volatile 会强制线程到主内存中读取变量

线程的执行操作有：使用（use）,赋值（assign），装载（load），存储（store），锁定（lock）,解锁（unlock）

住内存的执行操作有：读（read），写（write），锁定（lock），解锁（unlock），每个操作都是原子的

atomic多次操作实例.png

在需要进行同步的代码上加入锁，但最后一定要记得释放

Condition

代码

api

公平锁和非公平锁

使用场景

核心为 实现读写分离的锁

在高并发访问下，尤其是读多写少的情况下，性能要远高于重入锁

UseReentrantReadWriteLock.java

读读共享 写写互斥 读写互斥

释放当前线程的cpu占用

thread线程加入到当前线程中，知道thread线程执行完，当前线程才执行

子主题 1

join在内部使用wait方法进行等待

synchronized使用对象监视器原理做同步

饥饿模式

懒汉模式

DubbleSingleton.java

static inner class

双重判断方式

基本原理

Segment（桶）

注意事项

原理：当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

常用：CopyOnWriteArrayList和CopyOnWriteArraySet

应用场景

使用注意

缺点

ConcurrentLinkedQueue

BlockingQueue接口

Executors--提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口

自定义线程池

生命周期

Submit()和execute的区别

并发编程.4（四）.ppt

并行执行任务框架，可以分隔任务汇总结果

类

是并发执行的程序在执行过程中分配和管理资源的基本单位，是一个动态概念，竟争计算机系统资源的基本单位。每一个进程都有一个自己的地址空间，即进程空间或（虚空间）。进程空间的大小 只与处理机的位数有关，一个 16 位长处理机的进程空间大小为 216 ，而 32 位处理机的进程空间大小为 232 。

进程至少有 5 种基本状态，它们是：初始态，执行态，等待状态，就绪状态，终止状态。

单机系统中进程通信有 4 种形式：主从式，会话式，消息或邮箱机制，共享存储区方式。

主从式典型例子：终端控制进程和终端进程。

会话式典型例子：用户进程与磁盘管理进程之间的通信。

在网络或多用户环境下，一个服务器通常需要接收大量且不确定数量用户的并发请求，为每一个请求都创建一个进程显然是行不通的，——无论是从系统资源开销方面或是响应用户请求的效率方面来看。因此，操作系统中线程的概念便被引进了。线程，是进程的一部分，一个没有线程的进程可以被看作是单线程的。线程有时又被称为轻权进程或轻量级进程，也是 CPU 调度的一个基本单位。

线程可以有效地提高系统的执行效率，但并不是在所有计算机系统中都是适用的，如某些很少做进程调度和切换的实时系统。使用线程的好处是有多个任务需要处理机处理时，减少处理机的切换时间；而且，线程的创建和结束所需要的系统开销也比进程的创建和结束要小得多。最适用使用线程的系统是多处理机系统和网络系统或分布式系统。

线程的执行特性。

线程只有 3 个基本状态：就绪，执行，阻塞。

线程存在 5 种基本操作来切换线程的状态：派生，阻塞，激活，调度，结束。

进程的执行过程是线状的，尽管中间会发生中断或暂停，但该进程所拥有的资源只为该线状执行过程服务。一旦发生进程上下文切换，这些资源都是要被保护起来的。这是进程宏观上的执行过程。而进程又可有单线程进程与多线程进程两种。进程有 一个进程控制块 PCB ，相关程序段 和 该程序段对其进行操作的数据结构集 这三部分，单线程进程的执行过程在宏观上是线性的，微观上也只有单一的执行过程；而多线程进程在宏观上的执行过程同样为线性的，但微观上却可以有多个执行操作（线程），如不同代码片段以及相关的数据结构集。线程的改变只代表了 CPU 执行过程的改变，而没有发生进程所拥有的资源变化。出了 CPU 之外，计算机内的软硬件资源的分配与线程无关，线程只能共享它所属进程的资源。与进程控制表和 PCB 相似，每个线程也有自己的线程控制表 TCB ，而这个 TCB 中所保存的线程状态信息则要比 PCB 表少得多，这些信息主要是相关指针用堆栈（系统栈和用户栈），寄存器中的状态数据。进程拥有一个完整的虚拟地址空间，不依赖于线程而独立存在；反之，线程是进程的一部分，没有自己的地址空间，与进程内的其他线程一起共享分配给该进程的所有资源。

初始化时规定一个数目，然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时，所有进入等待状态的线程被唤醒并继续

CyclicBarrier就象它名字的意思一样，可看成是个障碍， 所有的线程必须到齐后才能一起通过这个障碍

CyclicBarrier初始时还可带一个Runnable的参数， 此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行

UseCyclicBarrier.java

用于监听某些初始化操作，等其初始化完成后通知主线程操作

类似 wait/notify 功能 但 countdownlacth是实时的 而wait/notify 则必须等notify线程释放锁后才可以

UseCountDownLatch.java

实现Future模式

funture.get();获取Future的执行结果 可以设置超时时间

UseFuture.java

相关概念

TimerTask任务为顺序执行，如果一个任务执行时间较长则其他的会延迟执行

cancel() 将自身从任务中清除

在指定日期后，按指定的间隔周期性的循环执行

当前时间后，按指定的毫秒数后执行任务

atomic类

synchronized

lock

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

synchronized

volatile

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

happends-before

1. ABA问题。因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A。从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

2. 循环时间长开销大。自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。如果JVM能支持处理器提供的pause指令那么效率会有一定的提升，pause指令有两个作用，第一它可以延迟流水线执行指令（de-pipeline）,使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突（memory order violation）而引起CPU流水线被清空（CPU pipeline flush），从而提高CPU的执行效率。

3. 只能保证一个共享变量的原子操作。当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁，或者有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量i＝2,j=a，合并一下ij=2a，然后用CAS来操作ij。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行CAS操作。

2、比较花费CPU资源，即使没有任何争用也会做一些无用功。

3、会增加程序测试的复杂度，稍不注意就会出现问题。

客户端发送一个长时间的请求，服务端不需等待该数据处理完成便立即返回一个伪造的代理数据（相当于商品订单，不是商品本身），用户也无需等待，先去执行其他的若干操作后，再去调用服务器已经完成组装的真实数据。该模型充分利用了等待的时间片段

Future模型图.png

Main：启动系统，调用Client发出请求；
 Client：返回Data对象，理解返回FutureData，并开启ClientThread线程装配RealData；
 Data：返回数据的接口；
 FutureData：Future数据，构造很快，但是是一个虚拟的数据，需要装配RealData；
 RealData：真实数据，构造比较慢

future核心结构.png

FutureData是对RealData的包装，是dui真实数据的一个代理，封装了获取真实数据的等待过程。它们都实现了共同的接口，所以，针对客户端程序组是没有区别的；

客户端在调用的方法中，单独启用一个线程来完成真实数据的组织，这对调用客户端的main函数式封闭的；

因为咋FutureData中的notifyAll和wait函数，主程序会等待组装完成后再会继续主进程，也就是如果没有组装完成，main函数会一直等待。