首页技术文章正文

Java 并发学习【黑马java培训】

更新时间:2019年07月26日 11时15分49秒 来源:黑马程序员论坛



Java 并发学习
       使用并发的一个重要原因是提高执行效率。由于I/O等情况阻塞,单个任务并不能充分利用CPU时间。所以在单处理器的机器上也应该使用并发。
为了实现并发,操作系统层面提供了多进程。但是进程的数量和开销都有限制,并且多个进程之间的数据共享比较麻烦。另一种比较轻量的并发实现是使用线程,一个进程可以包含多个线程。线程在进程中没有数量限制, 数据共享相对简单。线程的支持跟语言是有关系的。Java 语言中支持多线程。
      Java 中的多线程是抢占式的。这意味着一个任务随时可能中断并切换到其它任务。所以我们需要在代码中足够的谨慎,防范好这种切换带来的副作用。
基础
      Runnable 它可以理解成一个任务。它的run()方法就是任务的逻辑,执行顺序。
      Thread 它是一个任务的载体,虚拟机通过它来分配任务执行的时间片。Thread中的start方法可以作为一个并发任务的入口。不通过start方法来执行任务,那么run方法就只是一个普通的方法
线程的状态有四种:
  • NEW 线程创建的时候短暂的处于这种状态。这种状态下已经可以获得CPU时间了,随后可能进入RUNNABLE,BLOCKED状态。
  • RUNNABLE 此状态下只要CPU将时间分配给线程,线程中的任务就可以执行。随后可能进入BLOCKED,DEAD状态。
  • BLOCKED 线程可以运行,但是有某个条件阻止着它。当线程处于阻塞状态时,CPU不会分配时间片给它,直到它重新进入RUNNABLE状态。
  • DEAD 此状态的线程将永远不会获得CPU时间片。通常是因为run()方法返回才会到达此状态。此时任务还是可以被中断的。
     Callable 它是一个带返回的异步任务,返回的结果放到一个Future对象中。
     Future 它可以接受Callable任务的返回结果。在任务没有返回的时候调用get方法会阻塞当前线程。cancel方法会尝试取消未完成的任务(未执行->直接不执行,已经完成->返回false,正在执行->尝试中断)。
     FutureTask 同时继承了Runnable, Callable 接口。
     Java 1.5之后,不再推荐直接使用Thread对象作为任务的入口。推荐使用Executor管理Thread对象。Executor是线程与任务之间的的一个中间层,它屏蔽了线程的生命周期,不再需要显式的管理线程。并且ThreadPoolExecutor 实现了此接口,我们可以通过它来利用线程池的优点。
     线程池涉及到的类有:Executor, ExecutorService, ThreadExecutorPool, Executors, FixedThreadPool, CachedThreadPool, SingleThreadPool。
     Executor 只有一个方法,execute来提交一个任务
     ExecutorService 提供了管理异步任务的方法,也可以产生一个Future对象来跟踪一个异步任务。
主要的方法如下:
  • submit 可以提交一个任务
  • shutdown 可以拒绝接受新任务
  • shutdownNow 可以拒绝新任务并向正在执行的任务发出中断信号
  • invokeXXX 批量执行任务
     ThreadPoolExecutor 线程池的具体实现类。线程池的好处在于提高效率,能避免频繁申请/回收线程带来的开销。
它的使用方法复杂一些,构造线程池的可选参数有:
  • corePoolSize : int 工作的Worker的数量。
  • maximumPoolSize : int 线程池中持有的Worker的最大数量
  • keepAliveTime : long 当超过Workder的数量corePoolSize的时候,如果没有新的任务提交,超过corePoolSize的Worker的最长等待时间。超过这个时间之后,一部分Worker将被回收。
  • unit : TimeUnit keepAliveTime的单位
  • workQueue : BlockingQueue 缓存任务的队列, 这个队列只缓存提交的Runnable任务。
  • threadFactory : ThreadFactory 产生线程的“工厂”
  • handler : RejectedExecutionHandler 当一个任务被提交的时候,如果所有Worker都在工作并且超过了缓存队列的容量的时候。会交给这个Handler处理。Java 中提供了几种默认的实现,AbortPolicy, CallerRunsPolicy, DiscardOldestPolicy, DiscardPolicy。
      这里的Worker可以理解为一个线程。
      这里之前想不通,觉得线程不可能重新利用绑定新任务。看了下源码发现原来确实不是重新绑定任务。每一个Worker的核心部分只是一个循环,不断从缓存队列中取任务执行。这样达到了重用的效果。
[Java] 纯文本查看 复制代码
final void runWorker(Worker w) {
    Runnable task = w.firstTask;
    // ...
    try {
        while(task != null || (task=getTask())!=null) {
            try{
                task.run();
            } catch(Exception e){
            }
            // ...
        }
    } finally {
        // ...
    }
    // ...
}
Executors类提供了几种默认线程池的实现方式。
  • CachedThreadExecutor 工作线程的数量没有上限(Integer的最大值), 有需要就创建新线程。
  • FixedThreadExecutor 预先一次分配固定数量的线程,之后不再需要创建新线程。
  • SingleThreadExecutor 只有一个线程的线程池。如果提交了多个任务,那么这些人物将排队,每个任务都在上一个人物执行完之后执行。所有任务都是按照它们的提交顺序执行的。
sleep(long) 当前线程 中止 一段时间。它不会释放锁。Java1.5之后提供了更加灵活的版本。
TimeUnit 可以指定睡眠的时间单位。
优先级 绝大多数情况下我们都应该使用默认的优先级。不同的虚拟机中对应的优先级级别的总数,一般用三个就可以了 MAX_PRIORITY, NORM_PRIORITY, MIN_PRIORITY。

让步 Thread.yield()建议相同优先级的其它线程先运行,但是不保证一定运行其它线程。

后台线程 一个进程中的所有非后台线程都终止的时候整个进程也就终止,同时杀死所有后台线程。与优先级没有什么关系。
join() 线程 A 持有线程T,当在线程T调用T.join()之后,A会阻塞,直到T的任务结束。可以加一个超时参数,这样在超时之后线程A可以放弃等待继续执行任务。

捕获异常 不能跨线程捕获异常。比如说不能在main线程中添加try-catch块来捕获其它线程中抛出的异常。每一个Thread对象都可以设置一个UncaughtExceptionHandler对象来处理本线程中抛出的异常。线程池中可以通过参数ThreadFactory来为每一个线程设置一个UncaughtExceptionHandler对象。

访问共享资源 在处理并发的时候,将变量设置为private非常的重要,这可以防止其它线程直接访问变量。
synchronized 修饰方法在不加参数情况下,使用对象本身作为锁。静态方法使用Class对象作为锁。同一个任务可以多次获得对象锁。

显式锁 Lock,相比synchronized更加灵活。但是需要的代码更多,编写出错的可能性也更高。只有在解决特殊问题或者提高效率的时候才用它。

原子性 原子操作就是永远不会被线程切换中断的操作。很多看似原子的操作都是非原子的,比如说long,double是由两个byte表示的,它们的所有操作都是非原子的。所以,涉及到并发异常的地方都加上同步吧。除非你对虚拟机十分的了解。
volatile 这个关键字的作用在于防止多线程环境下读取变量的脏数据。这个关键字在c语言中也有,作用是相同的。

原子类 AtomicXXX类,它们能够保证对数据的操作是满足原子性的。这些类可以用来优化多线程的执行效率,减少锁的使用。然而,使用难度还是比较高的。

临界区 synchronized关键字的用法。不是修饰整个方法,而是修饰一个代码块。它的作用在于尽量利用并发的效率,减少同步控制的区域。

ThreadLocal 这个概念与同步的概念不同。它是给每一个线程都创建一个变量的副本,并保持副本之间相互独立,互不干扰。所以各个线程操作自己的副本,不会产生冲突。

终结任务
这里我讲一下自己当前的理解。
一个线程不是可以随便中断的。即使我们给线程设置了中断状态,它也还是可以获得CPU时间片的。只有因为sleep()方法而阻塞的线程可以立即收到InterruptedException异常,所以在sleep中断任务的情况下可以直接使用try-catch跳出任务。其它情况下,均需要通过判断线程状态来判断是否需要跳出任务(Thread.interrupted()方法)。
synchronized方法修饰的代码不会在收到中断信号后立即中断。ReentrantLock锁控制的同步代码可以通过InterruptException中断。
Thread.interrupted方法调用一次之后会立即清空中断状态。可以自己用变量保存状态。

线程协作
     wait/notifyAll wait/notifyAll是Object类中的方法。调用wait/notifyAll方法的对象是互斥对象。因为Java中所有的Object都可以做互斥量(synchronized关键字的参数),所以wait/notify方法是在Object类中的。
     wait与sleep 不同在于sleep方法是Thread类中的方法,调用它的时候不会释放锁;wait方法是Object类中的方法,调用它的时候会释放锁。
     调用wait方法之前,当前线程必须持有这段逻辑的锁。否则会抛出异常,不能继续执行。
     wait方法可以将当前线程放入等待集合中,并释放当前线程持有的锁。此后,该线程不会接收到CPU的调度,并进入休眠状态。有四种情况肯能打破这种状态:
  • 有其它线程在此互斥对象上调用了notify方法,并且刚好选中了这个线程被唤醒;
  • 有其它线程在此互斥对象上调用了notifyAll方法;
  • 其它线程向此线程发出了中断信号;
  • 等待时间超过了参数设置的时间。
     线程一旦被唤醒之后,它会像正常线程一样等待之前持有的所有锁。直到恢复到wait方法调用之前的状态。
     还有一种不常见的情况,spurious wakeup(虚假唤醒)。就是在没有notify,notifyAll,interrupt的时候线程自动醒来。查了一些资料并没有弄清楚是为什么。不过为了防止这种现象,我们要在wait的条件上加一层循环。
     当一个线程调用wait方法之后,其它线程调用该线程的interrupt方法。该线程会唤醒,并尝试恢复之前的状态。当状态恢复之后,该线程会抛出一个异常。
     notify  唤醒一个等待此对象的线程。
     notifyAll 唤醒所有等待此对象的线程。
错失的信号
     当两个线程使用notify/wait或者notifyAll/wait进行协作的时候,不恰当的使用它们可能会导致一些信号丢失。例子:
[Java] 纯文本查看 复制代码
T1:
synchronized(shareMonitor){
    // set up condition for T2
    shareMonitor.notify();
}

T2:
while(someCondition){
    // Point 1
    synchronized(shareMonitor){
        shareMonitor.wait();
    }
}
信号丢失是这样发生的:
       当T2执行到Point1的时候,线程调度器将工作线程从T2切换到T1。T1完成T2条件的设置工作之后,线程调度器将工作线程从T1切换回T2。虽然T2线程等待的条件已经满足,但还是会被挂起。
解决的方法比较简单:
[Java] 纯文本查看 复制代码
T2:
synchronized(sharedMonitor) {
    while(someCondition) {
        sharedMonitor.wait();
    }
}
将竞争条件放到while循环的外面即可。在进入while循环之后,在没有调用wait方法释放锁之前,将不会进入到T1线程造成信号丢失。
      notify & notifyAll 前面已经提过这两个方法的区别。notify是随机唤醒一个等待此锁的线程,notifyAll是唤醒所有等待此锁的线程。
      Condition 他是concurrent类库中显式的挂起/唤醒任务的工具。它是真正的锁(Lock)对象产生的一个对象。其实用法跟wait/notify是一致的。await挂起任务,signalAll()唤醒任务。
       生产者消费者队列 Java中提供了一种非常简便的容器,BlockingQueue。已经帮你写好了阻塞式的队列。
       除了BlockingQueue,使用PipedWriter/PipedReader也可以方便的在线程之间传递数据。
死锁
死锁有四个必要条件,打破一个即可去除死锁。
四个必要条件:
  • 互斥条件。 互斥条件:一个资源每次只能被一个进程使用。
  • 请求与保持条件:一个线程因请求资源而阻塞时,对已获得的资源保持不放。
  • 不剥夺条件:线程已获得的资源,在末使用完之前,不能强行剥夺。
  • 循环等待条件:若干线程之间形成一种头尾相接的循环等待资源关系。
本来自己翻译,但发现百度上描述的更好一些,直接copy到这里来,并把进程换成了线程。
其它工具
      CountDownLatch 同步多个任务,强制等待其它任务完成。它有两个重要方法countDown,await以及构造时传入的参数SIZE。当一个线程调用await方法的时候会挂起,直到该对象收到SIZE次countDown。一个对象只能使用一次。
      CyclicBarrier 也是有一个SIZE参数。当有SIZE个线程调用await的时候,全部线程都会被唤醒。可以理解为所有运动员就位后才能起跑,早就位的运动员只能挂起等待。它可以重复利用。
      DelayQueue 一个无界的BlockingQueue,用来放置实现了Delay接口的对象,在队列中的对象只有在到期之后才能被取走。如果没有任何对象到期,就没有头元素。
      PriorityBlockingQueue 一种自带优先级的阻塞式队列。
      ScheduledExecutor 可以把它想象成一种线程池式的Timer, TimerTask。
      Semaphore 互斥锁只允许一个线程访问资源,但是Semaphore允许SIZE个线程同时访问资源。
Exchanger 生产者消费者问题的特殊版。两个线程可以在都‘准备好了’之后交换一个对象的控制权。
ReadWriteLock 读写锁。 读-读不互斥,读-写互斥,写-写互斥。

文章摘自:https://juejin.im/entry/5777ce8d0a2b5839374acccc


推荐了解热门学科

java培训 Python人工智能 Web前端培训 PHP培训
区块链培训 影视制作培训 C++培训 产品经理培训
UI设计培训 新媒体培训 产品经理培训 Linux运维
大数据培训 智能机器人软件开发




传智播客是一家致力于培养高素质软件开发人才的科技公司“黑马程序员”是传智播客旗下高端IT教育品牌。自“黑马程序员”成立以来,教学研发团队一直致力于打造精品课程资源,不断在产、学、研3个层面创新自己的执教理念与教学方针,并集中“黑马程序员”的优势力量,针对性地出版了计算机系列教材50多册,制作教学视频数+套,发表各类技术文章数百篇。

传智播客从未停止思考

传智播客副总裁毕向东在2019IT培训行业变革大会提到,“传智播客意识到企业的用人需求已经从初级程序员升级到中高级程序员,具备多领域、多行业项目经验的人才成为企业用人的首选。”

中级程序员和初级程序员的差别在哪里?
项目经验。毕向东表示,“中级程序员和初级程序员最大的差别在于中级程序员比初级程序员多了三四年的工作经验,从而多出了更多的项目经验。“为此,传智播客研究院引进曾在知名IT企业如阿里、IBM就职的高级技术专家,集中研发面向中高级程序员的课程,用以满足企业用人需求,尽快补全IT行业所需的人才缺口。

何为中高级程序员课程?

传智播客进行了定义。中高级程序员课程,是在当前主流的初级程序员课程的基础上,增加多领域多行业的含金量项目,从技术的广度和深度上进行拓展“我们希望用5年的时间,打造上百个高含金量的项目,覆盖主流的32个行业。”传智播客课程研发总监于洋表示。




黑马程序员热门视频教程【点击播放】

Python入门教程完整版(懂中文就能学会) 零起点打开Java世界的大门
C++| 匠心之作 从0到1入门学编程 PHP|零基础入门开发者编程核心技术
Web前端入门教程_Web前端html+css+JavaScript 软件测试入门到精通


在线咨询 我要报名
和我们在线交谈!