Java并发编程
Java并发编程
首先来回顾线程的基本内容
程序: 静态代码 安装在硬盘上的
进程: 运行中的程序 是操作系统分配内存空间的单位
线程: 线程是进程中的一个最小执行单位, 是cpu调度单位 线程依赖于进程
创建线程
-
线程类 继承 Thread
-
类 实现 Runnable接口 重写 run( )
创建Thread类的对象,为其分配任务 -
类 实现 Callable接口 重写 call( ) 有返回值 可以抛出异常
创建Thread类的对象,为其分配任务
常用方法
run() calll() start()
设置名字
设置优先级
线程状态
- start() 就绪状态
- join() sleep() 阻塞状态
- yield() 线程让步 运行状态 主动让出 —>就绪状态
多线程
-
程序中如果同时有多个任务执行,需要多线程
-
多线程可以提高程序运行效率
-
提高cpu利用率
不足:
-
对cpu 内存的要求增加了
-
多线程同时访问同一个共享资源
线程安全问题:
多线程 且 多个线程访问同一个共享数据.
解决办法 排队+锁
Synchronized 关键字 修饰方法 修饰一个代码块 是隐式锁 自动加锁 自动释放锁
ReentrantLock
只能对某段代码加锁 是显示锁 手动添加 手动释放
sleep() 休眠指定的时间 时间到了后,会进入到就绪状态 不会释放锁
wait() 让线程等待 必须需要通过notify()唤醒 等待时会释放锁
生产者 消费者问题
让我们来了解一下并发编程是什么?
并发: 是在某一个时间段内 依次做好几件事情 一个一个的做 多个线程访问同一个资源
单核cpu不会出现问题
硬件cpu的功能逐渐强大, 已经发展到多内核( 4 8 12) 可以同时执行多个线程 这样就有可能多个线程同时执行,同时访问同一个共享数据 . 秒杀 抢购…
并发编程就是要让在多核,多线程情况下,也只能一次只有一个线程对共享数据进行访问.
我们线程已经可以通过加锁的方式实现, 但是加锁并不是唯一的解决方案,还有其他方式来实现.
本篇章我们要学习 并发问题如何产生,如何解决, 学习新的方式解决, 以及加锁内部的原理问题.
多核cpu可以做到真正的并行执行,但是我们在某种场景 就是要让程序并发执行.
并行与并发
单核CPU下，线程实际是串行执行的。操作系统中有一个组件叫做任务调度器，将CPU的时间片分给不同的线程使用，只是由于CPU在线程间（时间片很短）的切换非常快，人类感觉是同时运行的。
总结一句话就是：微观串行，宏观并行，一般会将这种线程轮流使用CPU的做法称为并发，concurrent。
多核CPU下，每个核（core）都可以调度运行线程，这时候线程可以是并行的。
大家排队在一个咖啡机上接咖啡，交替执行，是并发；两台咖啡机上接咖啡，是并行。
从严格意义上来说，并行的多任务是真的同时执行，而对于并发来说，这个过程只是交替的，一会执行任务A，一会执行任务B，系统会不停的在两者之间切换。
并发说的是在一个时间段内，多件事在这个时间段内交替执行。
并行说的是多件事在同一个时刻同时发生。
多线程
Java是最先支持多线程的开发的语言之一，Java从一开始就支持了多线程能力。由于现在的CPU已经多是多核处理器了，是可以同时执行多个线程的。
多线程优点
多线程技术使程序的响应速度更快，可以在进行其他工作的同时一直处于活动状态，程序性能得到提升。
性能提升的本质就是榨取硬件的剩余价值（硬件利用率）。
多线程问题
那么多线程会带来什么问题呢？
安全性（访问共享变量），性能（切换开销等）
Java内存模型（JMM）
问题
硬件的发展中，一直存在一个矛盾，CPU、内存、I/O设备的速度差异。
速度排序：CPU–>内存–>I/O设备
为了平衡这三者的速度差异，做了如下优化：
- CPU增加了缓存，以均衡内存与CPU的速度差异；
- 操作系统以线程分时复用CPU，进而均衡I/O设备与CPU的速度差异；
- 编译程序优化指令执行次序，使得缓存能够得到更加合理的利用。
JMM
Java内存模型（Java Memory Model，JMM）规范了Java虚拟机与计算机内存是如何协同工作的。Java虚拟机是一个完整的计算机的一个模型，因此这个模型自然也包含一个内存模型——又称为Java内存模型。
Java内存模型， 用于屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的并发效果，JMM规范了Java虚拟机与计算机内存是如何协同工作，规定了一个线程如何以及何时可以看到由其他线 程修改过后的共享变量的值，以及在必须时如何同步的访问共享变量。
计算机在高速的 CPU 和相对低速的存储设备之间使用高速缓存，作为内存 和处理器之间的缓冲。将运算需要使用到的数据复制到缓存中，让运算能快速运 行，当运算结束后再从缓存同步回内存之中。
在多处理器的系统中(或者单处理器多核的系统)，每个处理器内核都有自己 的高速缓存，它们有共享同一主内存(Main Memory)。
当多个处理器的运算任务都涉及同一块主内存区域时，将可能导致各自的缓 存数据不一致。
JVM主内存与工作内存
Java 内存模型的主要目标是定义程序中各个变量的访问规则，即在虚拟机 中将变量（线程共享的变量）存储到内存和从内存中取出变量这样底层细节。
Java 内存模型中规定了所有的变量都存储在主内存中，每条线程还有自己的工 作内存，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内 存中的变量。
这里的工作内存是 JMM 的一个抽象概念，也叫本地内存，其存储了该线程以 读 / 写共享变量的副本。
就像每个处理器内核拥有私有的高速缓存，JMM 中每个线程拥有私有的本地内存。
不同线程之间无法直接访问对方工作内存中的变量，线程间的通信一般有两种方 式进行，一是通过消息传递，二是共享内存。Java 线程间的通信采用的是共享 内存方式，线程、主内存和工作内存的交互关系如下图所示：
这里所讲的主内存、工作内存与 Java 内存区域中的 Java 堆、栈、方法区 等并不是同一个层次的内存划分，这两者基本上是没有关系的，如果两者一定要 勉强对应起来，那从变量、主内存、工作内存的定义来看，主内存主要对应于 Java 堆中的对象实例数据部分，而工作内存则对应于虚拟机栈中的部分区域。
并发编程核心问题–可见性,原子性,有序性
可见性
一个线程对共享变量的修改，另外一个线程能够立刻看到，我们称为可见性。
对于如今的多核处理器，每颗 CPU 都有自己的缓存，而缓存仅仅对它所在 的处理器可见，CPU 缓存与内存的数据不容易保证一致。
为了避免处理器停顿下来等待向内存写入数据而产生的延迟，处理器使用写 缓冲区来临时保存向内存写入的数据。写缓冲区合并对同一内存地址的多次写， 并以批处理的方式刷新，也就是说写缓冲区不会即时将数据刷新到主内存中。
缓存不能及时刷新导致了可见性问题。
举例：假设线程 1 和线程 2 同时开始执行，那么第一次都会将 a=0 读到各自的 CPU 缓存里，线程 1 执行 a++之后 a=1，但是此时线程 2 是看不到线程 1 中 a 的值的，所以线程 2 里 a=0，执行 a++后 a=1。
线程 1 和线程 2 各自 CPU 缓存里的值都是 1，之后线程 1 和线程 2 都会将 自己缓存中的 a=1 写入内存，导致内存中 a=1，而不是我们期望的 2。
原子性
线程切换带来的原子性问题
原子的意思代表着——“不可分”；
一个或多个操作在CPU执行的过程中不被中断的特性，我们称为原子性。
原子性是拒绝多线程交叉操作的，不论是多核还是单核，具有原子性的量，同一时刻只能有一个线程来对他进行操作。
CPU 能保证的原子操作是 CPU 指令级别的，而不是高级语言的操作符。线程 切换导致了原子性问题
Java 并发程序都是基于多线程的，自然也会涉及到任务切换，任务切换的 时机大多数是在时间片结束的时候。我们现在基本都使用高级语言编程，高级语 言里一条语句往往需要多条 CPU 指令完成。如 count++，至少需要三条 CPU 指令。
- 指令 1：首先，需要把变量 count 从内存加载到工作内存；
- 指令 2：之后，在工作内存执行 +1 操作；
- 指令 3：最后，将结果写入内存;
还是以上面的 count++ 为例。两个线程 A 和 B 同时执行 count++， 即便 count 使用 volatile 修辞，我们预期的结果值是 2，但实际可能是 1。
有序性
有序性指的是程序按照代码的先后顺序执行。 编译器为了优化性能，有时候会改变程序中语句的先后顺序。
例子：
init(); 与 inited = true; 并没有数据的依赖，在单线程看来，如果把两句的代 码调换好像也不会出现问题。
但此时处于一个多线程的环境，而处理器真的把这两句代码重新排序，那问题就 出现了，若线程 1 先执行 inited = true; 此时，init() 并没有执行，线程 2 就 已经开始调用 work() 方法，此时很可能造成一些奔溃或其他问题的出现。
Java 内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不 会影响到单线程程序的执行，却会影响到多线程并发执行的正确性.
总结：
缓存导致的可见性问题，线程切换带来的原子性问题，编译优化带来的**有序 性问题。**其实缓存、线程、编译优化的目的和我们写并发程序的目的是相同的， 都是提高程序安全性和性能。但是技术在解决一个问题的同时，必然会带来另外 一个问题，所以在采用一项技术的同时，一定要清楚它带来的问题是什么，以及如何规避。
volatile 关键字
一旦一个共享变量（类的成员变量、类的静态成员变量）被 volatile 修饰之后：
- 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变 量的值，这新值对其他线程来说是立即可见的。
- 禁止进行指令重排序。
- volatile 不能保证对变量操作的原子性。
public class ThreadDemo implements Runnable{
/*
volatile 修饰的变量,在一个线程中被修改后,对其它线程立即可见
禁止cpu对指令重排序
*/
private volatile boolean flag = false;//共享数据
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.flag = true;//让一个线程修改共享变量值
System.out.println(this.flag);
}
public boolean getFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
测试：
public class TestVolatile {
public static void main(String[] args) {
ThreadDemo td = new ThreadDemo();
Thread t = new Thread(td);//创建线程
t.start();
//main线程中也需要使用flag变量
while(true){
if(td.getFlag()){
System.out.println("main---------------");
break;
}
}
}
}
如何保证原子性？
“同一时刻只有一个线程执行”我们称之为互斥。如果我们能够保证对共享 变量的修改是互斥的那么就都能保证原子性了。
锁
锁是一种通用的技术方案，Java 语言提供的 synchronized 关键字，就是锁的一种实现。
synchronized 是独占锁/排他锁（就是有你没我的意思），但是注意！ synchronized 并不能改变 CPU 时间片切换的特点，只是当其他线程要访问这个 资源时，发现锁还未释放，所以只能在外面等待。
synchronized 一定能保证原子性，因为被 synchronized 修饰某段代码 后，无论是单核 CPU 还是多核 CPU，只有一个线程能够执行该代码，所以一 定能保证原子操作。
synchronized 也能够保证可见性和有序性。
JUC–原子变量
现在我们已经知道互斥锁可以保证原子性，也知道了如何使用 synchronized 来保证原子性。但 synchronized 并不是 JAVA 中唯一能保证原 子性的方案。
如果你粗略的看一下 J.U.C(java.util.concurrent 包)，那么你可以很显眼的 发现它俩：
一个是 locks 包，一个是 atomic 包,它们可以解决原子性问题。
- 加锁是一种阻塞式方式实现
- 原子变量是非阻塞式方式实现
原子类
原子类原理（AtomicInteger 为例）
原子类的原子性是通过 volatile + CAS 实现原子操作的。
AtomicInteger 类中的 value 是有 volatile 关键字修饰的，这就保证了 value的内存可见性，这为后续的 CAS 实现提供了基础。
低并发情况下：使用 AtomicInteger。
import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
public class ThreadDemo implements Runnable{
//private int num = 0;//共享变量
// private volatile int num = 0;
private AtomicInteger num = new AtomicInteger(0);
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":::"+getNum());
}
public int getNum() {
// return num++;
return num.getAndIncrement();
}
}
测试：
import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;
public class Test {
public static void main(String[] args) {
ThreadDemo td = new ThreadDemo();
for (int i = 0; i <10 ; i++) {//循环创建10个线程
Thread t = new Thread(td);
t.start();
}
}
}
CAS
CAS(Compare-And-Swap) ：比较并交换，该算法是硬件对于并发操作的支持。
CAS 是乐观锁的一种实现方式，他采用的是自旋锁的思想，是一种轻量级 的锁机制。
即每次判断我的预期值和内存中的值是不是相同，如果不相同则说明该内存值 已经被其他线程更新过了，因此需要拿到该最新值作为预期值，重新判断。而该 线程不断的循环判断是否该内存值已经被其他线程更新过了，这就是自旋的思 想。
CAS 包含了三个操作数：
- 内存值 V
- 预估值 A (比较时,从内存中再次读到的值)
- 更新值 B (更新后的值)
当且仅当预期值 A==V，将内存值 V=B，否则什么都不做。
这种做法的效率高于加锁,当判断不成功不能更新值时,不会阻塞,继续获得 cpu 执行权,继续判断执行.
CAS 的缺点
CAS 使用自旋锁的方式，由于该锁会不断循环判断，因此不会类似 synchronize 线程阻塞导致线程切换。但是不断的自旋，会导致 CPU 的消耗，在并发量大的 时候容易导致 CPU 跑满。
ABA 问题
ABA 问题，即某个线程将内存值由 A 改为了 B，再由 B 改为了 A。当另外一个 线程使用预期值去判断时，预期值与内存值相同，误以为该变量没有被修改过而 导致的问题。
解决 ABA 问题的主要方式，通过使用类似添加版本号的方式，来避免 ABA 问题。 如原先的内存值为（A，1），线程将（A，1）修改为了（B，2），再由（B，2） 修改为（A，3）。此时另一个线程使用预期值（A，1）与内存值（A，3）进行 比较，只需要比较版本号 1 和 3，即可发现该内存中的数据被更新过了。
扫一扫
6177
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
