java 多线程学习（一）多线程的构造

偏执的太偏执、 2021-09-15 23:16 423阅读 0赞

## 进程和线程的理解： ##

进程：从狭义的角度来讲,**进程就是一个正在运行的程序的实例**。

线程：指的是进程中单一顺序的执行流，有时候也叫作轻量级进程。

举个例子：

当我们用word 2016程序 编辑word的时候，word2016 可以实时检查拼写的错误。 我们先运行word 2016 程序，

打开任务管理器，切换到进程页面，就可以找到word2016的进程，这就是正在运行的word2016 的一个实例

![70][]

同时也可以看到，一个运行的中的程序可能不止有一个进程，可能有多个进程，每个进程都执行不同的任务，如图中的QQ音乐和电脑管家。

我们继续以word2016 来举例说明线程。可以看到在运行的过程中，word只有一个进程，但是却可以同时执行不同的功能。

这是因为word2016 的进程中，有多个线程，如 有一个线程在接收键盘输入的字并以适当的格式显示在屏幕上，而另一个线程在“读取”我们输入的字符或者文本，然后分析并标记错误的部分。

这就和我们以前运行java程序的时候形成对比了。以前我们运行java程序的时候，是从mian函数从上往下按顺序执行的，当调用函数的时候，也要等调用的函数执行完了，才能继续往下执行。而，如果在我们的程序里加入多线程，就可以不用等函数调用完成，可以继续往下执行下面的语句。

## 多线程的状态 ##

线程从产生到消亡，一共有五个状态

1. Newborn 状态：线程被创建但没有开始执行的初始状态。直到调用Thread类的run()方法后，线程会进入Runable状态

2.Runable状态：线程处在准备就绪的状态，随时可被调用执行。（**注意：对线程调用run()方法后，不代表线程立即执行，Runable状态****的****线程会进入一个等待队列中等待执行**）

3. Running 状态： 线程正在运行的状态，表示线程已经拥有处理器的控制权。正常情况下，当run()方法运行结束后，该线程就进入Dead状态。

4. Blocked状态： 线程的堵塞状态。处于阻塞状态的的线程必须由某些事件唤醒，至于是何种事件，则取决于阻塞发生的原因。

5. Dead 状态： 死亡或终止状态，表示线程已经退出运行的状态。进入这一状态的线程有多方面的原因，可能是线程执行完毕，正常终止也可能是一个线程被另一个线程强行中断。

为了便于理解和记忆，笔者特地画了一个流程图：

![70 1][]

## 构造多线程的三种方法： ##

### 一、 通过继承Thread类来构造线程 ###

步骤：

1.创建一个类，并继承（extends）Thread类

2. 重载父类Thread的run（）方法（即**把你想要在这个线程中执行的代码放入run（）方法里**）

3. 实例化（new）该线程的一个对象

4, 调用对象的start（）方法启动线程

ps：线程启动后自动执行run（）方法里的内容，执行完毕后，线程进入终止的状态，

下面是一个简单的实例：

//多线程的实现方法之一： 通过继承Thread类实现
    public class myThread00 extends Thread {
        public void run(){ //需要重写run方法
            for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+" - running");}
        } //Thread.currentThread().getName() 会返回正在执行的该方法的线程的名字，该名字一般由java虚拟机自己生成
        public static void main(String[]args){
            myThread00 mt0=new myThread00();
            myThread00 mt1= new myThread00();
            mt0.start();// 调用start方法而不是run方法啊
            mt1.start();
            for(int i=0;i<5;i++){
                System.out.println("for: "+Thread.currentThread().getName()+" - running");}
        }
    
    }

运行结果如下图：（运行结果不唯一）

![70 2][]   ![70 3][]

（ps： Thread-0 ,Thread-1 ,main 代表三个不同的线程）

读者多运行几次也会得到不同的结果，上面右边的运行结果是比较明显的，可以看出 两个线程是在同时运行的。表现出来的结果就是交替打印（毕竟计算机每秒运算上百万次，所以要想看出更明显的效果，可以把循环的次数适当增大。）

需要说明的是，我们在main方法里新建并启动了一个线程，但实际上，**还有一个线程在运行main方法，我们这个线程叫做主线程。主线程负责新建和启动其他线程。Thread.currentThread().getName()返回的名字为main即代表该线程是主线程。**如在这个例子中， 通过主线程新建并启动了两个子线程。

**通过这个简单的例子，我们能得到下面几个结论：**

1. 创建独立执行的线程还是比较容易的（Java JVM负责处理了大部分细节）

2. 无法准确的知道线程在什么时间开始执行的（因为这是操作系统决定的）

3. 线程间的执行是相互独立的

4. 线程独立于启动它的线程。

### 二、通过实现实现Runable接口来构造线程 ###

我们知道，java类是单继承的，每个类只能有一个父类，所以如果我们通过继承Thread类的方法来构造线程，这个类就不能继承其他需要的类，这可能会对我们的编程造成很大的限制。所以实现多线程一般通过实现Runable接口实现，从而克服了单一继承方式所造成的限制。

先来看下Runable接口的定义：

public interface Runable{
        public abstract void run();
    }

看起来和一般的接口没有什么不一样的，它是怎么实现多线程的呢？答案是 **和一个Thread类对象绑定** 。

我们将前面的例子稍微改一下，改成通过实现Runable接口的方式构造线程

//多线程的实现方法之二： 实现Runnable接口。和继承自Thread类差不多，不过实现Runnable后，还是要通过一个Thread来启动：
    public class myThread01 implements Runnable{
        @Override
        public void run() {
           for(int i=0;i<5;i++){
               System.out.println(Thread.currentThread().getName()+" - running");
           }
        }
        public static void main(String[] args){
    
            myThread01 mt1 = new myThread01();//实例化类
            myThread01 mt2 = new myThread01();
           
            Thread t1 = new Thread(mt1); //绑定Thread类对象，并通过Thread类启动
            Thread t2 = new Thread(mt2);
    
          //Thread t1 = new Thread(new myThread01());  
          //Thread t2 = new Thread(new myThread01()); 这两行和上面四行效果是一样的，是一种简便的写法
    
            t1.start();//还是通过start方法启动
            t2.start();
            for (int i=0;i<5;i++){
                System.out.println("for: "+Thread.currentThread().getName()+" - running");
            }
        }

运行效果如下（效果不唯一）：这是比较明显的结果。。毕竟打印5句话实在是太快了，想看到明显效果的话，可以把循环次数改为500000...

![70 4][]

## 三、在方法二的基础上,可以通过lambda表达式创建线程 ##

**ps:lambda表达式是java8加入的特性,如果想要的了解话,可以看看我写的这篇[博客][Link 1]**

/**
     * 多线程的实现方法之三：
     * //通过lambda表达式方法创建,本质就是实现Runable接口
     *
     * @author manzuo
     */
    public class myThread01 {
        public static void main(String[] args) {
            //通过lambda表达式方法创建,本质就是实现Runable接口
            Thread t1 = new Thread(()->{
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + " - running");
                } 
            });
            //还是通过start方法启动
            t1.start();
            for (int i = 0; i < 5; i++) {
                System.out.println("for: " + Thread.currentThread().getName() + " - running");
            }
        }

[70]: /images/20210724/db5b015b11c34cb295b26da01c52caf6.png
[70 1]: /images/20210724/854c9dd859d74f8b8d9e760328a71d3e.png
[70 2]: https://img-blog.csdn.net/20180729153734423?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbl96dW8=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 3]: /images/20210724/ad5cf35420da48dcbb0219ffa900c3dc.png
[70 4]: /images/20210724/a2b4a4cc6d3f49c1a3d4fd2f095160c4.png
[Link 1]: https://blog.csdn.net/man_zuo/article/details/104994562