Java创建线程的方式以及线程的几种状态

灰太狼 2020-05-30 02:04 900阅读 0赞

# Java创建线程的方式以及线程的几种状态

### 一、线程的概述

进程：正在运行的程序，负责了这个程序的内存空间分配，代表了内存中的执行区域。
 线程：就是在一个进程中负责一个执行路径。
 多线程：就是在一个进程中多个执行路径同时执行。

#### 1.1多线程的好处：

1. 解决了一个进程里面可以同时运行多个任务（执行路径）。
2. 提供资源的利用率，而不是提供效率。

#### 1.2多线程的弊端:

1. 降低了一个进程里面的线程的执行频率。
2. 对线程进行管理要求额外的 CPU开销。线程的使用会给系统带来上下文切换的额外负担。
3. 公有变量的同时读或写。当多个线程需要对公有变量进行写操作时,后一个线程往往会修改掉前一个线程存放的数据，发生线程安全问题。
4. 线程的死锁。即较长时间的等待或资源竞争以及死锁等多线程症状。

------

### 二、创建线程

#### 2.1 创建线程的方式一（继承）

通过继承`Thread`来创建线程。步骤：

1. 自定义一个类继承`Thread`.
2. 重写`Thread`的`run`方法。
3. 创建`Thread`子类的对象，然后调用`start`方法开启一个线程。

注意：千万不要直接调用run方法，直接调用run方法就相当于调用了一个普通的方法而已，并没有开启一个新的线程。

```java
public class Demo1 extends Thread {
    //自定义线程的任务代码写到run方法中。
    @Override
    public void run() {
        for(int i = 0 ; i<100 ; i++){
            System.out.println("自定义线程："+ i);
        }
    }
    public static void main(String[] args) throws Exception {
        //主线程
        Demo1 d = new Demo1();
        d.start();//开启了一个新的线程，一个线程开启的时候就会执行run方法中的代码
        for(int i = 0 ; i<100 ; i++){
            System.out.println("主线程："+ i);
        }   
    }
}
```

#### 2.2 为什么要重写run()方法?

每个线程都有自己的任务代码，主线程的任务代码是在main方法中，因为每个线程都有自己要执行的代码，自定义线程要执行的代码就放在run方法 中。重写run方法的目的就是把自定义线程的任务代码编写到run方法中。

#### 2.3 线程的使用细节

1. 线程的启动使用父类的`start()`方法
2. 如果线程对象直接调用`run()`，那么`JVM`不会把它当作线程来运行，会认为是普通的方法调用
3. 线程的启动只能有一次，否则抛出异常
4. 可以直接创建`Thread`类的对象并启动该线程，但是如果没有重写`run()`，什么也不执行
5. 可以使用匿名内部类的实现方式来启动一个线程

#### 2.4 线程的多种状态

![线程状态之间的转换](/images/1590804269062.jpg "线程状态之间的转换")

线程状态之间的转换

- 创建：新创建了一个线程对象。
- 可运行：线程对象创建后，其线程调用了该对象的`start()`方法。该状态的线程位于可运行线程池中，变得可运行，等待获取`cpu`的执行权。
- 运行：就绪状态的线程获取了`CPU`执行权，执行程序代码。
- 阻临时塞： 阻塞状态是线程因为某种原因放弃`CPU`使用权，例如调用了`sleep`或者`wait`方法，线程会暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态
- 死亡：线程执行完它的任务时

#### 2.5 线程的常用方法

- ·`Thread(String name)` 初始化线程的名字
-  `getName()` 返回线程的名字
-  `setName(String name)`  设置线程对象名
-  `sleep()` 静态的方法，线程睡眠指定的毫秒数。使用该方法需要抛出异常,并不会释放锁对象
-  `getPriority()` 返回当前线程对象的优先级，默认线程的优先级是5
-  `setPriority(int newPriority)` 设置线程的优先级，虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ， 默认是5）
-  `currentThread()` 返回CPU正在执行的线程的对象
-  `getId()` 返回该线程的标识符。线程 ID 是一个正的 `long`型数值，在创建该线程时生成。线程ID是唯一的，并终生不变。线程终止时，该线程 ID 可以被重新使用。

#### 2.６ 创建线程的方式二(实现Runnable接口)

创建线程的第二种方式：实现Runnable接口。该类中的代码就是对线程要执行的任务的定义。步骤如下：

1. 定义一个实现`Runnable`接口的类
2. 实现`Runnable`接口中的`run`方法，就是将线程运行的代码放入在`run`方法中
3. 通过`Thread`类建立线程对象
4. 将`Runnable`接口的子类对象作为实际参数，传递给`Thread`类构造方法
5. 调用`Thread`类的`start`方法开启线程，线程最终会调用`Runable`接口子类的`run`方法

```java
class RunableDemo1 {
    public static void main(String[] args) {
        //1.创建Runnable的子类对象
        MyRun mr = new MyRun();
        //2.通过Runnbale的子类对象创建线程对象
        Thread t1 = new Thread(mr);
        //3.启动线程
        t1.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("main:"+i);
        }

}
}

class MyRun implements Runnable{    //建立Runnable接口的实现类
    @Override
    public void run() {
        for(int i=0;i<200;i++){
            System.out.println("MyRun"+i);
        }
    }   
}  
```

【提示】推荐使用第二种方式，即实现`Runnable`接口的方式。因为`java`是单继承的。

#### 2.7  为什么要将Runnable接口的子类对象传递给Thread的构造函数？

因为自定义的`run`方法所属对象是`Runnable`接口的子类对象，所以要让线程去执行指定对象的`run`方法。在创建`Thread`线程对象的时候，会调用线程的`run`方法，而调用线程`run`方法的时候又会去调用`Runnable`接口的实现类对象的`run`方法，来执行线程代码。`Thread`类的构造方法，可以接收一个`Runnable`接口的子类对象。

#### 2.8 关于Runnable的实现类对象

`Runnable`实现类的对象并不是线程对象，因为它没有`start`方法。只有`Thread`类对象极其子类对象才是一个线程对象。