线程的基本概念 - 实现多线程的四种基本方式

谁践踏了优雅 2022-12-06 04:17 179阅读 0赞

### 文章目录 ###

*  线程概述
 *   *  进程和线程
     *  线程的生命周期
     *  线程常用方法归纳
     *  多线程的实现方法
     *   *  案例
         *   *  1. 继承Thread类，重写run方法来实现多线程
             *  2.继承Runnable接口实现多线程
             *  继承Thread类和实现Runnable接口完成多线程的区别
             *  3. 通过Callable 和 FutureTask创建线程
             *  4. 通过线程池实现多线程
     *  关于线程注意事项

# 线程概述 #

利用多线程技术可以使系统同时运行多个程序块，缩短出程序响应的时间，提高计算机资源的利用率，达到多任务处理的目的。

## 进程和线程 ##

*  **进程**是程序的一次动态执行过程，每个进程都有自己独立的内存空间。一个应用程序可以同时启动多个进程(比如浏览器可以开多个窗口，每个窗口就是一个进程)
 *  多进程操作系统能够运行多个进程，每个进程都能够**循环利用所需要的CPU时间片**，使的所有进程看上去像在**同时**运行一样。
 *  **线程**是进程的一个执行流程，一个进程可以由多个线程组成，也就是**一个进程可以同时运行多个不同的线程**，每个线程完成不同的任务。
 *  **线程的并发运行**：就是一个进程内若干个线程同时运行。(比如：word的拼写检查功能和首字母自动大写功能是word进程中的线程)
 *  **线程**和**进程**的关系是一个**局部**和**整体**的关系，每个进程都由操作系统分配独立的内存地址空间，而同一进程的所有线程都在同一地址空间工作。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center]

## 线程的生命周期 ##

一个线程的完整生命周期要经历5中状态：**新建、就绪、运行、阻塞、死亡**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 2]

*  新建状态：使用**new和某种线程的构造方法**来创建线程对象，该线程就会进入新建状态，系统为该线程对象分配内存空间。处于新建状态的线程可以通过调用\*\*start()\*\*方法进入就绪状态。
 *  就绪状态：此时线程已经具备了运行的条件，进入了线程队列，等待系统分配CPU资源，一旦获得CPU资源，该线程就会进入运行状态。
 *  运行状态：进入运行在状态，线程会执行自己的\*\*run()\*\*方法中的代码。
 *  阻塞状态：一个正在执行的线程，如果执行了**suspend、join或sleep方法**，或等待io设备的使用权，那么该线程将会让出自己的CUP控制权并暂时中止自己的执行，进入阻塞状态。阻塞的线程，不能够进入就绪队列，只有当阻塞原因被消除的时候，线程才能进入就绪状态，重新进入线程队列中排队等待CPU资源，然后继续执行。
 *  死亡状态：一个线程完成了全部工作或者被提前强制性的中止，该线程就处于死亡状态。

## 线程常用方法归纳 ##

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Thread(Runnable target)</td> 
   <td align="left">利用Runnable接口子类对象实例化Thread对象</td> 
  </tr> 
  <tr> 
   <td>Thread(Runnable target,String name)</td> 
   <td align="left">利用Runnable接口子类实例化Tread对象，并指定线程名</td> 
  </tr> 
  <tr> 
   <td>Thread(String name)</td> 
   <td align="left">实例化Thread对象，指定线程名</td> 
  </tr> 
  <tr> 
   <td>Thread currentThread()</td> 
   <td align="left">返回当前正在执行的线程</td> 
  </tr> 
  <tr> 
   <td>String getName()</td> 
   <td align="left">返回线程名</td> 
  </tr> 
  <tr> 
   <td>int getPriority()</td> 
   <td align="left">返回线程优先级</td> 
  </tr> 
  <tr> 
   <td>boolean isInterrupter()</td> 
   <td align="left">判断线程是否中断，线程中断返回true，否则返回false</td> 
  </tr> 
  <tr> 
   <td>boolean isAlive()</td> 
   <td align="left">判断线程是否活动，是返回true，否则返回false</td> 
  </tr> 
  <tr> 
   <td>final void join()</td> 
   <td align="left">强制线程运行（有些任务需要紧急运行）</td> 
  </tr> 
  <tr> 
   <td>void run()</td> 
   <td align="left">执行线程，线程执行的主要任务都写里面</td> 
  </tr> 
  <tr> 
   <td>void sleep()</td> 
   <td align="left">使正在执行的线程暂时休眠(单位 / 毫秒)，其他线程继续执行</td> 
  </tr> 
  <tr> 
   <td>interrupt()</td> 
   <td align="left">强制终端线程运行，该线程后面的方法不继续执行</td> 
  </tr> 
  <tr> 
   <td>void yield()</td> 
   <td align="left">将目前正在执行等的线程暂停，运行其他线程执行(让给其他线程执行，然后再恢复该线程)，不使线程阻塞，即线程任然处于可执行状态，随时可能再次分得CPU时间。</td> 
  </tr> 
  <tr> 
   <td>setName()</td> 
   <td align="left">设置线程名</td> 
  </tr> 
  <tr> 
   <td>setPriority(int new)</td> 
   <td align="left">设置线程优先级，MIN_PRIORITY(常量值1)最低优先级，NORM_PRIORITY(值5)中等优先级(<strong>线程的默认优先级</strong>)，MAX_PRIORITY(值10) 最高优先级</td> 
  </tr> 
  <tr> 
   <td>void start()</td> 
   <td align="left">启动线程，进入就绪队列，等待cpu资源就可以进入运行状态</td> 
  </tr> 
  <tr> 
   <td>finalv void setDaemon(boolean on)</td> 
   <td align="left">将一个线程设置成后台运行</td> 
  </tr> 
 </tbody> 
</table>

## 多线程的实现方法 ##

### 案例 ###

#### 1. 继承Thread类，重写run方法来实现多线程 ####

public class MyThread extends Thread{ 
    
        private String name;//线程名
    
        public MyThread() { 
        }
        public MyThread(String name) { 
            this.name = name;
        }
        
        //完成线程功能的主体代码都在run()方法中
        @Override
        public void run() { 
            for (int i = 0; i < 3; i++){ 
                System.out.println(name + "执行功能" + i);
            }
        }
    }

public class ThreadDemo { 
        public static void main(String[] args) { 
            //定义线程
            MyThread thread1 = new MyThread("线程A");
            MyThread thread2 = new MyThread("线程B");
            MyThread thread3 = new MyThread("线程C");
            MyThread thread4 = new MyThread("线程D");
            MyThread thread5 = new MyThread("线程E");
            MyThread thread6 = new MyThread("线程F");
    
            //调用start()方法启动线程，让其进入就绪状态，等待系统分配CPU资源进入运行状态调用run()方法
            thread1.start();
            thread2.start();
            thread3.start();
            thread4.start();
            thread5.start();
            thread6.start();
        }
    }

运行结果：(基于4核计算机)  
运行三个线程（顺序执行）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 3]  
运行6个线程（交互执行）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 4]

#### 2.继承Runnable接口实现多线程 ####

**重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target**

class MyRunnable implements Runnable { 
    
        @Override
        public void run() { 
            for(int i = 0; i < 3; i++){ 
                System.out.println(Thread.currentThread().getName()+"运行功能"+i);
            }
        }
    }
    
    public class RunnableDemo { 
        public static void main(String[] args) { 
            //定义线程
            MyRunnable mt1 = new MyRunnable();
            MyRunnable mt2 = new MyRunnable();
            MyRunnable mt3 = new MyRunnable();
            MyRunnable mt4 = new MyRunnable();
            MyRunnable mt5 = new MyRunnable();
            MyRunnable mt6 = new MyRunnable();
    
            //利用Runnable接口子类对象来实例化Thread对象
            Thread thrad1 = new Thread(mt1,"线程1");
            Thread thrad2 = new Thread(mt2,"线程2");
            Thread thrad3 = new Thread(mt3,"线程3");
            Thread thrad4 = new Thread(mt4,"线程4");
            Thread thrad5 = new Thread(mt5,"线程5");
            Thread thrad6 = new Thread(mt6,"线程6");
    
            //启动线程
            thrad1.start();
            thrad2.start();
            thrad3.start();
            thrad4.start();
            thrad5.start();
            thrad6.start();
        }
    }

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 5]

#### 继承Thread类和实现Runnable接口完成多线程的区别 ####

*  实现Runnable接口可以做到资源共享，而继承Thread类不行(比如购票问题)
 *  实现Runnable接口相比继承Thread类来说，具有两大优势：**避免单继承带来的局限和可以共享资源等优势**
 *  相比Thread类的继承，一般采用实现Runnable接口来实现多线程

#### 3. 通过Callable 和 FutureTask创建线程 ####

3.1 创建Callable接口的实现类 ，实现它的Call方法  
3.2 使用FutureTask类来包装Callable对象，这个FutureTask对象需要封装Callable对象的Call方法的返回值  
3.3 使用FutureTask对象作为Thread对象的target创建并调用start方法启动线程

//1. 创建Callable接口的实现类 ，实现它的Call方法
    class MyCallable<T> implements Callable<T>{ 
    
        //重写Callable的call方法
        @Override
        public T call() throws Exception { 
            System.out.println(Thread.currentThread().getName() + " ---->通过实现Callable接口来实现线程");
            return null;
        }
    }
    
    
    public class Callable_FutureTask { 
    
        public static void main(String[] args) { 
    
            //2. 实例化Callable对象
            Callable<Object> callable = new MyCallable<Object>();
            //3. 使用FutureTask类来包装Callable对象
            FutureTask<Object> futureTask = new FutureTask<Object>(callable);
            //使用FutureTask对象作为Thread对象的target创建并调用start方法启动线程
            Thread thread1 = new Thread((futureTask),"线程A");
    
            System.out.println("当前运行线程名：" + Thread.currentThread().getName());
            //启动线程
            thread1.start();
        }
    
    }

运行结果：

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

#### 4. 通过线程池实现多线程 ####

class MyRunnable implements Runnable
    { 
        @Override
        public void run()
        { 
            System.out.println("通过线程池的方式创建的线程，线程名 ：" + Thread.currentThread().getName());
    
        }
    }
    
    public class ThreadPool { 
    
        //设置线程池的数量
        private static int threadPoolNum = 8;
    
    
        public static void main(String[] args) { 
            ExecutorService executorService = Executors.newFixedThreadPool(5);
            for(int i = 0; i < threadPoolNum; i ++)
            { 
                //创建线程对象
                MyRunnable thread = new MyRunnable();
    
                //Thread.sleep(1000);//使线程休眠1秒
                executorService.execute(thread);
            }
        }
    }

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 7]

## 关于线程注意事项 ##

1.  java中，**所有线程都是同时启动的**，哪个线程占有CPU等运行资源，哪个线程就可以运行。
2.  Java程序**每次运行都需要启动两个线程**(**main线程和垃圾收集器线程**)
3.  Java线程运行过程中，其他线程并不会随着主线程的结束而结束。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/78f21696537041d5a5e16195089fd351.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/c763fb167b6640d6b2d368ccb447d93b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/ea98b9b7d4c343559ca3ff749cb7dc75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/08f3dcb7368443f2a8064dae36990151.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/b429a70f7cca44f7b327e1fffcaffb47.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/dd3be13f584d426cbcb7d0a193d4f251.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/786c58cc0b83419e81cf644f9a98c04b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/1cfdd1536aa64a4fa480ed10004df8e4.png