java并发编程
一、关于并发
- 并发是什么？
- 并发是指在同一时间间隔内，有多个程序处于运行状态。当然，同一时刻只有一个程序在运行。与之对应的是并行，并行是指同一时刻有多个程序同时执行（宏观上）.多进程之间可以共享数据，但是其代价比多线程要大，会涉及序列化与反序列化的开销
- 为什么需要并发？
- 为了提高系统的资源利用率 和 吞吐量。就好比全班需要填表时，可以发给每个人，然后填完之后在收起来，这样的效率远比一个一个的发，然后等第一个人填完了再发给第二人填写要快的多
- 什么是线程安全？
- 线程作为独立调用的单位，当使用线程实现并发时，由于处理机的调度，可能存在线程安全问题。那什么是线程安全呢，定义为：当多个线程访问某个类是，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，这个类都能表现出正确的行为，则称这个类是线程安全的。
二、并发编程中的3个概念
1.原子性
- 定义：一个操作要么全部操作 要么都不执行
- 类似于 自增（++） 的操作，就不是原子的，因为这个操作实际上是一个“读取-修改-写入”的操作序列，其结果依赖于之前的状态。还有就是竞态条件（先检查后执行—if）非原子操作
2.可见性（同步）
- 定义：可见性是指当一个线程修改了共享变量的值后，其他线程能够立即得知这个修改。为了确保多个线程之间对内存的写入操作的可见性，必须使用同步机制。在没有同步的情况下，编译器 或 处理器 都可能对操作的执行顺序进行调整。
- volatile 变量，是一种稍弱的同步机制，它能确保变量的更新操作通知到其他线程。
- 非volatile变量为什么会存在不可见问题？
- 因为变量存储在主内存中，当一个线程需要这个变量时，它会从主内存中拷贝一份到自己线程内存中。如果这时，这个线程对它进行了修改，其他线程又访问了这个变量时，也会去主内存进行拷贝，就会导致失效数据。
- volatile 变量是怎么保证可见性的呢？
- 被 volatile 修饰的变量，每次在自己线程中使用时，都会从主内存中刷新自己的值（如果发生了改变），当被线程修改了值后，又会立即返回主内存中，把主内存中的值进行刷新。底层实现是通过内存屏障（lock前缀指令）实现的
- 那么 volatile 变量能保证原子性吗？
- volatile 变量是不能保证原子性的
3.有序性
- 有序性是指数据不相关的变量在并发的情况下，实际执行的结果和单线程的执行结果是一样的，不会因为重排序而导致结果未知，volatile、final、synchronized、显示锁可以保证有序性
三、同步机制
1.内置锁
- 每个java对象都可以用做一个实现同步的锁，这些所被称为内置锁。获得内置锁的唯一途径就是进入这个锁保护的同步代码块或方法（被 synchronized 修饰的代码块或方法）。
- 被synchronized 修饰的静态方法，锁对象为当前 Class 对象
- 被 synchronized 修饰一般方法，锁对象为当前对象
- 同步代码块的锁对象为自己指定的对象
- synchronized 是 JVM 的内置属性，JVM对此进行了优化，比如：
- 锁消除优化（去除一些不会发生竞争的锁）；
- 增加锁粒度（将附近的同步代码块用同一个锁合并起来，减少了同步的开销）；
- 找出不会发布到堆的本地对象引用，去除锁获取操作。（也就是线程封闭）
- 内置锁是可重入的，为什么？
- 重入是指：如果线程试图获取一个已经由它自己持有的锁，那么这个请求就会成功。
- 为什么是可重入的？如下代码，当调用子类的 doSomething方法时，获取了锁（当前实例），然后调用父类的方法，如果不是可重入的，则会产生死锁，因为无法获得父类上的锁（也是当前实例，因为这个锁已经被持有，从而线程会永远停顿下去）
public synchronized void doSomething(){
...
}
}
public class LoggingWidget extends Widget{
public sychronized void doSomething{
super.doSomething();
}
}2.显示锁Lock
a.关于Lock
- Lock 是java中的一个接口，其提供了一种无条件的、可轮询的、定时的以及可中断的锁获取操作。与synchronized 相同的是 互斥性 与 内存可见性。当然，它也是可重入的。java.util.concurrent.locks包中有很多实现类，常用的有 ReentrantLock、ReadWriteLock，其实现都是依赖于 java.util.concurrent.AbstractQueuedSynchronizer 类
- 下面是 Lock 接口 定义的方法
public interface Lock{
void lock();
void lockInterruptily() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time,TimeUnt unit) throws InterruptedException;
void unlock();
Condition newCondition();
}
/**- 其中前面4 个方法都是用来获取锁的，unLock（）方法是用来释放锁的： 1.lock（）方法是用来获取锁的，如果锁已被其他线程获取，则进行等待。使用lock必须在try-catch 块中进行，释放锁必须在finally 块中进行，因为如果抛出了异常，这个锁永远都不会被释放。 2.tryLock（）：请求加锁，如果加锁不成功返回false，不会发生阻塞 3.tryLock（long time，TimeOut unit）throws InterruptedException：请求加锁，如果加锁不成功会在规定的时间内阻塞，超时后会返回，支持中断 4.lockInterruptibly（）throws InterruptedException：请求加锁，如果请求不到锁会发生阻塞，在阻塞过程中允许中断 */
b.关于AbstractQueueSynchronizer
- 在java.util.concurrent 中许多可阻塞类，例如 ReentrantLock、Semaphore、ReentrantReadWriteLock、CountDownLatch、SynchronousQueue 和 FutureTask等都是基于 AQS 构建的。
- 关于读写锁ReentrantReadWriteLock:可以多个读线程同时访问 或者 只有一个写线程访问
- 构建ReentrantLock 时，可以传入一个Boolean 类型的参数，这个参数是用来描述锁公平与否的。公平锁是严格按照请求锁的顺序来排队获取锁的，而非公平锁是可以抢占的
3.在synchronized 和 ReentrantLock 的选择
- synchronized 与 lock 锁的区别：
- synchronized 是 基于软件层面，JVM 内置的锁，而 Lock是基于CPU指令的
- synchronized 是基于块结构的，而 Lock 可以有更小的粒度
- synchronized 是不可中断的，而 Lock是可中断的
- synchronized 不用自己释放锁，而lock需要显示释放锁（在finally代码块中）
- 由于 synchronized 是 JVM 的内置锁，所以对它可进行的干预很少，甚至不需要自己来释放锁。除此之外， JVM还对内置锁做了一些优化，所以建议只有在内置锁无法满足需求的情况下，才选择使用 ReentrantLock。比如：可定时、可轮询、可中断的锁获取操作，以及非块结构（相当于ConcurrentHashMap 中的锁分段）。
4.锁的劣势
- 当线程恢复执行时，必须等待其他线程执行完它们的时间片以后，才能被调度指向，在挂起和恢复线程等过程中存在很大的开销，并且通常存在着较长时间的中断
- 当一个线程正在等待锁时，它不能做任何其他事情，必须等待锁释放
5.非阻塞同步机制
- 基于锁的劣势，处理器提供了一种类似于 volatile变量的机制同时还支持原子的更新操作（测试并设置，比较并交换，获取并递增）。这种方法采用的是乐观的方法，意思就是如果在操作过程中，有其他线程的干扰，就重试。
- 比较并交换 CAS：首先从V中读取值A，并根据A计算新值B，然后再通过CAS以原子方式将V中的值由A变成B（只要在这段期间没有任何线程将 V的值修改为其他值）。这种方式的主要缺点是：它将是调用者处理竞争问题（重试、回退、放弃），并且在高并发的情况下，失败的几率大大增加。
- 在java中，原子变量类就直接利用了底层的并发原语（CAS）来维持线程的安全性
四、避免使用同步的方式
- 线程封闭：也就是在单线程内访问数据
- 局部变量，其封闭在执行的线程中，位于线程的栈中，其他线程无法访问这个栈
- ThreadLocal 类，这个类能使线程中的某个值与保存值的对象关联起来，其可以防止对可变的单实例变量或全局变量进行共享。每个线程中有一个 localVariable 变量，这个变量是 一个threadLocalMap 变量，当设置值的时候会获取当前线程的 Map，然后把当前 threadLocal 添加进去，key为当前 threadLocal，value为 资源，然后获取的时候也是获取当前对象的Map，然后进行获取，从而屏蔽了线程的私有变量
- 不可变对象：因为不可变对象一定是线程安全。不可变对象必须满足一下条件：
- 对象创建以后其状态就不能修改
- 对象的所有域都是final类型
- 对象是正确创建的（在对象的创建期间，this引用没有逸出）
五、并发容器 & 同步工具类
1.并发容器
- Queue：
- ConcurrentLInkedQueue：先进先出的并发队列
- PriorityQueue：是一个非并发的优先队列，Queue上的操作不会阻塞，如果队列为空，获取元素的操作将会返回空值。是由LinkedList实现
- BlockingQueue：可阻塞队列，如果队列为空，获取操作将一直阻塞，直到队列出现一个 可用的元素；如果队列已满，则插入元素的操作将一直阻塞，直到队列出现可用的空间。阻塞队列一般用于生产者-消费者模式
- LinkedBlockingQueue：基于链表
- ArrayBlockingQueue：基于数组
- PriorityBlockingQUeue：按照优先级排序的队列
- SynchronousQueue：其维护一组线程直接交付给处理线程，从而降低了将数据从生产者移动到消费者的延迟
- Concurrent
- CopyOnWriteArrayList| CopyOnWriteArraySet：写入时复制，也就是在每次修改时，都会创建并重新发布一个新的容器副本，因此写操作花费很大，但是在访问对象不需要进行同步
- ConcurrentMap：是 Map的同步容器类
- Deque：Deque是对Queue的扩展，它是一个双端队列，实现了在队列头和队列尾的高效插入和移除
2.同步工具类
- 闭锁 闭锁是一种同步工具类，可以延迟线程的进度直到其到达终止状态。闭锁可以用来确保某些活动直到其他活动都完成后才继续执行，用于等待事件。 CountDownLatch（不能循环使用） ：使一个或多个线程等待一组事件发生，countDown方法递减计数器（表示还需等待多少事件发生），而await方法等待计数器达到零。也就是说当多个线程都到达了预期状态或完成预期工作时触发事件，其他线程可以等待这个事件来触发自己后续工作
举个例子：
int count = 5;
final CountDownLatch latch = new CountDownLatch(count);
for(int i = 0 ; i < count ; i ++ ){
threadPool.execute(new MyRunnable(latch));
}
latch.await();//等待全部达到状态再执行后面操作
...
//MyRunnable run 方法
public void run（）{
latch.countDown（）；//继续执行后面的代码
....
}
- FutureTask — 可用于实现缓存，用于检查某项任务是否已经开始，而不是检查是否完成 Future 是一个接口，FutureTask是一个具体实现类 Future.get 的行为取决于任务的状态，如果任务已经完成，那么 get会立即返回结果，否则get 将阻塞直到任务进入 完成状态，然后返回结果或者抛出异常。FutureTask 将计算结果从执行计算的线程传递到获取这个结果的线程 private Future<HashMap> getDataFromRemote(){ return threadPool.submit(new Callable<HashMap>(){ public HashMap call() throws Exception{ return getData(); } } }
- 信号量 计数信号量用来控制同时访问某个特定资源的操作数量，或者同时执行某个指定操作的数量。技术信号量还可以用来实现某种资源池，或者对容器施加边界 Semaphore 中管理者一组虚拟的许可，许可的初始数量可通过构造函数来指定，在执行操作时可以首先获得许可（只要还有剩余的许可 — 阻塞），并在使用后释放许可。当初始值为1 的 S恩吗炮轰热二值信号量可以用做互斥体，并具备不可重入的加锁（相当于的加锁） 可以用做 数据库连接池 、 可以使用Semaphore 将任何一种容器变成有界阻塞容器
- 栅栏 — 等待过后还要做其他事情 闭锁是一次性对象，一旦进入终止状态，就不能被重置 栅栏：所有线程必须同时到达栅栏位置才能继续执行，用于等待其他线程，等待过后还要做其他事情，用于实现一些协议 ①CyclicBarrier（能循环使用）:等待全部线程狙击，栅栏打开，线程被释放，栅栏被重置。也就是说用于协同多个线程，让多个线程在这个屏障前等待，直到所有线程都到达了这个屏障时，再一起继续执行后面的方法。线程如未全部通过，则线程将全部终止并抛出 BrokenBarrierException ，若成功通过，则 await将为每个线程返回一个唯一的到达索引号。 完成了前一步的所有操作才可以进入下一步
int count = 5;
final CycliBarrier barrier = new CycliBarrier(count + 1);//此处比构造CountDownLatch多出来的1是因为 CountDownLatch调用的是 countDown 的数量，而 CyclicBarrier 的数量是 await 的数量
for(int i = 0 ; i < count ; i ++ ){
threadPool.execute(new MyRunnable(barrier))
}
barrier.await();//这里有一个 await
....
// MyRunnable 的 run 方法
public void run(){
try{
barrier.await(); // 所有都执行完了才继续执行后面的
....
}catch(Exception e ){
}
}
②另一种形式的栅栏式 Exchanger ，它是一种两方栅栏，各方在栅栏位置上交换数据，当两个线程通过 Exchanger 交换对象时，这种交换就把这两个对象安全的发布给另一方。线程会阻塞在 Exchanger 的 exchange 方法上，直到另外一个线程也到了同一个 Exchange的 exchange 方法 a. 当缓冲区被填满时，有填充任务进行交换，当缓冲区为空时，有清空任务进行交换 b. 不仅当缓冲被填满时进行交换，并且当缓冲被填充到一定程度并保持一定时间后也进行交换
关于线程
- yield 与 sleep 不会释放当前这个线程拥有的锁，sleep也不会放弃当前的锁，如果其他线程不需要这个资源，则可运行。interrupt可以唤醒休眠中的线程。t.join（）:主线程等待 t 线程结束.10 为最高优先级，0为最低优先级，默认优先级为5
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
