请选择 进入手机版 | 继续访问电脑版
零一零零 门户 IT技术 Java并发 查看内容

Java并发编程之应用详解

2020-7-3 10:58| 发布者: x0100| 查看: 839| 评论: 0

摘要: 1. 并发编程介绍 1.1 并发的出现 单CPU时代,单任务在一个时间点只能执行单一程序。 多任务阶段,计算机能在同一时间点并行执行多进程。多个任务或进程共享一个CPU,并交由操作系统来完成多任务间对CPU的运行切换, ...


1. 并发编程介绍

1.1 并发的出现

单CPU时代,单任务在一个时间点只能执行单一程序。

多任务阶段,计算机能在同一时间点并行执行多进程。多个任务或进程共享一个CPU,并交由操作系统来完成多任务间对CPU的运行切换,以使得每个任务都有机会获得一定的时间片运行。

现代的计算机多核CPU,在一个程序内部能拥有多个线程并行执行,多个CPU同时执行该程序。一个进程就包括了多个线程,每个线程负责一个独立的子任务。

进程让操作系统的并发性成为可能,而线程让进程的内部并发成为可能。

一个进程虽然包括多个线程,但是这些线程是共同享有进程占有的资源和地址空间的。

进程是操作系统进行资源分配的基本单位,而线程是操作系统进行调度的基本单位。

1.2 并发编程优点

1)资源利用率更好

举例:

一个程序读取文件(5s)和处理文件(2s),处理2个文件。

  1. 5秒读取文件A
  2. 2秒处理文件A
  3. 5秒读取文件B
  4. 2秒处理文件B

总共需要14秒。读取文件的时候,CPU空闲等待读取数据,浪费CPU资源。

并发处理:

  1. 5秒读取文件A
  2. 5秒读取文件B + 2秒处理文件A
  3. 2秒处理文件B

总共需要12秒。当第二文件在被读取的时候,利用CPU的空闲去处理第一个文件。

2)程序设计在某些情况下更简单

如上述读取处理文件举例中,如果使用单线程实现,需要每个文件读取和处理的状态;而使用多线程,每个线程处理一个文件的读取和处理,不需要记录文件读取和处理状态,实现更简单。

3)程序响应更快

并发编程缺点

1)设计更复杂

由于多个线程是共同占有所属进程的资源和地址空间的,那么就会存在多个线程同时访问同一个资源的问题,可能导致线程安全问题。避免多线程编程中线程安全设计较复杂。

2)上下文切换的开销

CPU从执行一个线程切换到执行另外一个线程的时候,需要先存储当前线程的本地的数据,程序指针等,然后载入另一个线程的本地数据,程序指针等,最后才开始执行。这种切换称为上下文切换

对于线程的上下文切换实际上就是存储和恢复CPU状态的过程,它使得线程执行能够从中断点恢复执行。

虽然多线程可以使得任务执行的效率得到提升,但是由于在线程切换时同样会带来一定的开销代价,并且多个线程会导致系统资源占用的增加,所以在进行多线程编程时要注意这些因素。

3)增加资源消耗

线程在运行的时候需要从计算机里面得到一些资源。除了CPU,线程还需要一些内存来维持它本地的堆栈。它也需要占用操作系统中一些资源来管理线程。

2. 线程安全问题

竞态条件:当多个线程同时访问同一个资源,其中的一个或者多个线程对这个资源进行了写操作,对资源的访问顺序敏感,就称存在竞态条件。多个线程同时读同一个资源不会产生竞态条件。

临界区:导致竞态条件发生的代码区称作临界区。在临界区中使用适当的同步就可以避免竞态条件。

  1. public class Counter {
  2. protected long count = 0;
  3. public void add(long value){
  4. this.count = this.count + value;
  5. }
  6. }

多线程同时执行上面的代码可能会出错:多线程同时执行临界区代码this.count = this.count + value时,同时对同一资源this.count进行写操作,产生了竞态条件。

基本上所有的并发模式在解决线程安全问题时,都采用“序列化访问临界资源”的方案,即在同一时刻,只能有一个线程访问临界资源,也称作同步互斥访问。通常来说,是在访问临界资源的代码前面加上一个锁,当访问完临界资源后释放锁,让其他线程继续访问。

在Java中,提供了两种方式来实现同步互斥访问:synchronized和Lock。

3. 线程通信

线程通信的目标是使线程间能够互相发送信号。另一方面,线程通信使线程能够等待其他线程的信号。

通过共享对象通信

  1. // 必须是同一个MySignal实例,通过共享变量hasDataToProcess通信
  2. public class MySignal {
  3. protected boolean hasDataToProcess = false;
  4. public synchronized boolean hasDataToProcess() {
  5. return this.hasDataToProcess;
  6. }
  7. public synchronized void setHasDataToProcess(boolean hasData) {
  8. this.hasDataToProcess = hasData;
  9. }
  10. }

单线程A完成某一操作M之后,调用setHasDataToProcess(true),将hasDataToProcess置为true,表示操作M完成。

线程B调用hasDataToProcess()获取hasDataToProcess为true,就知道操作M已经完成。

wait() - notify()/notifyAll()

  1. //A线程调用doWait()等待, B线程调用doNotify()唤醒A线程
  2. public class MyWaitNotify {
  3. MonitorObject myMonitorObject = new MonitorObject();
  4. public void doWait(){
  5. synchronized(myMonitorObject){
  6. try{
  7. myMonitorObject.wait();
  8. } catch(InterruptedException e){...}
  9. }
  10. }
  11. public void doNotify() {
  12. synchronized (myMonitorObject) {
  13. myMonitorObject.notify();
  14. }
  15. }
  16. }

优化:

  1. 增加boolean wasSignalled,记录是否收到唤醒信号。只有没收到过唤醒信号时才可以wait,避免信号丢失导致永久wait。

  2. while()自旋锁,线程被唤醒之后可以保证再次检查条件是否满足,避免虚假信号。

  1. public class MyWaitNotify3 {
  2. MonitorObject myMonitorObject = new MonitorObject();
  3. boolean wasSignalled = false;
  4. public void doWait() {
  5. synchronized (myMonitorObject) {
  6. while (!wasSignalled) {
  7. try {
  8. myMonitorObject.wait();// 如果被虚假唤醒,再回while循环检查条件wasSignalled
  9. } catch (InterruptedException e) {
  10. }
  11. }
  12. wasSignalled = false;
  13. }
  14. }
  15. public void doNotify() {
  16. synchronized (myMonitorObject) {
  17. wasSignalled = true;
  18. myMonitorObject.notify();
  19. }
  20. }
  21. }

4. 死锁

死锁:多个线程同时但以不同的顺序请求同一组锁的时候,线程之间互相循环等待锁导致线程一直阻塞。

如果线程1锁住了A,然后尝试对B进行加锁,同时线程2已经锁住了B,接着尝试对A进行加锁,这样线程1持有锁A等待锁B,线程2持有锁B等待锁A,就会发生死锁。

死锁可能不止包含2个线程,可以包含多个线程。如线程1等待线程2,线程2等待线程3,线程3等待线程4,线程4等待线程1。

举例:

  1. public class Test {
  2. static Object lockObject1 = new Object();
  3. static Object lockObject2 = new Object();
  4. public static void main(String[] args) {
  5. new Thread() {
  6. @Override
  7. public void run() {
  8. synchronized (lockObject1) {
  9. try {
  10. Thread.sleep(500);
  11. } catch (InterruptedException e) {
  12. e.printStackTrace();
  13. }
  14. synchronized (lockObject2) {
  15. System.out.println(1);
  16. }
  17. }
  18. }
  19. }.start();
  20. new Thread() {
  21. @Override
  22. public void run() {
  23. synchronized (lockObject2) {
  24. synchronized (lockObject1) {
  25. System.out.println(1);
  26. }
  27. }
  28. }
  29. }.start();
  30. }
  31. }

如何避免死锁?

1)按顺序加锁

多个线程请求的一组锁按顺序加锁可以避免死锁。

死锁:如果线程1锁住了A,然后尝试对B进行加锁,同时线程2已经锁住了B,接着尝试对A进行加锁,发生死锁。

解决:规定锁A和锁B的顺序,某个线程需要同时获取锁A和锁B时,必须先拿锁A再拿锁B。线程1和线程2都先锁A再锁B,不会发生死锁。

问题:需要事先知道所有可能会用到的锁,并对这些锁做适当的排序。

2)加锁时限(超时重试机制)

设置一个超时时间,在尝试获取锁的过程中若超过了这个时限该线程则放弃对该锁请求,回退并释放所有已经获得的锁,然后等待一段随机的时间再重试。

这段随机的等待时间让其它线程有机会尝试获取相同的这些锁,并且让该应用在没有获得锁的时候可以继续运行干点其它事情。

问题:

  1. 当线程很多时,等待的这一段随机的时间会一样长或者很接近,因此就算出现竞争而导致超时后,由于超时时间一样,它们又会同时开始重试,导致新一轮的竞争,带来了新的问题。

  2. 不能对synchronized同步块设置超时时间。需要创建一个自定义锁,或使用java.util.concurrent包下的工具。

3)死锁检测

主要是针对那些不可能实现按序加锁并且锁超时也不可行的情况。

每当一个线程获得了锁,会在线程和锁相关的数据结构中(比如map)将其记下。当一个线程请求锁失败时,这个线程可以遍历锁的关系图看看是否有死锁发生。

例如:线程1请求锁A,但是锁A这个时候被线程2持有,这时线程1就可以检查一下线程2是否已经请求了线程1当前所持有的锁。

如果线程2确实有这样的请求,那么就是发生了死锁(线程1拥有锁B,请求锁A;线程B拥有锁A,请求锁B)。

当检测出死锁时,可以有两种做法:

  1. 释放所有锁,回退,并且等待一段随机的时间后重试。(类似超时重试机制)

  2. 给这些线程设置优先级,让一个(或几个)线程回退,剩下的线程就像没发生死锁一样继续保持着它们需要的锁。

5. 嵌套管程锁死

  1. 线程1获得A对象的锁。
  2. 线程1获得对象B的锁(A对象锁还未释放)。
  3. 线程1调用B.wait(),从而释放了B对象上的锁,但仍然持有对象A的锁。
  4. 线程2需要同时持有对象A和对象B的锁,才能向线程1发信号B.notify()。
  5. 线程2无法获得对象A上的锁,因为对象A上的锁当前正被线程1持有。
  6. 线程2一直被阻塞,等待线程1释放对象A上的锁。
  7. 线程1一直阻塞,等待线程2的信号,因此不会释放对象A上的锁。

举例:

  1. public class Lock {
  2. protected MonitorObject monitorObject = new MonitorObject();
  3. protected boolean isLocked = false;
  4. public void lock() throws InterruptedException {
  5. synchronized (this) {
  6. while (isLocked) {
  7. synchronized (this.monitorObject) {
  8. this.monitorObject.wait();
  9. }
  10. }
  11. isLocked = true;
  12. }
  13. }
  14. public void unlock() {
  15. synchronized (this) {
  16. this.isLocked = false;
  17. synchronized (this.monitorObject) {
  18. this.monitorObject.notify();
  19. }
  20. }
  21. }
  22. }

线程1调用lock()方法,Lock对象锁和monitorObject锁,调用monitorObject.wait()阻塞,但仍然持有Lock对象锁。

线程2调用unlock()方法解锁时,无法获取Lock对象锁,因为线程1一直持有Lock锁,造成嵌套管程锁死。

6. 重入锁死

如果一个线程持有某个对象上的锁,那么它就有权访问所有在该对象上同步的块,这就叫可重入。synchronized、ReentrantLock都是可重入锁。

如果一个线程持有锁A,锁A是不可重入的,该线程再次请求锁A时被阻塞,就是重入锁死。

重入锁死举例:

  1. public class Lock {
  2. private boolean isLocked = false;
  3. public synchronized void lock() throws InterruptedException {
  4. while (isLocked) {
  5. wait();
  6. }
  7. isLocked = true;
  8. }
  9. public synchronized void unlock() {
  10. isLocked = false;
  11. notify();
  12. }
  13. }

如果一个线程两次调用lock()间没有调用unlock()方法,那么第二次调用lock()就会被阻塞,这就出现了重入锁死。

7. 饥饿和公平

如果一个线程因为CPU时间全部被其他线程抢走而得不到CPU运行时间,这种状态被称之为饥饿。

导致线程饥饿原因:

  1. 高优先级线程吞噬所有的低优先级线程的CPU时间。

  2. 线程始终竞争不到锁。

  3. 线程调用object.wait()后没有被唤醒。

解决饥饿的方案被称之为公平性,即所有线程均能公平地获得运行机会。关于公平锁会在之后ReentrantLock中详细介绍。

总结

并发编程可以更好的利用CPU资源,更高效快速的响应程序,但是设计较复杂,并且上下文切换会造成一定的消耗。

并发编程中,由于多个线程同时访问同一个资源,可能造成线程安全问题,Java中可以通过synchronized和Lock的方式实现同步解决线程安全问题。

更好的发挥多线程的优势需要线程之间通信,常用的线程通信方式是通过共享对象的状态通信和wait()/notify()。

多个线程同时但以不同的顺序请求同一组锁的时候,线程之间互相循环等待锁导致线程一直阻塞,造成死锁。最常用的解决死锁的方式是按顺序加锁。

线程持有不可重入锁之后再次请求不可重入锁时被阻塞,就是重入锁死。

如果一个线程因为CPU时间全部被其他线程抢走而得不到CPU运行时间,这种状态被称之为饥饿。


鲜花

握手
1

雷人

路过

鸡蛋

刚表态过的朋友 (1 人)

最新评论


QQ|Archiver|手机版|小黑屋| 零一零零 ( 京ICP备20003964号 ) |网站地图

GMT+8, 2020-10-31 18:33 , Processed in 0.038682 second(s), 17 queries .

Powered by Discuz! X3.4

© 2001-2013 Comsenz Inc.

返回顶部