第35节：Java面向对象中的多线程

àì夳堔傛蜴生んèń 2021-09-16 06:32 463阅读 0赞

![标题图][1240]

## Java面向对象中的多线程 ##

#### 多线程 ####

在`Java`面向对象中的多线程中，要理解多线程的知识点，首先要掌握什么是进程，什么是线程？为什么有多线程呢？多线程存在的意义有什么什么呢？线程的创建方式又有哪些？以及要理解多线程的特点等。

#### 多线程和线程的理解 ####

多线程？线程，多个线程，如何理解什么是进程呢？

如图：

![任务管理器][1240 1]

任务管理器中有个进程，下面列表的则是正在进行中的任务程序，都属于进程（正在执行中的程序），那么具体的进程是什么？进程实质是：应用程序在内存中运行的所占空间。

可以理解为一个空间，当一个应用程序启动时，就为一个进程，如`qq`的启动，可以为一个进程，（简单理解正在进行的应用程序），那么我们在玩`qq`的时候，进行聊天，那么这个聊天为进程中的线程，即为一个执行单元，那么这个应用程序不仅只有一个线程，一个进程可以有多个线程，那么这个应用程序就被称为多线程程序。

多线程，你在玩`qq`的时候，是不是同时和其他人聊天呢？即为多线程嘛，可以这么理解。多线程同时处理问题，和执行任务。

> 一个进程中至少有一个线程

一个应用程序启动了多线程，可以实现多个任务同时执行，这也就是Java中的并发概念。

## 多线程的原理 ##

多线程是如何使用的呢？多线程的使用可以合理的安排`cpu`的调用，多线程会导致程序的性能降低，多线程是靠`cpu`内部处理快速切换完成的。

## 案例 ##

主方法的运行，主线程运行负责，`start`方法开启一个线程

class Demo{
     private String name;
     Demo(String name){
      this.name = name;
     }
     public void show(){
      for(int i = 0; i < 10; i++){
       System.out.println("name"+name+"运行到第"+i);
      }
     }
    }
    // 测试
    class ThreadDemo{
     public static void main(String[] args){
      Demo demo1 = new Demo("dashu");
      Demo demo2 = new Demo("dashu2");
      demo1.show();
      demo2.show();
     }
    }
    // 主线程，先运行demo1.show()完成后再次运行demo2.show()

## 多线程的优点 ##

*  多线程编程比较简单，效率也高，可以共享数据和资源
 *  适合开发服务的程序，如聊天等
 *  适合开发有多种交互的接口程序等

## 线程类（Thread）及其方法 ##

多线程中的一些概念，程序指用静态的计算机语言编写的代码程序，多进程指在操作系统中有多个程序同时执行，那么多线程是指在程序中有多个线程同时执行咯~

> 再次强调：一个进程中至少要有一个线程，一个进程可以有多个线程

#### 线程的创建： ####

java.lang.Object->java.lang.Thread
    public class Thread extends Object implements Runnablef

线程对象调用`run`方法是不开启线程的，由对象调用方法，是`main`主线程负责的，调用`start`开启线程，并让`jvm`调用`run`方法在开启的线程中执行，即开启线程，多一条路可以走。注意有主线程负责的为一条线程路，`run`方法启动的。

// 为一条主线程，先执行d1，然后为d2
    d1.run();
    d2.run();
    // 为两条线程，d2和d1不并发，run()走完，才开启start() d1.run();
    d2.start();
    // 为三条线程
    d1.start();
    d2.start();
    // 为两条线程，d2和d1并发
    d2.start();
    d1.run();

1.  声明一个 `Thread` 类的子类，覆盖`run()`方法，创建子类对象，就是创建线程对象，然后调用`start`方法（开启线程让线程去执行，然后让`jvm`调用`run`方法）。
2.  声明一个实现 `Runnable` 接口的类，实现`run()`方法。

// 声明一个 Thread 类的子类，覆盖run()方法
    class Mythread extends Thread { 
       // 覆盖run方法
       public void run( ){
        ...
       }
    }

继承`Thread`类，是因为`Thread`类中有描述线程的事务，具备线程该有的功能，创建线程是为了建立独立的执行路径，实现代码同时执行，线程的创建就是为了给线程执行任务。

`Runnable`接口，`public interface Runnable`

Demo d = new Demo("dashucoding");
    Thread t1 = new Thread(d);
    t1.start();

定义类实现`Runnable`接口，覆盖`run`方法，线程任务代码在`run`中定义，创建`Runnable`接口的子类对象，创建线程对象，并将`Runnable`接口的子类对象作为参数传递给`Thread`的构造函数，`start`调用开启线程即可。

// 声明一个实现 Runnable 接口的类，实现run()方法
    class Mythread implements Runnable { 
       // 实现run方法
       public void run( ){
        ...
       }
    }

主线程是运行在`main`函数中的，自定义的线程是要将需要执行的任务定义在`run`方法中，在`Thread`类中的`run`方法不是我们需要执行的，所以我们需要自己重写这个方法，将要执行的任务`diam`定义在`run`方法中即可。

> 创建新的执行线程在`Java`中有两种方法，一种为将类声明为`Thread`的子类，将该子类重写`Thread`类的`run`方法，接着分配和启动该子类的实例；另外一种方法是声明实现`Runnable`接口的类，然后实现`run`方法。

#### 线程类的主要方法 ####

线程嵌套类摘要：

// 线程的状态
    Thread.State
    // 当线程因未捕获的异常而突然终止时，调用的处理程序的接口
    Thread.UncaughtExceptionHandler

一般方法：

// 构造方法
    Thread()
    // 给线程指定一个名字
    Thread(String threadName)
    // 线程所执行的代码
    void run()
    // 线程睡眠
    void sleep()
    // 改变线程的名字
    void setName(String threadName)
    // 获得线程的名字
    String getName()

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>currentThread()</code></td> 
   <td>返回对当前正在执行的线程对象的引用</td> 
  </tr> 
  <tr> 
   <td><code>getId()</code></td> 
   <td>返回该线程的标识符</td> 
  </tr> 
  <tr> 
   <td><code>getName()</code></td> 
   <td>返回该线程的名称</td> 
  </tr> 
  <tr> 
   <td><code>getPriority()</code></td> 
   <td>返回该线程的优先级</td> 
  </tr> 
 </tbody> 
</table>

## 线程的生命周期 ##

线程是程序内部的一个控制流，它是由特定的生命周期的，线程的状态表示了线程正在进行任务。

创建新的线程，线程创建后，进入到就绪状态，等待`start()`方法被调用，然后进入到运行状态，在线程中可以设置等待一个事件，该线程就会处于阻塞状态，直到`run()`方法结束，或调用`stop()`方法后，线程就处于死亡状态。

**线程休眠**

myThread.sleep(10000);

**线程死亡**

myThread.stop( );

多线程的执行，在栈内存中，每一个线程都有属于自己的栈内存空间，进行压栈和弹栈，当线程结束时，该线程就会在栈内存中释放。

#### 线程的优先级 ####

线程中是具有优先级的，`Java`提供了线程调度器来监控所有线程，通过线程调度器安排哪个线程进行执行，优先级高的线程会在优先级低的线程之前先进行执行，优先级的分类：低（`Thread.MIN_PRIORITY`），中（`Thread. NORM_PRIORITY`），高（`Thread.MAX_PRIORITY`）。

**线程优先级的一些方法**

// 获得线程的优先级
    int getPriority()
    // 改变线程的优先级
    void setPriority( int p )

> 线程是程序在运行中的执行单元，`Java`虚拟机时允许应用程序同时并发多个线程的，每个线程独有属于自己的优先级，处于高优先级的线程是先于低优先级的线程进行执行。

## 多线程的案例 ##

class Ticket implements Runnable{ 
     private int tickets = 100;
     public void run(){
      ...
     }
    }
    class Demo{ 
     Ticket t = new Ticket();
     Thread t1 = new Thread(t);
     t1.start();
    }

## 结语 ##

*  下面我将继续对`Java`、 `Android`中的其他知识 深入讲解 ，有兴趣可以继续关注
 *  小礼物走一走 or 点赞

[1240]: /images/20210724/d0d9f259fa224aaca1fa636f3f1a3ec7.png
[1240 1]: /images/20210724/ef8523654ba04103a8c26c1c952bfa98.png