Java多线程01(Thread类、线程建立、线程池)

时间 2019-12-11

标签 java 多线程 thread 线程建立栏目 Java 繁體版

原文原文链接

Java多线程(Thread类、线程建立、线程池)

第一章多线程

1.1 多线程介绍

1.1.1 基本概念

进程：进程指正在运行的程序。确切的来讲，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程当中的程序，而且具备必定独立功能。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是能够有多个线程的，这个应用程序也能够称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中能够包含多个线程

1.1.2 单线程程序

从入口main到结束，一条路走到底
- 好处：没有安全隐患
- 缺点：效率低
- 解决缺点：让方法一同运行起来，为程序开启多个执行的路，每一个执行的路，成为线程。
- 示例代码：
```
public static void main(String[] args){
    add();
    remove();
    get();
    System.out.println(222);
}

public static void add(){
    // 一万次循环
}
public static void remove(){
}
public static void get(){
}
```

1.1.3 深刻理解多线程

CPU中央处理器
- Inter AMD
- Inter Core i7 6680M
- 四核心，八线程
- 执行多线程时，每一个功能均可以单独执行，开启功能，对CPU开启新的执行路径。
- 线程深刻理解：每一个功能对于CPU的独立执行路径，就是线程。
网上下载一个软件：
- 下载的流程：
- 单线程下载：一次读取n个字节
  - 浏览器下载：（IE）写一个，读一个，写一个，读一个
- 多线程下载：一次读取m*m个字节，多(m)个线程读取同一个文件
  - 迅雷：开启一个线程，读取其中的一部分，再开启一个线程再读取一部分，...

1.2 程序运行原理

分时调度：
- 全部线程轮流使用 CPU 的使用权，平均分配每一个线程占用 CPU 的时间。
抢占式调度：
- 优先让优先级高的线程使用 CPU，若是线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

抢占式调度详解

大部分操做系统都支持多进程并发运行，如今的操做系统几乎都支持同时运行多个程序。好比：如今咱们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板， dos窗口等软件。此时，这些程序是在同时运行，”感受这些软件好像在同一时刻运行着“。
实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对咱们的感受要快，看上去就是在同一时刻运行。
其实，多线程程序并不能提升程序的运行速度，但可以提升程序运行效率，让CPU的使用率更高。java

1.3 主线程

代码示例：浏览器

public class Demo {
    public static void main(String[] args) {
    fun();
    System.out.println(Math.abs(-9));
}
public static void fun() {
    for(int i=0;i<10000; i++) {
        System.out.println(i);
    }
}
}

分析：
- 程序：从上到下的执行过程
- 在dos窗口中：java Demo
- 启动JVM，运行Demo.main
- JVM 运行方法main，操做系统开启线程
- 对于CPU有了一个执行的路径，运行方法main路径，有个名字“main”
- 主线程：
思考：
- 可否实现一个主线程负责执行其中一个循环，再由另外一个线程负责其余代码的执行，最终实现多部分代码同时执行的效果？
- 可以实现同时执行，经过Java中的多线程技术来解决该问题。

1.4 Thread类

经过API中搜索，查到Thread类。经过阅读Thread类中的描述。Thread是程序中的执行线程。Java 虚拟机容许应用程序并发地运行多个执行线程。
线程是程序中执行的线程。 Java虚拟机容许应用程序同时运行多个执行线程。
每一个线程都有优先权。具备较高优先级的线程优先于具备较低优先级的线程执行。每一个线程可能也可能不会被标记为守护进程。
当在某个线程中运行的代码建立一个新的Thread对象时，新线程的优先级最初设置为等于建立线程的优先级，而且当且仅当建立线程是守护进程时才是守护进程线程。安全

经常使用构造方法多线程

Thread()
    Allocates a new Thread object. 
Thread(Runnable target) 
    Allocates a new Thread object. 
Thread(Runnable target, String name)
    Allocates a new Thread object. 
Thread(String name) 
    Allocates a new Thread object.

经常使用方法并发
- void run()
  - If this thread was constructed using a separate Runnable run object, then that Runnable object's run method is called; otherwise, this method does nothing and returns.
- static void sleep(long millis)
  - Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds, subject to the precision and accuracy of system timers and schedulers.
- void start()
  - Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread.

建立新执行线程有两种方法：

一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。建立对象，开启线程。run方法至关于其余线程的main方法。异步

```
  class PrimeThread extends Thread {
      long minPrime;
      PrimeThread(long minPrime) {
          this.minPrime = minPrime;
      }
      public void run() {
          // compute primes larger than minPrime
          . . .
      }
  }

```jvm

另外一种方法是声明一个实现 Runnable 接口的类。该类而后实现 run 方法。而后建立Runnable的子类对象，传入到某个线程的构造方法中，开启线程。编辑器

class PrimeRun implements Runnable {
        long minPrime;
        PrimeRun(long minPrime) {
            this.minPrime = minPrime;
        }
        public void run() {
            // compute primes larger than minPrime
            . . .
        }
    }

1.5 建立新执行线程方法一：继承Thread类

建立线程的步骤：
1. 定义一个类继承Thread。
2. 重写run方法。
3. 建立子类对象，就是建立线程对象。
4. 调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。

代码示例：ide

public class SubThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<50; i++) {
            System.out.println("run方法中的变量："+i);
        }       
    }
}

public class ThreadDemo {   
    public static void main(String[] args) {   // 一、JVM从入口main开始执行主线程，从CPU开启第一条线程路径，执行main()方法。
        SubThread subThread = new SubThread();    // 二、建立线程对象，至关于开启了一个新的线程，从CPU开启第二条线程路径，执行run()方法。
        subThread.start();   // 三、执行start方法时，调用run()方法，与main()方法同时要调用CPU，两个执行路径都会被CPU执行，CPU本身选择的权利，出现执行结果，随机性结果。
        for(int i=0; i<50; i++) {
            System.out.println("main方法中的变量："+i);
        }
    }
}

1.5.1 继承Thread类原理

思考1：线程对象调用 run方法和调用start方法区别？
- 线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。
思考2：咱们为何要继承Thread类，并调用其的start方法才能开启线程呢？
- 继承Thread类：由于Thread类用来描述线程，具有线程应该有功能。
思考3：那为何不直接建立Thread类的对象呢？以下代码：
Thread t1 = new Thread();t1.start();
- 这样作没有错，可是该start调用的是Thread类中的run方法，而这个run方法没有作什么事情，更重要的是这个run方法中并无定义咱们须要让线程执行的代码。
思考4：建立线程的目的是什么？
- 是为了创建程序单独的执行路径，让多部分代码实现同时执行。也就是说线程建立并执行须要给定线程要执行的任务。
- 对于以前所讲的主线程，它的任务定义在main函数中。自定义线程须要执行的任务都定义在run方法中。
思考5：为何要重写run方法
- Thread类run方法中的任务并非咱们所须要的，只有重写这个run方法。既然Thread类已经定义了线程任务的编写位置（run方法），那么只要在编写位置（run方法）中定义任务代码便可。因此进行了重写run方法动做。

1.5.2 线程运行时的内存状况

单线程：全部执行的方法都在一个栈中，后调用的方法先执行，执行结束后弹出；
多线程：每调用一个线程，就分配一个栈区，例如：main和run方法分别属于不一样的栈区，CPU执行时，随机选择执行一个栈区中的方法。

1.5.3 获取线程名字Thread类方法getName()

Java API 中函数

String getName()  // 返回线程的名字 
static Thread currentThread()  // 获取当前线程

示例：

public class NameThread extends Thread {
    @Override
    public void run() {
        System.out.println(super.getName());  // 输出本线程的名字
    }
}

/*
 * 每一个线程都有本身的名字
 * 运行方法main线程的名字是"main"
 * 其余线程也有名字，默认为"Thread-0","Thread-1", ...
 * 得到主线程的名字的方法：JVM开启主线程，运行方法main，主线程也是线程，是线程必然是Thread类的对象，Thread类中的静态方法：
 *  static Thread currentThread() 返回正在执行的线程对象
 *  该对象调用getName方法，获取线程名字
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        NameThread nameThread = new NameThread();
        nameThread.start();

        // 获取主线程的线程名
        System.out.println(Thread.currentThread().getName());
    }
}

1.5.3 设置线程名字Thread类方法

Java API 中

Thread(String name)  // 分配一个新的名字为name的对象
void setName(String name) // 改变线程的名字为name

方法一：

// 在主线程中
NameThread nameThread = new NameThread();
nameThread.setName("Thread线程名字");

方法二：

// 在建立的线程类中的run方法中，调用Thread父类构造函数
super("Thread线程名字");

1.5.4 Thread类方法sleep()

位置：能够写在main方法中，也能够写在Thread类中。

代码：

public class SleepThread extends Thread{    
    @Override
    public void run() {
        for(int i=0; i<5; i++) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        SleepThread sleepThread = new SleepThread();
        sleepThread.start();
        Thread.sleep(2000);
    }
}

1.6 建立新执行线程方法二：实现Runnable接口

建立线程的另外一种方法是声明实现 Runnable 接口的类。该类而后实现 run 方法。而后建立Runnable的子类对象，传入到某个线程的构造方法中，开启线程。
为什么要实现Runnable接口，Runable是啥玩意呢？继续API搜索。
查看Runnable接口说明文档：Runnable接口用来指定每一个线程要执行的任务。包含了一个 run 的无参数抽象方法，须要由接口实现类重写该方法。

Java API 中

// Runnable接口中只有一个run方法
// 方法摘要
void run() // 当使用实现接口Runnable的对象来建立线程时，启动该线程会致使在该单独执行的线程中调用该对象的run方法。

// 建立线程使用Thread类中的构造方法：
Thread(Runnable target)  // 分配一个线程对象，参数为Runnable接口实现类的对象

建立线程的步骤。
1. 定义类实现Runnable接口。
2. 覆盖接口中的run方法。。
3. 建立Thread类的对象
4. 将Runnable接口的子类对象做为参数传递给Thread类的构造函数。
5. 调用Thread类的start方法开启线程。

示例：

public class SubRunnable implements Runnable{
    @Override
    public void run() {
        for(int i=0; i<50; i++) {
            System.out.println("run..."+i);
        }       
    }
}

/**
 * 实现接口方式的线程
 * 建立Thread类对象，构造方法中，传递Runnable接口实现类对象
 * 调用Thread类的方法start
 */
public class RunnableDemo {
    public static void main(String[] args) {
        SubRunnable subRunnable = new SubRunnable();
        Thread t = new Thread(subRunnable);
        t.start();  
        for(int i=0; i<50; i++) {
            System.out.println("main..."+i);
        }
    }
}

1.6.1 实现Runnable接口的原理

思考：为何须要定一个类去实现Runnable接口呢？继承Thread类和实现Runnable接口有啥区别呢？
- 实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。
- 建立Thread类的对象，只有建立Thread类的对象才能够建立线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，因此将这个子类对象做为参数传递给Thread的构造函数，这样，线程对象建立时就能够明确要运行的线程的任务。

1.6.2 实现Runnable的好处

避免局限性、解耦合、资源共享
第二种方式实现Runnable接口避免了单继承的局限性，因此较为经常使用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一块儿。一旦建立Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

1.7 线程的匿名内部类使用

使用线程的内匿名内部类方式，能够方便的实现每一个线程执行不一样的线程任务操做。
- 方式1：建立线程对象时，直接重写Thread类中的run方法
- 方式2：使用匿名内部类的方式实现Runnable接口，从新Runnable接口中的run方法

1.8 线程状态(6种)

线程状态。线程能够处于如下状态之一：
- new：还没有启动的线程处于此状态。
- runnable：在Java虚拟机中执行的线程处于此状态。
- blocked：被阻塞等待监视器锁定的线程处于此状态。
- wait：无限期等待另外一个线程执行特定操做的线程处于此状态。
- timed_waiting：正在等待另外一个线程执行最多指定等待时间的操做的线程处于此状态。
- terminated：已退出的线程处于此状态。
线程在给定时间点只能处于一种状态。这些状态是虚拟机状态，不反映任何操做系统线程状态。

线程状态图：

第二章线程池

2.1 线程池概念

2.1.1 线程池，其实就是一个容纳多个线程的容器，其中的线程能够反复使用，省去了频繁建立线程对象的操做，无需反复建立线程而消耗过多资源。

线程池示意图：

2.1.2 为何要使用线程池？

- 在java中，若是每一个请求到达就建立一个新线程，开销是至关大的。在实际使用中，建立和销毁线程花费的时间和消耗的系统资源都至关大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了建立和销毁线程的开销以外，活动的线程也须要消耗系统资源。若是在一个JVM里建立太多的线程，可能会使系统因为过分消耗内存或“切换过分”而致使系统资源不足。为了防止资源不足，须要采起一些

办法来限制任何给定时刻处理的请求数目，尽量减小建立和销毁线程的次数，特别是一些资源耗费比较大的线程的建立和销毁，尽可能利用已有对象来进行服务。
- 线程池主要用来解决线程生命周期开销问题和资源不足问题。经过对多个任务重复使用线程，线程建立的开销就被分摊到了多个任务上了，并且因为在请求到达时线程已经存在，因此消除了线程建立所带来的延迟。这样，就能够当即为请求服务，使用应用程序响应更快。另外，经过适当的调整线程中的线程数目能够防止出现资源不足的状况。

2.1.3 线程池原理

本身建立线程池（伪代码示例）

ArrayList<Thread> threads = new ArrayList<Thread>();
threads.add(new Thread());
threads.add(new Thread());
threads.add(new Thread());
threads.add(new Thread());
threads.add(new Thread());
threads.add(new Thread());
threads.add(new Thread());
threads.add(new Thread());
threads.add(new Thread());
threads.add(new Thread());

// 程序一开始的时候，建立多个线程对象，存储到集合中，须要线程，从集合中获取线程出来
Thread t = threads.remove(0);
// 使用线程
t.start();
// 线程用完，回到容器中继续等待使用
threads.add(t);

从JDK5开始，内置线程池技术，不须要本身建立，直接使用便可。

2.2 使用线程池

2.2.1 使用线程池方式--Runnable接口

一般，线程池都是经过线程池工厂建立，再调用线程池中的方法获取线程，再经过线程去执行任务方法。
- Executors：线程池建立工厂类
- public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象
- ExecutorService：线程池类
- Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行
- Future接口：用来记录线程任务执行完毕后产生的结果。线程池建立与使用
使用线程池中线程对象的步骤：
- 建立线程池对象
- 建立Runnable接口子类对象
- 提交Runnable接口子类对象
- 关闭线程池

示例：

public class ThreadPoolRunnable implements Runnable{
    @Override
    public void run() {     
        System.out.println(new Thread().getName());
    }
}


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*
 * JDK1.5以后的新特性，实现线程池程序
 *  一、使用工厂类，Executors中的静态方法建立线程对象，指定线程个数
 *  二、static ExecutorsService newFixedThreadPool(int 线程个数)   返回线程池对象
 *  三、返回的是 ExecutorsService接口的实现类（线程池对象）
 *  四、接口实现类对象，调用方法submit(Runnable r) 提交线程，执行任务
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 调用工厂类的静态方法，建立线程池对象
        // Executors.newFixedThreadPool(2);返回线程池对象，是接口的实现类对象
        ExecutorService es = Executors.newFixedThreadPool(2);
        // 调用接口实现类对象es的方法submit，提交一个线程任务
        es.submit(new ThreadPoolRunnable());
        es.submit(new ThreadPoolRunnable());
        es.submit(new ThreadPoolRunnable());
    }
}

Runnable接口的缺陷
- 线程运行完没有结果
- 不能抛出异常

2.2.2 使用线程池方式—Callable 接口

Callable接口与Runnable接口功能类似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。
- ExecutorService：线程池类
- <T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的call()方法
- Future接口：用来记录线程任务执行完毕后产生的结果。线程池建立与使用
使用线程池中线程对象的步骤：
- 建立线程池对象
- 建立Callable接口子类对象
- 提交Callable接口子类对象
- 关闭线程池

示例：

import java.util.concurrent.Callable;

public class ThreadPoolCallable implements Callable<String>{
    @Override
    public String call() throws Exception {
        return "abc";
    }
}

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService es = Executors.newFixedThreadPool(2);
        // 提交任务的方法，返回Future接口的实现类
        Future<String> f = es.submit(new ThreadPoolCallable());
        String s = f.get();
        System.out.println(s);
    }
}

2.3 线程池练习：返回多个数相加的结果

```
import java.util.concurrent.Callable;
/*
 * 多线程的异步计算
 * 
 */
public class GetSumCallable implements Callable<Integer>{
    private int a;
    public GetSumCallable(int a) {
        this.a = a;
    }
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for(int i=0; i<=a; i++) {
            sum += i;
        }
        return sum;
    }   
}

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService es = Executors.newFixedThreadPool(2);
        Future<Integer> f1 = es.submit(new GetSumCallable(100));  // 加法
        Future<Integer> f2 = es.submit(new GetSumCallable(200));  // 减法
        System.out.println("1+2+...+100 = "+f1.get());
        System.out.println("1+2+...+200 = "+f2.get());
        es.shutdown();
    }
}
```

第三章总结

建立线程的方式

方式1，继承Thread线程类
- 步骤
  - 自定义类继承Thread类
  - 在自定义类中重写Thread类的run方法
  - 建立自定义类对象(线程对象)
  - 调用start方法，启动线程，经过JVM，调用线程中的run方法
方式2，实现Runnable接口
- 步骤
  - 建立线程任务类实现Runnable接口
  - 在线程任务类中重写接口中的run方法
  - 建立线程任务类对象
  - 建立线程对象，把线程任务类对象做为Thread类构造方法的参数使用
  - 调用start方法，启动线程，经过JVM，调用线程任务类中的run方法
方式3，实现Callable接口
- 步骤
  - 工厂类Executors静态方法newFixedThreadPool方法，建立线程对象
  - 线程池对象ExecutorService接口实现类，调用方法submit提交线程任务：submit(Callable c)