003 - 并发与多线程处理及应用

正常情况下

异常情况下

“一个变量在同一时刻指允许一条线程对其进行 lock 操作”

这条规则决定了持有同一个锁的两个同步块只能串行的进入。

验证

准备

解析

上下文

寄存器

程序计数器

当前正在执行的任务完成， 系统的CPU正常调度下一个需要运行的线程

当前正在执行的任务遇到I/O等阻塞操作，线程调度器挂起此任务，继续调度下一个任务。

多个任务并发抢占锁资源，当前任务没有获得锁资源，被线程调度器挂起，继续调度下一个任务。

用户的代码挂起当前任务， 比如线程执行sleep方法， 让出CPU.

使用硬件中断的方式引起上下文切换

多个线程访问共享资源的同步方法

答案1：

分析1：在main主线程中启动A,B两个线程，故意让主线程休眠500毫秒目的是为了演示效果让A线程有足够的时间先启动；因为同步方法锁定的是res对象，所以A线程抢先获取了对象实例锁，执行了increase方法，decrease必须等待上一个锁释放之后才能执行，所以执行结果是先打印increase方法；

多个线程访问共享资源的静态同步方法

答案2：

分析2：静态同步方法的锁是当前对象，increase和decrease都是静态同步方法，所以当A线程启动后首先获取了Resource对象锁，decrease要执行也必须等待increase执行完释放资源后才能执行，即先打印increase方法，如上图所示；

多个线程访问共享资源的静态同步方法和非静态同步方法

答案3：

分析3：

非静态同步方法用的都是同一把锁，即对象实例;

静态同步方法，锁的是当前的Class对象;

上面的代码可以将decrease方法改成普通的方法，即不用synchrnoized修饰，看看会先打印哪个方法？

子主题

对于同步方法，JVM 采用ACC_SYNCHRONIZED 标记符来实现同步。

对于同步代码块，JVM 采用monitorenter、monitorexit 两个指令来实现同步。

如果有设置，则需要先获得监视器锁，

然后开始执行方法，方法执行之后再释放监视器锁。

这时，如果其他线程来请求执行方法，会因为无法获得监视器锁而被阻断住。

执行过程中，发生了异常

monitorenter 指令理解为加锁

monitorexit 理解为释放锁

未被锁定的对象的该计数器为0，

当一个线程获得锁（执行monitorenter）后，该计数器自增变为1 ，

当同一个线程再次获得该对象的锁的时候，计数器再次自增。

当同一个线程释放锁（执行monitorexit 指令）时，计数器再自减。

当计数器为0 时。锁将被释放，其他线程便可以获得锁。

如enter、exit、wait、notify、notifyAll 等

synchronized

原子性是指一个操作是不可中断的，要全部执行完成，要不就都不执行。

线程是CPU调度的基本单位。CPU 有时间片的概念，会根据不同的调度算法进行线程调度。

当一个线程获得时间片之后开始执行，在时间片耗尽之后，就会失去CPU 使用权。

所以在多线程场景下，由于时间片在线程间轮换，就会发生原子性问题。

monitorenter 

monitorexit

通过这两个字节码指令指令，可以保证被synchronized 修饰的代码在同一时间只能被一个线程访问，在锁未释放之前，无法被其他线程访问到。

保证了原子性

在Java 中，可以使用synchronized 来保证方法和代码块内的操作是原子性的。

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

Java 内存模型规定了所有的变量都存储在主内存中，

每条线程还有自己的工作内存，线程的工作内存中保存了该线程中是用到的变量的主内存副本拷贝，

线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存。

不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量的传递均需要自己的工作内存和主存之间进行数据同步进行。

所以，就可能出现线程1 改了某个变量的值，但是线程2 不可见的情况。

图解可见性

对一个变量解锁之前，必须先把此变量同步回主存中。

这样解锁后，后续线程就可以访问到被修改后的值。

synchronized 关键字锁住的对象，其值是具有可见性的。

即程序执行的顺序按照代码的先后顺序执行。

除了引入了时间片以外，

由于处理器优化和指令重排等，CPU 还可能对输入代码进行乱序执行，

这就是可能存在有序性问题。

比如：load->add->save 有可能被优化成load->save->add 。

如果在本线程内观察，所有操作都是天然有序的。

如果在一个线程中观察另一个线程，所有操作都是无序的。

和as-if-serial 语义有关

可见性是什么？

为什么产生可见性问题？

volatile 与可见性

其一是保证该变量对所有线程可见，这里的可见性

嗅探机制 强制失效

当被volatile修饰的变量进行写操作时，这个变量将会被直接写入共享内存，而非线程的专属存储空间。

volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。

根本原因是在写入后执行了一个空操作,使得cpu的cache写入内存

当读取一个被volatile修饰的变量时，会直接从共享内存中读，而非线程专属的存储空间中读。

有序性是什么？

为什么产生有序性问题？

volatile可以禁止指令重排优化

happens-before

as-if-serial

volatile 是不能保证原子性的。

什么是原子性？

为什么会发生原子性问题？

volatile 和原子性的例子

i++这种操作不能保证原子性

（i++的过程是读取i值，把i+1，再把i+1赋给i）。

这个过程中任何一步都可能会被其它线程改动

像i=1这种的就可以保证原子性

意味着在不同线程之间共享某些状态

比如一个或者多个对象，当线程要共享数据时，就会造成竞态条件或者死锁等问题。

当然，这些问题只是可能会出现，具体实现方式取决于你是否安全的使用和访问共享对象。

共享状态

独立的状态表明状态不会在多个线程之间共享

如果线程之间需要通信，可以访问不可变的对象来实现，这是最有效的避免并发问题的一种方式

使用独立状态让我们的设计更加简单，因为只有一个线程能够访问对象，即使交换对象，也是不可变的对象。

独立状态

代理人(Delegator)

工人(worker)

Delegator负责接收来自客户端的任务并把任务下发， 交给具体的Worker进行处理

Worker处理完成后把结果返回给Delegator， 

在Delegator接收到Worker处理的结果后对其进行汇总， 然后交给客户端。

实际的并行Worker要比我们图中画出的更复杂

图解

主要是并行Worker通常会访问内存或共享数据库中的某些共享数据。

这些共享状态可能会使用一些工作队列来保存等

在线程通信中， 线程需要确保共享状态是否能够让其他线程共享，

而不是仅仅停留在CPU缓存中，让自己可用 

多线程在访问共享数据时，会丢失并发性

因为操作系统要保证只有一个线程能够访问数据，这会导致共享数据的争用和抢占。

线程需要避免竞态条件，死锁和许多其他共享状态造成的并发问题。

现代的非阻塞并发算法

可持久化的数据结构

共享状态可以由其他线程所修改

 因此， worker必须在每次操作共享状态时重新读取， 以确保在副本上能够正确工作，

不在线程内部保持状态的worker成为无状态的worker

无法保证首先执行或最后执行哪些作业。

任务A在任务B之前分配给worker， 但是任务B可能在任务A之前执行。

例如，从网络中读取文件

非阻塞IO的流程图

根据完成的不同工作在不同的worker之间流动

任务还可能需要多个worker共同参与完成

一个并发模型

在Actor模型中， 每一个Actor其实就是一个Worker， 每一个Actor都能够处理任务。

它定义了一系列系统组件应该如何动作和交互的通用规则

著名的使用这套规则的编程语言是Erlang。

一个参与者Actor对接收到的消息做出响应， 然后可以创建出更多的Actor或发送更多的消息， 同时准备接收下一条消息。

图解Actor模型 

在Channel模型中， worker通常不会直接通信

与此相对的， 他们通常将事件发送到不同的通道(Channel) 上， 然后其他worker可以在这些通道上获取消息

有的时候worker不需要明确知道接下来的worker是谁

他们只需要将作者写入通道中， 监听Channel的worker可以订阅或者取消订阅， 这种方式降低了worker和worker之间的耦合性

Channel的模型图

因为流水线设计能够保证worker在处理完成后再传递给下一个worker，

 所以worker与worker之间不需要共享任何状态， 也就无需考虑并发问题。

甚至可以在实现上把每个worker看成是单线程的一种。 

因为worker知道没有其他线程修改自身的数据， 所以流水线设计中的worker是有状态的，

 有状态的意思是，可以将需要操作的数据保留在内存中，有状态通常比无状态更快。

因为你可以把流水线看成是单线程的，而单线程的工作优势在于，它能够和硬件的工作方式相同，

因为有状态的worker通常在CPU中缓存数据， 这样可以更快地访问缓存的数据。

可以对流水线井发模型中的任务进行排序，一般用来日志的写入和恢复。

任务会涉及多个worker， 因此可能会分散在项目代码的多个类中。

因此，很难确定每个worker都在执行哪个任务。

流水线的代码编写也比较困难， 

设计许多嵌套回调处理程序的代码通常被称为回调地狱， 回调地狱很难追踪debug.

使用函数调用来实现

消息的传递就相当于是函数的调用。

相当于是各个CPU单独执行各自的任务。

代码

 run方法内部就是线程要完成的任务

因此run方法也被称为执行体

上面代码中的子类是TJavaThread　

注意， 并不是直接调用run方法来启动线程， 而是使用start方法来启动线程。

当然run方法可以调用， 这样的话就会变成普通方法调用， 而不是新创建一个线程来调用了。　

只需要一个Runnable对象， 调用Thread对象的start方法为该线程执行必须的初始化操作，　

然后调用Runnable的run方法， 以便在这个线程中启动任务。

上面使用了线程的join方法， 它用来等待线程的执行结束，

 如果我们不加join方法， 它就不会等待tJavaThread的执行完毕，输出的结果可能就不是10088　

可以看到， 在run方法还没有结束前， run就被返回了

也就是说， 程序不会等到run方法执行完毕就会执行下面的指令。

代码1

代码2

在创建线程对象时必须向构造方法的参数传递一个实现Runnable接口类的实例，

该实例对象称作所创线程的目标对象，当线程调用start()方法后，一旦轮到它来享用CPU资源，目标对象就会自动调用接口中的run()方法。

run方法的方法体，同样是该线程的线程执行体。

可以使用上面代码这种简单的方式创建

也可以通过new出线程的实例来创建，如下所示

执行Callable任务后，可以获取一个Future的对象

future对象

futureTask

在该对象上调用get就可以获取到Callable任务返回的Object了，

有返回值

一般和ExecutorService配合来使用

再结合线程池接口ExecutorService，就可以实现传说中有返回结果的多线程了。

具体代码

有新任务时，根据当前线程池的线程数量，确定后续步骤

创建一个可重用固定线程数的线程池，

固定大小的线程池

使用有限的线程集来启动多线程

在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。

如果在所有线程处于活动状态时，提交附加任务，则在有可用线程之前，附加任务将在队列中等待。

如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。

在某个线程被显式地关闭之前，池中的线程将一直存在。

以共享的无界队列方式来运行这些线程。

可以一次性的预先执行高昂的线程分配， 因此可以限制线程的数量。

LinkedBlockingQueue(无界)

线程存活时间：永久存活

核心线程数：n(用户指定)

最大线程数：n(用户指定)

newFixedThreadPool实例

创建线程池的代码

这个线程池只有一个线程

线程数量为1的FixedThreadPool

创建单个线程的线程池

Executors.newSingleThreadExecutor()返回一个线程池

确保任意时刻都只有唯一一个任务在运行。

如果向SingleThreadPool一次性提交了多个任务，那么这些任务将会排队

SingleThreadPool会序列化所有提交给他的任务， 并会维护它自己(隐藏) 的悬挂队列

每个任务都会在下一个任务开始前结束，所有的任务都将使用相同的线程

该线程池可以在线程死后（或发生异常时）重新启动一个线程来替代原来的线程继续执行下去

LinkedBlockingQueue(无界)

线程存活时间：永久存活

核心线程数：1

最大线程数：1

newSingleThreadExecutor的实例

从输出的结果就可以看到，任务都是挨着执行的。

实例中，给任务分配了五个线程，但是这五个线程不像是之前看到的有换进换出的效果

它每次都会先执行完自己的那个线程，然后余下的线程继续走完这条线程的执行路径。

创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。

可以接受一个线程池对象， 创建一个根据需要创建新线程的线程池

调用 execute 将重用以前构造的线程（如果线程可用）。

当有新任务时，直接新建线程

如果现有线程没有可用的，则创建一个新线程并添加到池中。

为每个任务都创建一个线程

对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。

终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

因此，长时间保持空闲的线程池不会使用任何资源

SynchronousQueue

线程存活时间：60s

核心线程数：0

最大线程数：Interget.MAX_VALUE

在它们可用时，重用先前构造的线程， 并在需要时，使用提供的ThreadFactory创建新线程。

newCachedThreadPool的构造方法

CachedThreadPool的实例

Executors.newCachedThreadPool

DelayedWorkQueue

线程存活时间：永久存活

核心线程数：用户指定

最大线程数：Integer.MAX_VALUE

代码

Executor虽然不是传统线程创建的方式之一

但是它却成为了创建线程的替代者，从而简化了并发编程。

严格意义上讲，Executor并不是一个线程池，而只是一个执行线程的工具。

应用程序可以使用Executor框架来创建线程池

Java中的线程池是通过Executor框架实现的

Executor在客户端和任务之间提供了一个间接层； 

Executor允许你管理异步任务的执行， 而无须显示地管理线程的生命周期。

Java里面线程池的顶级接口是Executor

只有一个 void excute(Runnable task)方法，用户执行任务

使用如下操作来替换线程创建

只有一个方法就是创建线程的方法

ThreadFactory的基本使用

子主题

提供了一个更有用的简单实现

它在返回之前，将创建的线程上下文设置为已知值

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) { this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler); }

corePoolSize、maximumPoolSize、largestPoolSize 有意思

1. corePoolSize：

2. maximumPoolSize 

3. keepAliveTime：

4. unit：

5. workQueue

6. threadFactory：

7. handler

使用Hash表维护线程的引用

submit

既是一个可执行的任务，又可以达到锁的效果

1.worker未运行时

2.worker运行时

代码示例

定义了一个退出标志exit，当exit为true时，while循环退出，exit的默认值为false.

在定义exit时，使用了一个Java关键字volatile，这个关键字的目的是使exit同步，也就是说在同一时刻只能由一个线程来修改exit的值。

public static boolean interrupted()

public boolean isInterrupted()

public void interrupt()

InterruptedException

如使用了sleep,同步锁的wait,socket中的receiver,accept等方法时，会使线程处于阻塞状态。

当调用线程的interrupt()方法时，会抛出InterruptException异常。

阻塞中的那个方法抛出这个异常，通过代码捕获该异常，然后break跳出循环状态，从而让我们有机会结束这个线程的执行。

通常很多人认为只要调用interrupt方法线程就会结束，实际上是错的，

一定要先捕获InterruptedException异常，之后通过break来跳出循环，才能正常结束run方法。

使用isInterrupted()判断线程的中断标志来退出循环。

当使用interrupt()方法时，中断标志就会置true，和使用自定义的标志来控制循环是一样的道理。

代码讲解

不安全主要是：thread.stop()调用之后，创建子线程的线程就会抛出ThreadDeatherror的错误，并且会释放子线程所持有的所有锁。

一般任何进行加锁的代码块，都是为了保护数据的一致性，

如果在调用thread.stop()后导致了该线程所持有的所有锁的突然释放(不可控制)，那么被保护数据就有可能呈现不一致性

其他线程在使用这些被破坏的数据时，有可能导致一些很奇怪的应用程序错误。