标签分类
当前位置:首页 > > Java电子书网盘下载
Java线程与并发编程实践 Java线程与并发编程实践
码小辫

码小辫 提供上传

资源
20
粉丝
49
喜欢
214
评论
12

    Java线程与并发编程实践 PDF 超清中文版

    Java电子书
    • 发布时间:

    给大家带来的一篇关于Java相关的电子书资源,介绍了关于Java、线程、并发方面的内容,本书是由人民邮电出版社出版,格式为PDF,资源大小42.3 MB,Jeff Friesen编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:7.9

  • Java线程与并发编程实践 PDF 下载
  • 下载地址:https://pan.baidu.com/s/1DIMQCFtu0sY_iGoJW3Nt_g
  • 分享码:qhs5
  • 读者评价

    对jdk自带的线程工具和核心类都有使用和原理性的说明,入门宝典

    Java的线程API和并发工具类,是Java自身强大而富有挑战性的API及语言特性的一部分。Java新手往往很难用这些特性编写出正确的多线程应用程序。本书旨在帮助Java开发者掌握并高效地使用这些功能。

    编辑推荐

    Java的线程API和并发工具类,是Java自身强大而富有挑战性的API及语言特性的一部分。Java新手往往很难用这些特性编写出正确的多线程应用程序。本书旨在帮助Java开发者掌握并高效地使用这些功能。
    本书分为两个部分,每部分包含4个章节。 第1部分关注于底层的线程API,而第2部分则关注于高级的并发工具类。第1部分介绍线程API的基础知识、同步、等待 通知以及线程组的额外能力,还有线程局部变量和定时器框架。第2部分介绍并发工具类的基础知识、Executor、同步器、锁框架,以及并发集合的额外能力、原子变量、Fork Join框架和Completion Service。每一章节后都给出了一些练习题。这些练习题旨在测试你对章节内容的理解程度。附录A提供这些习题的答案。附录B介绍了如何在Swing图形用户接口工具集(Swing Graphical User Interface Tookit)中使用线程。

    通过本书,你将学习:

    ● 创建、配置并启动运行runnable的线程;
    ● 同步共享代码以避免竞态条件、数据竞争以及
    其他并发问题;
    ● 避免缓存变量引发的问题;
    ● 使用等待 通知机制协调多条线程;
    ● 探索线程组并学习避免使用它们的原因;
    ● 学习线程局部变量;
    ● 探索定时器框架;
    ● 学习引入并发工具类的原因;
    ● 探索Executor、同步器以及锁框架;
    ● 探索并发集合、原子变量、Fork Join框架以及Completion Service;
    ● 实验Sw i ng中的线程使用方式及其线程相关的API。

    内容介绍

    Java线程和并发工具是应用开发中的重要部分,备受开发者的重视,也有一定的学习难度。 《Java线程与并发编程实践》是针对Java 8中的线程特性和并发工具的快速学习和实践指南。全书共8章,分别介绍了Thread类和Runnable接口、同步、等待和通知、线程组、定时器框架、并发工具、同步器、锁框架,以及高级并发工具等方面的主题。每章的末尾都以练习题的方式,帮助读者巩固所学的知识。附录A给出了所有练习题的解答,附录B给出了一个基于Swing线程的教程。 《Java线程与并发编程实践》适合有一定基础的Java程序员阅读学习,尤其适合想要掌握Java线程和并发工具的读者阅读参考。

    内容节选

    Java多线程中线程的两种创建方式及比较代码示例

    1.线程的概念:线程(thread)是指一个任务从头至尾的执行流,线程提供一个运行任务的机制,对于java而言,一个程序中可以并发的执行多个线程,这些线程可以在多处理器系统上同时运行。当程序作为一个应用程序运行时,java解释器为main()方法启动一个线程。

    2.并行与并发:

    (1)并发:在单处理器系统中,多个线程共享CPU时间,而操作系统负责调度及分配资源给它们。

    (2)并行:在多处理器系统中,多个处理器可以同时运行多个线程,这些线程在同一时间可以同时运行,而不同于并发,只能多个线程共享CPU时间,同一时间只能运行一个线程。

    3.线程的创建:

    (1)基础概念:java中每个任务就是一个可运行对象,为了创建任务,必须首先定义任务类,任务类必须实现Runnable接口。而线程本质上讲就是便于任务执行的对象。一个线程的执行过程就是一个任务类中run()方法的执行到结束。

    (2)通过Runnable接口创建线程:

      a.定义一个任务类实现Runnable接口,实现Runnable接口中的run()方法(run()方法告知系统线程该如何运行),run()方法中定义具体的任务代码或处理逻辑。

      b.定义了任务类后,为任务类创建一个任务对象。

      c.任务必须在线程中执行,创建一个Tread类的对象,将前面创建的实现了Runnable接口的任务类对象作为参数传递给Tread类的构造方法。

      d.调用Tread类对象的start()方法,启动一个线程。它会导致任务的run()方法被执行,当run()方法执行完毕,则线程就终止。

      实例代码:

    package com.muzeet.mutithread;
    
    //每个任务都是Runable接口的一个实例,任务是可运行对象,线程是便于任务执行的对象。必须创建任务类,重写run方法定义任务
    public class ThreadDemo1 implements Runnable {
     private int countDown = 10;
     @Override
     //重写run方法,定义任务
     public void run() {
      while(countDown-- >0)
      {
       System.out.println("$" + Thread.currentThread().getName() 
         + "(" + countDown + ")");
      }
     }
     //调用start方法会启动一个线程,导致任务中的run方法被调用,run方法执行完毕则线程终止
     
     public static void main(String[] args) {
      Runnable demo1 = new ThreadDemo1();
      
      Thread thread1 = new Thread(demo1);
      Thread thread2 = new Thread(demo1);
      thread1.start();
      thread2.start();
      
      System.out.println("火箭发射倒计时:");  
     }
    
    }

    程序运行结果:

    火箭发射倒计时:
    $Thread-0(9)
    $Thread-0(8)
    $Thread-0(7)
    $Thread-0(6)
    $Thread-0(5)
    $Thread-0(4)
    $Thread-0(3)
    $Thread-0(2)
    $Thread-0(1)
    $Thread-0(0)

    同时运行两个任务对象:

    public static void main(String[] args) {
      Runnable demo1 = new ThreadDemo1();
      Runnable demo2 = new ThreadDemo1();
      Thread thread1 = new Thread(demo1);
      Thread thread2 = new Thread(demo2);
      thread1.start();
      thread2.start();
      
      System.out.println("火箭发射倒计时:"); 
     }

     运行结果:

    火箭发射倒计时:
    $Thread-0(9)
    $Thread-0(8)
    $Thread-0(7)
    $Thread-0(6)
    $Thread-1(9)
    $Thread-0(5)
    $Thread-1(8)
    $Thread-0(4)
    $Thread-1(7)
    $Thread-0(3)
    $Thread-1(6)
    $Thread-1(5)
    $Thread-0(2)
    $Thread-1(4)
    $Thread-1(3)
    $Thread-1(2)
    $Thread-1(1)
    $Thread-1(0)
    $Thread-0(1)
    $Thread-0(0)

    (3)继承Thread类来创建线程: 

      a.首先创建一个任务类extends Thread类,因为Thread类实现了Runnable接口,所以自定义的任务类也实现了Runnable接口,重新run()方法,其中定义具体的任务代码或处理逻辑。

      b.创建一个任务类对象,可以用Thread或者Runnable作为自定义的变量类型。

      c.调用自定义对象的start()方法,启动一个线程。

      示例代码:

    package com.muzeet.mutithread;
    
    //每个任务都是Runable接口的一个实例,任务是可运行对象,线程即可运行对象。必须创建任务类,重写run方法定义任务
    public class ExtendFromThread extends Thread {
     private int countDown = 10;
     @Override
     //重写run方法,定义任务
     public void run() {
      while(countDown-- >0)
      {
       System.out.println("$" + this.getName() 
         + "(" + countDown + ")");
      }
     }
     //调用start方法会启动一个线程,导致任务中的run方法被调用,run方法执行完毕则线程终止
     
     public static void main(String[] args) {
      
      ExtendFromThread thread1 = new ExtendFromThread();
      ExtendFromThread thread2 = new ExtendFromThread();
      thread1.start();
      thread2.start();
      
      System.out.println("火箭发射倒计时:"); 
     }
    
    }

    运行结果: 

    火箭发射倒计时:
    $Thread-0(9)
    $Thread-0(8)
    $Thread-0(7)
    $Thread-0(6)
    $Thread-0(5)
    $Thread-0(4)
    $Thread-0(3)
    $Thread-0(2)
    $Thread-0(1)
    $Thread-0(0)
    $Thread-1(9)
    $Thread-1(8)
    $Thread-1(7)
    $Thread-1(6)
    $Thread-1(5)
    $Thread-1(4)
    $Thread-1(3)
    $Thread-1(2)
    $Thread-1(1)
    $Thread-1(0)

    一个线程等待另一个线程结束后再执行:当执行PrintNum这个任务时,打印到数字50时,转而去执行打印字符C这个任务,知道线程thread4执行完才继续执行打印数字任务。

    package com.muzeet.testThread;
    
    public class PrintNum implements Runnable {
    
     private int lastNum;
     
     public PrintNum(int n)
     {
      lastNum = n;
     }
    
     @Override
     public void run() {
      // TODO Auto-generated method stub
      Thread thread4 = new Thread(new PrintChar('c', 40));
      thread4.start();
      try {
      for(int i=1;i<=lastNum;i++)
      {
       System.out.println(" " + i);
       if(i == 50)
       {
      thread4.join();
        
       }
      }
      } catch (InterruptedException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
      }
     }
     
    }

    4.两种方法的比较(转载)

    首先分析两种方式的输出结果,同样是创建了两个线程,为什么结果不一样呢?

    使用实现Runnable接口方式创建线程可以共享同一个目标对象(TreadDemo1tt=newTreadDemo1();),实现了多个相同线程处理同一份资源。当第一个线程执行完任务后,countDown已经为0,所以第二个线程就不会输出。而继承Thread创建线程的方式,new出了两个任务类对象,有各自的成员变量,相互之间不干扰。

    然后再看一段来自JDK的解释:

    Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run的无参数方法。

    设计该接口的目的是为希望在活动时执行代码的对象提供一个公共协议。例如,Thread类实现了Runnable。激活的意思是说某个线程已启动并且尚未停止。

    此外,Runnable为非Thread子类的类提供了一种激活方式。通过实例化某个Thread实例并将自身作为运行目标,就可以运行实现Runnable的类。大多数情况下,如果只想重写run()方法,而不重写其他Thread方法,那么应使用Runnable接口。这很重要,因为除非程序员打算修改或增强类的基本行为,否则不应为该类创建子类。(推荐使用创建任务类,并实现Runnable接口,而不是继承Thread类)

    采用继承Thread类方式:

    (1)优点:编写简单,如果需要访问当前线程,无需使用Thread.currentThread()方法,直接使用this,即可获得当前线程。

    (2)缺点:因为线程类已经继承了Thread类,所以不能再继承其他的父类。

    采用实现Runnable接口方式:

    (1)优点:线程类只是实现了Runable接口,还可以继承其他的类。在这种方式下,可以多个线程共享同一个目标对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。

    (2)缺点:编程稍微复杂,如果需要访问当前线程,必须使用Thread.currentThread()方法。

    目录

    • 第一部分 线程API
    • 第1章 Thread和Runnable 2
    • 第2章 同步 26
    • 第3章 等待和通知 52
    • 第4章 额外的线程能力 67
    • 第二部分 并发工具类
    • 第5章 并发工具类和Executor框架 90
    • 第6章 同步器 106
    • 第7章 锁框架 142
    • 第8章 额外的并发工具类 167
    • 第三部分 附录
    • 附录A 练习题答案 198
    • 第1章:Thread和Runnable 198
    • 第2章:同步 201
    • 第3章:等待和通知 205
    • 第4章:额外的线程能力 208
    • 第5章:并发工具类和Executor框架 211
    • 第6章:同步器 215
    • 第7章:锁框架 220
    • 第8章:额外的并发工具 222
    • 附录B Swing中的线程 225
    • 单线程编程模型 225
    • 线程化API 231
    • SwingUtilities和EventQueue 231
    • SwingWorker 240
    • 定时器 245
    • 基于定时器的幻灯片展示 249

    上一篇:Python金融实战(严玉星)  下一篇:跟兄弟连学PHP

    展开 +

    收起 -

    码小辫二维码
     ←点击下载即可登录

    Java相关电子书
    学习笔记

    Copyright 2018-2019 xz577.com 码农之家

    版权责任说明