多线程快速入门

蔚落 2021-09-14 04:30 307阅读 0赞

### 文章目录 ###

*   *  线程介绍
     *  线程的意义
     *   *  线程相比进程的优点:
         *  使用多线程的影响:
     *  线程创建方式
     *   *  1、继承Thread类创建线程
         *  2、实现Runnable接口创建线程
         *  3、 使用Callable和Future创建线程
         *  4、 使用线程池Executor框架
     *  启动线程
     *  守护线程
     *  多线程运行状态
     *   *  新建状态
         *  就绪状态
         *  运行状态
         *  阻塞状态
         *  死亡状态
     *  线程的常用方法
     *   *  join()方法作用
         *  优先级
         *  Yield方法
     *  线程间的通信
     *  面试题

## 线程介绍 ##

线程（thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。

每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。线程是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行。也可以把它理解为代码运行的上下文。所以线程基本上是轻量级的进程，它负责在单个程序里执行多任务。通常由操作系统负责多个线程的调度和执行。  
一个进程可以有很多线程，每条线程并行执行不同的任务。

总结:进程是所有线程的集合，每一个线程是进程中的一条执行路径。

## 线程的意义 ##

为了解决负载均衡问题,充分利用CPU资源.为了提高CPU的使用率,采用多线程的方式去同时完成几件事情而不互相干扰.为了处理大量的IO操作时或处理的情况需要花费大量的时间等等,比如:读写文件,视频图像的采集,处理,显示,保存等

### 线程相比进程的优点: ###

1.  线程在程序中是独立的，并发的执行流，但是，与分隔的进程相比，进程中的线程之间的隔离程度要小。它们共享内存，文件句柄和其他每个进程应有的状态。
2.  线程比进程具有更高的性能，这是由于同一个进程中的线程都有共性:多个线程将共享同一个进程虚拟空间。线程共享的环境包括：进程代码段，进程的公有数据等。利用这些共享的数据等,线程很容易实现相互之间的通信。
3.  当操作系统创建一个进程时，必须为进程分配独立的内存空间，并分配大量相关资源：但创建一个线程则简单很多，因此使用多线程来实现并发比使用多进程实现并发

### 使用多线程的影响: ###

1.  cpu在多个线程之间进行切换会牺牲一部分性能.
2.  创建线程需要占用一定的内存空间
3.  线程之间共享数据会产生线程安全问题
4.  线程竞争资源会导致死锁

## 线程创建方式 ##

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。  
Java可以以下四种方式来创建线程：

1.  继承Thread类创建线程
2.  实现Runnable接口创建线程
3.  使用Callable和Future创建线程
4.  使用线程池Executor框架

### 1、继承Thread类创建线程 ###

通过继承Thread类来创建并启动多线程的一般步骤如下

1.  定义Thread类的子类，并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。
2.  创建Thread子类的实例，也就是创建了线程对象

public class ThreadExt extends Thread{ 
    
        @Override
        public void run() { 
            for(int i = 0;i<10;i++){ 
                System.out.println(Thread.currentThread().getName() + " : " + i);
            }
        }
    
        public static void main(String[] args) { 
            Thread thread = new ThreadExt();
            thread.start();
        }
    }

### 2、实现Runnable接口创建线程 ###

通常推荐使用实现Runnable接口创建线程的方式，原因是一个类实现了接口还可以继续继承，继承了Thread类则不能再继承其它类了。

通过实现Runnable接口创建并启动线程一般步骤如下：

1.  定义Runnable接口的实现类，一样要重写run()方法，这个run（）方法和Thread中的run()方法一样是线程的执行体
2.  创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象

public class RunnableImpl implements Runnable{ 
        @Override
        public void run() { 
            for(int i = 0;i<10;i++){ 
                System.out.println(Thread.currentThread().getName() + " : " + i);
            }
        }
    
        public static void main(String[] args) { 
            //将实现Runnable接口的类传入Thread构造器创建，推荐使用此方式
            Thread thread = new Thread(new RunnableImpl());
            //当然你也可以使用匿名内部类的形式实现Runnable接口,一般不推荐这么做
            thread = new Thread(()->{ 
                for(int i = 0;i<10;i++){ 
                    System.out.println(Thread.currentThread().getName() + " : " + i);
                }
            });
            //
            thread.start();
        }
    }

### 3、 使用Callable和Future创建线程 ###

和Runnable接口不一样，Callable接口提供了一个call（）方法作为线程执行体，call()方法比run()方法功能要强大。

Java5提供了Future接口来代表Callable接口里call()方法的返回值，并且为Future接口提供了一个实现类FutureTask，这个实现类既实现了Future接口，还实现了Runnable接口，因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。

1.  创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表达式创建Callable对象）。
2.  使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值
3.  使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口）
4.  调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

public class CallableImpl implements Callable {
    
        // 与run()方法不同的是，call()方法具有返回值
        @Override
        public Integer call() throws InterruptedException {
            int sum = 0;
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + " : " + i);
                sum += i;
            }
            Thread.sleep(3000);   //计算完成sum后，我们让线程休眠3秒
            return sum;
        }
    
        public static void main(String[] args) {
    
            Callable<Integer> callableImpl = new CallableImpl();    // 创建CallableImpl对象
            FutureTask<Integer> ft = new FutureTask<>(callableImpl); //使用FutureTask来包装CallableImpl对象
    
            Thread thread = new Thread(ft);       //FutureTask对象作为Thread对象的target创建新的线程
            thread.start();                       //线程进入到就绪状态
    
            System.out.println("主线程for循环执行完毕..");
    
            try {
                int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果
                System.out.println("sum = " + sum);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
    
        }
    }

### 4、 使用线程池Executor框架 ###

Executor接口中之定义了一个方法execute（Runnable command），该方法接收一个Runable实例，它用来执行一个任务，任务即一个实现了Runnable接口的类。

关于线程池框架的详细介绍请参考这篇博文：[Java线程池ThreadPoolExecutor的使用及其原理][Java_ThreadPoolExecutor]

下面是一个自定义线程池的示例：

public static void main(String[] args) {
            ExecutorService threadPool = new ThreadPoolExecutor(// 自定义一个线程池
                    1, // 核心线程数
                    2, // 最大线程数
                    60, // 超过核心线程数的额外线程存活时间
                    TimeUnit.SECONDS, // 线程存活时间的时间单位
                    new ArrayBlockingQueue<>(3) // 有界队列，容量是3个
                    , Executors.defaultThreadFactory()    // 线程工厂
                    , new ThreadPoolExecutor.AbortPolicy() //线程的拒绝策略
            );
            //执行一个任务
            threadPool.execute(()->{
                //线程执行的具体逻辑
                //Runnable to do something.
                System.out.println("hello world");
            });
            threadPool.shutdown();
            threadPool.shutdownNow();
        }

## 启动线程 ##

*  使用`start()`方法开始执行线程
 *  注意开启线程不是调用`run()`方法，直接使用`run()`方法相当于在当前线程下执行了

其中`start()`方法原码如下

/**
     	*使该线程开始执行；Java虚拟机调用此线程的run方法。
     	*结果是两个线程同时运行：
     	*当前线程（执行start方法）和另一个线程（执行其run方法）。
     	*多次启动线程是不合法的。
    	 *特别是，线程一旦完成就不能重新启动执行。
    	**/
        public synchronized void start() {
       		 /**
       	 	 *0状态值对应于状态“NEW”。
        	 */
            if (threadStatus != 0)
                throw new IllegalThreadStateException();
    
            /*通知组此线程即将启动
    		*以便将其添加到组的线程列表中
    		*组的未开始计数可以减少*/
            group.add(this);
    
            boolean started = false;
            try {
                start0();
                started = true;
            } finally {
                try {
                    if (!started) {
                        group.threadStartFailed(this);
                    }
                } catch (Throwable ignore) {
                    /* do nothing. If start0 threw a Throwable then
                      it will be passed up the call stack */
                }
            }
        }
    
        private native void start0();

## 守护线程 ##

Java中有两种线程，一种是用户线程，另一种是守护线程。

*  用户线程是指用户自定义创建的线程，主线程停止，用户线程不会停止守护线程
 *  当进程不存在或主线程停止，守护线程也会被停止。

使用setDaemon(true)方法设置为守护线程

## 多线程运行状态 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2MxNTE1ODAzMjMxOQ_size_16_color_FFFFFF_t_70]

线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。

### 新建状态 ###

当用new操作符创建一个线程时， 例如new Thread()，线程还没有开始运行，此时线程处在新建状态。  
线程中的代码此时并未被执行。

### 就绪状态 ###

一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。

处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由[Java][]运行时系统的线程调度程序(*thread scheduler*)来调度的。

### 运行状态 ###

当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法.

### 阻塞状态 ###

线程运行过程中，可能由于各种原因进入阻塞状态:

1.  线程通过调用sleep方法进入睡眠状态；
2.  线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
3.  线程试图得到一个锁，而该锁正被其他线程持有；
4.  线程在等待某个触发条件；

### 死亡状态 ###

有两个原因会导致线程死亡：

*  run方法正常退出而自然死亡，
 *  一个未捕获的异常终止了run方法而使线程猝死。

为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true；  
如果线程仍旧是new状态且不是可运行的， 或者线程死亡了，则返回false.

## 线程的常用方法 ##

<table> 
 <thead> 
  <tr> 
   <th><strong>常用线程api方法</strong></th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>start()</td> 
   <td>启动线程</td> 
  </tr> 
  <tr> 
   <td>currentThread()</td> 
   <td>获取当前线程对象</td> 
  </tr> 
  <tr> 
   <td>getID()</td> 
   <td>获取当前线程ID Thread-编号 该编号从0开始</td> 
  </tr> 
  <tr> 
   <td>getName()</td> 
   <td>获取当前线程名称</td> 
  </tr> 
  <tr> 
   <td>sleep(long mill)</td> 
   <td>休眠线程，单位毫秒</td> 
  </tr> 
  <tr> 
   <td>stop（）</td> 
   <td>停止线程,</td> 
  </tr> 
  <tr> 
   <td><strong>常用线程构造函数</strong></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>Thread（）</td> 
   <td>分配一个新的 Thread对象。自动生成的名称的格式为“Thread-”+n，其中n是整数。</td> 
  </tr> 
  <tr> 
   <td>Thread（String name）</td> 
   <td>分配一个新的 Thread对象，指定线程名称name。</td> 
  </tr> 
  <tr> 
   <td>Thread（Runable r）</td> 
   <td>分配一个新的 Thread对象</td> 
  </tr> 
  <tr> 
   <td>Thread（Runable r, String name）</td> 
   <td>分配一个新的 Thread对象 指定线程名称name</td> 
  </tr> 
 </tbody> 
</table>

### join()方法作用 ###

当在当前线程中执行到t1.join()方法时，就认为当前线程会把把执行权让给t1

public static void main(String[] args) {
            Thread t1 = new Thread(() ->{ System.out.println(Thread.currentThread().getName()); },"t1");
            Thread t2 = new Thread(() -> {
                try {
                    t1.join();
                } catch (Exception e) {
                    // TODO: handle exception
                }
                System.out.println(Thread.currentThread().getName());
            },"t2");
            Thread t3 = new Thread(() -> {
                try {
                    t2.join();
                } catch (Exception e) {
                    // TODO: handle exception
                }
                System.out.println(Thread.currentThread().getName());
            },"t3");
            t3.start();
            t2.start();
            t1.start();
        }

输出：

t1
    t2
    t3

### 优先级 ###

现代操作系统基本采用时分的形式调度运行的线程，线程分配得到的时间片的多少决定了线程使用处理器资源的多少，也对应了线程优先级这个概念。在JAVA线程中，通过一个int  
priority来控制优先级，范围为1-10，其中10最高，默认值为5。下面是源码（基于1.8）中关于priority的一些量和方法。

### Yield方法 ###

Thread.yield()方法的作用：暂停当前正在执行的线程，并执行其他线程。（可能没有效果）

yield()让当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运行的机会。因此，使用yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。但是，实际中无法保证yield()达到让步的目的，因为，让步的线程可能被线程调度程序再次选中。

结论：大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

## 线程间的通信 ##

## 面试题 ##

1.  **进程与线程的区别？**
2.  **为什么要用多线程？**
3.  **多线程创建方式？**
4.  **是继承Thread类创建线程好还是实现Runnable接口线程好？为什么？**
5.  **多线程的应用场景？**
6.  **现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行**

[Java_ThreadPoolExecutor]: https://blog.csdn.net/c15158032319/article/details/116900412
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2MxNTE1ODAzMjMxOQ_size_16_color_FFFFFF_t_70]: /images/20210606/898276e7f01d418d82241ce34e34a1ca.png
[Java]: http://lib.csdn.net/base/java