每周总结16 - 多线程

每周总结16 - 多线程

一、程序、进程和线程的概念

程序只是一组指令的有序结合，它本身并没有任何运行的含义，它只是一个静态的实体。（代码块集合，未生效）

而进程则不同。

它是程序在某个数据集上的执行。（开始运行，变成了指令下的动作）

进程是一个动态的实体，它有自己的生命周期。

它因创建而产生，因调度而执行，因等待资源或者事件而被处于等待状态，

因此完成任务而被撤销，

反映了一个程序在一定的数据集上运行的全部动态过程。

进程和程序并不是一一对应的，一个程序执行在不同的数据集上就成为了不同的进程（正在进行的程序，过程），

可以用进程控制块来唯一地标识每个进程。

而这一点正是程序无法做到的，由于程序没有和数据产生直接的联系（他是指令集合，被运行由操作系统CPU之类的去执行么），即使是执行不同的数据的程序，他们的指令的集合依然是一样的，所以无法唯一的标识出这些运行于不同数据集上的程序，一般来说，一个进程肯定肯定有 一个与之对应的程序，而且只有一个。

而一个程序有可能没有与之对应的进程（因为它没有被执行），也有可能有多个进程与之对应（运行在几个不同的数据集上）。

（程序在一个数据集上就有一个对应进程（if 有相关指令的话），不同的数据集上就有不同的进程了）

线程 是 进程内一个相对独立的、可调度的执行单元，又被称为轻量级进程。和进程类似，线程也有运行、就绪、阻塞等状态。（线程就是进程内相对独立的小小轻量级进程。可调度的执行单元，也是动态的）

线程必须拥有父进程。系统没有为线程分配资源，（资源即是空间吧）它与进程中的其他线程共享该进程的共享资源。

同一进程的不同线程共享相同的地址空间，它们可以访问相同的变量和对象，实现线程间的信息共享。

线程间的通信简单而有效，上下文切换非常快。

线程可以彼此独立运行，一个程序可以同时使用多个线程来完成不同的任务。例如，考虑Word字处理程序的输入、词法检查、定时保存。易见，该应用程序涉及三个相对独立的控制流，这三个控制流共享内存缓冲区中的文本信息。单进程或多进程模式都难以恰当地描述和处理这一问题，而同一进程中的三个线程是最恰当的模型。

（一个进程分为多个独立的小线程单元，通过共享这个父进程的资源，实现彼此之间的高效交流，完成各自不同的工作，最终实现这个进程的任务效果）

二、并行和并发

并行，指的是并排行走，几个人并排行走，就是说程序同时在进行。

并发，其实是交替执行的，同一时间，只有一个程序or线程再执行。执行一段时间后切换到另一个程序执行。

决定二者的主要是物理环境，硬件，是否有多核处理器。

多核的CPU才能做到并行，相当于多个大脑。可以一心二用（我们的大脑也是单线程的）

而单核的CPU就是并发的。

多个需要执行的线程or程序是随机交替的。决（定交替的优先级和时长由操纵系统和CPU有一套算法和优先级，但现在目前我的水平看来也是随机的吧？）

并行，同时执行。

并发，实质交替执行。如果快的话看起来好像是同时运行的。

合理运用并发也有实际价值，如视频电影的声音和画面不是同时放送的，只是交替够快。

决定二者的，先是物理CPU环境条件，再是选择吧。

三、多线程

多线程程序是指一个程序中包含多个执行流，它是实现并发机制的有效手段。

从逻辑的观点看，多线程意味着一个程序的多个语句块同时执行，但不等于多次启动一个程序。

（实际上是并发交替，逻辑上（在人、眼看来）是同时执行的，要这个效果，先做1再做2就显得奇怪，或者需要配合成果的实施。于是1,2并发交替运行）

引入多线程程序设计的原因：

1.某些应用具有的内在多控制流 结构，控制流 具有合作性质，需要共享内存。采用多线程易于对时间建模。

2.在需要多控制流 时，多线程比多进程速度绝对优势，建立速度约比后者快100倍。

（毕竟小就占资源少，然后共享就交流速度快么）

3.采用多线程可以提高处理机和设备之间的并行性。

大概是想一步就做一步，想到烧开水就先烧，然后边等边想的感觉么？就节省时间了。

4.在多处理机的硬件环境中，多线程可以并行执行，从而提高资源的利用率和进程推进的速度。

数据流是在控制流上的数据操作表示，只有在控制流上进行的数据流分析才是有价值的。

数据流：最初是通信领域使用的概念，代表传输中所使用的信息的数字编码信号序列。

控制流：是指按一定的顺序排列程序元素来决定程序执行的顺序。Visual BASIC、C和其他编程语言也继承了控制流，语句按照出现在程序中的顺序执行。

——来自百度搜索，数据流和控制流。

多线程，一般为并发交替，但如果有多核处理器硬件环境，也可以并行执行，提高效率，（此时应该默认是并发提速吧）

看硬件物理环境，决定多线程是并发还是并行。

多线程机制是Java语言的重要特征之一。Java是基于操作系统级的多线程环境设计的，

JVM依靠多线程来执行多任务，并且，所有类库在设计的时候都考虑到了多线程机制。

Java的多线程是一个类，

这个类可以对它的线程进行控制，可以确定哪个线程的 优先级 高，

哪个线程应该执行，等等。

线程的执行由拥有这个线程的一个or多个类来控制。

多线程是一个类，线程的执行由拥有它的类们来控制。

java中实现线程的的方式有两种，第一种是生成Thread子类，并定义该子类自己的run()方法，线程要完成的任务在run()方法中实现。这种方法比较简单。

但如果要实现其他的继承，由于java没有多继承，便只能使用第二种方法。

即是实现Runnable接口中的run()方法来完成线程的任务。

tips:

java lang包不需要导入，因为常用，所以提前加载了。

Thread类就是lang包中的。

\t转义字符的意识是水平制表格相当于Tab键

就像\n 就是回车键。

四、Thread类

1.线程组

每个线程都会有一个线程组，如果创建时没指定一个线程组，那么该线程将会被加入到父线程（创造该线程的线程）所在的线程组。

而在Java中，线程组是使用类ThreadGroup进行抽象描述的。

ThreadGroup

线程组表示一个线程的集合。（一个类吧，他的对象应该可以包含多个线程对象。）

此外，线程组也可以包含其他的线程组。（也可以包含多个与自己同类的线程组对象。）

线程组构成一棵树，在树中，除了初始线程组之外，每个线程组都有一个父线程组。

线程组，

表示1-n个线程的集合。

每个线程都会存放在线程组里面。

java中线程组是用类ThreadGroup来描述。

他的对象可以包含多个线程对象or线程组对象。进行批量管理。

线程组们可任意构成一棵树，在树中，除了初始线程组外，每个线程组都有一个父线程组。

这怎么和类继承一样，所以都是在一个线程里面吗。

只有在创建线程时才能指定其所在的线程组，线程运行中途不能该改变它所属的线程组，创建时指定了or没指定就是默认的线程组，即是在父线程所在线程组，一般为main线程组里面。

然后就一直在那里运行到结束。

2.Thread的构造方法

Thread有8个构造方法。

算了先看书学一下，敲看有无必要，

累了，休息。

五、构造线程的四种方式

1.继承Thread线程类

2.实现Runnable接口

3.实现callable接口

4.通过线程池创建线程。

1.继承Thread线程类

重写run()方法实现你想要的功能。

package com.XGX.Test.myThread;

public class myThread extends Thread{//这里不用导包吗？lang包都不需要导。
    String threadId;//属性，线程的名称代号。
    public myThread(){}
    public myThread(String threadId){
        this.threadId = threadId;
    }
    //无参和有参
    public void run(){//线程要重写run方法
        System.out.println("Thread started:" + this.threadId);
        for(int i = 0;i<6;i++)
            System.out.println(" i ="+ (i+1)+"\t");//\t转义字符的意识是水平制表格相当于Tab键。
        System.out.println("Thread stopped:" + this.threadId);
    }
    //重写了run方法，有自己的运行方式了。
}
---
    
package com.XGX.Test;

import java.lang.*;
import com.XGX.Test.myThread.*;

public class Test{
    public static void main(String[] args){
        System.out.println("程序开始运行");
        myThread t1 = new myThread("t1");//创建线程对象
        t1.start();
        //调用start()方法来启动该线程。
        myThread t2 = new myThread("t2");
        t2.start();
        System.out.println("ThreadTest1 is done");
        //结束标志。
    }
}
/*
线程测试，
1.先构建Thread子类，要重写其中的run()方法，看来是一定会运行的东西，通过run方法来实现这个线程的功能作用。
2.创建线程对象。
3.用Thread对象调用start()方法，这时候就开始运行了。
调用start()方法启动该线程。
》》》
通过结果可以看到，整个main方法是一个主程序，主进程。
位于Main方法末尾的ThreadTest1 is done。反而是最先输出的。
然后随着两个线程的开始
X（~有提示标志语句打印，应该是start方法自带的~）X
X并不是，你自己写的start and stop tips.
i = data开始不断打印。
其中顺序出现乱，随机现象。
但不知道线程是同时进行速度不一样，还是交替运行的，随机交替。

BUT，不确定线程运行方式，此时还无法判断。同时or交替。
但是多次测试结果，比较随机，处理线程1是先打开的顺序固定的影响以外。
如果是同时。
2个线程的运行速率应该不会相差过大。
从随机结果看（甚至可以见到2线程比1先结束）
更倾向于是随机交替运行这种结果。

多次运行的输出结构都不一样。
 */
/*
运行结果实例展示

1.
程序开始运行
        ThreadTest1 is done
        Thread started:t2
        i =1
        i =2
        i =3
        Thread started:t1
        i =1
        i =2
        i =4
        i =3
        i =4
        i =5
        i =5
        i =6
        i =6
        Thread stopped:t2
        Thread stopped:t1
2.
程序开始运行
ThreadTest1 is done
Thread started:t1
 i =1	
 i =2	
 i =3	
Thread started:t2
 i =1	
 i =4	
 i =5	
 i =6	
 i =2	
Thread stopped:t1
 i =3	
 i =4	
 i =5	
 i =6	
Thread stopped:t2
 */

2.实现Runnable接口

实现run()方法。

因为java中无法多继承，可以一父多子，但不能一子多父。extends.

但是接口可以实现多个。implements.

通过接口来间接实现多继承。

即是，一个子类，有一个父亲，一个父类class继承extend。

和多个老师，即是多个接口interface.去实现implements.

父亲和老师共同塑造，教这个子类东西和本领，

然后由子类来实现个性化。

用于你的线程类要继承别的类时（就无法继承Thread类）通过实现Runnable接口和Run（）方法来完成

线程类的构建。

这样可以保持线程类在别的体系中的继承关系。

Runnable接口源码

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

实现Runnable接口构造线程的步骤如下：

1.将需要实现多线程的类声明为实现Runnable接口的类，实现run()方法，并将线程体放在该方法中。

run() 方法就是用来执行线程操作的。

在start()后，JVM会分配新的栈空间交由线程使用。

run()方法就是新的main()方法在新栈中运行。

2.创建一个该类的实例

3.从该实例创建一个Thread实例。

4.调用start()方法启动该线程。

错误示例：code1
public class Test{
    public static void main(String[] args){
        myThread t1 = new myThread(1);
        Thread t2 = new Thread(t1);//大概是将自己的myThread转化为大Thread父类，由父类调用start()方法？,确实是是这样
        t1.start();
    }
}
//上面写错了，因为直接用t1调用了start()方法，
//报错显示找不到start()符号。这说明你写的thread类中没有此方法。

//成功案例c2
package com.XGX.Test;

import com.XGX.Test.myThread.*;

public class Test{
    public static void main(String[] args){
        myThread t1 = new myThread(1);
        Thread t2 = new Thread(t1);
        t2.start();
    }
}
//书上示例c3
public class Test{
    public static void main(String[] args){
        Runnable r1 = new myThread("1");//用父接口引用类型指针，指向了子实现类对象。
        Thread t1 = new Thread(r1);//这到底是个什么构造？
        //说是分配一个带有指定目标的线程对象。
        //Thread(Runnable target)  此构造方法，参数为启动此线程时调用其run()方法的对象。
        t1.start();//所以t1 start,r1就run 了。
    }
}                         

这个c2和c3的区别

就是创建 自己的Thread类 的时候，用的是myThread 还是 Runnable引用类型指针。

这个应该是基本没什么区别的，毕竟Runnable太抽象了，就一个run()方法。

就后者范围高一级吧

用的构造方法都是一样的。都是先用myThread()方法。

然后再Thread()方法的特殊构造，创建Thread对象，但调用的是你的myThread中的run()方法。

探索

public class myThread extends Thread{
    String id;
    public myThread(){}
    public myThread(String id){
        this.id = id;

    }
    public void run(){
        System.out.println("线程" + this.id + "已经成功运行");
    }
}
---
    import com.XGX.Test.myThread.*;

public class Test{
    public static void main(String[] args){
        myThread t1 = new myThread("t1");
        t1.start();
    }
}
//结果，成功运行了，第一种方法，直接继承Thread,可以直接用myThread对象调用start()方法。
把以上代码仅做这一行修改，把myThread由继承Thread变为实现Runnable。
public class myThread implements Runnable
    然后编译就过不了了。
    无法识别 start();
***
继续做一点修改
public class Test{
    public static void main(String[] args){
        myThread t1 = new myThread("t1");
        Thread T1 = new Thread(t1);
        T1.start();
    }
}
//结果成功了
让这个实现了Runnable的myThread直接调用 start()是不行的。
    通过thread 的特殊构造方法，来通过 thread对象T1来调用目标t1的 run()方法
    实现了启动线程。
    
//结论
    继承了Thread类，就继承了start方法，对象实例可以直接调用。
    但实现Runnable接口，就没有start方法，必须通过Thread的特殊构造
    创建一个Thread实例 包装 Runnable实现类对象，
    来用此Thread实例调用start方法启动线程。

之前第一种方法，直接继承了Thread类，直接用自己的对象就可以调用start()方法运行这个线程。

public class myThread implements Runnable{
        String id;
        public myThread(){}
        public myThread(String id){
            this.id = id;
        }
        public void run(){
            System.out.print("\n Thread started:" + this.id);
            for(int i = 0;i < 6;i++ )
                System.out.print("i = " +(i+1) + "\t");//一行语句不写{}了
                System.out.print("\n Thread stopped:" +this.id);
                //这个类就是先输出1-5，然后输出结束。
        }
}
----
    import com.XGX.Test.myThread.*;

public class Test{
    public static void main(String[] args){
        System.out.println("Starting ThreadTest1");
        Runnable r1 = new myThread("thread1");
        Thread t1 = new Thread(r1);//此构造方法构造的对象被启动时，会调用指定Runnable实现类的Run方法，而不是自己的Run()方法
        t1.start();
        Runnable r2 = new myThread("thread2");
        Thread t2 =new Thread(r2);//直接填对象名就行，
        t2.start();
        Runnable r3 = new myThread("thread3");
        Thread t3 = new Thread(r3);
        t3.start();
        System.out.print("ThreadTest1 is done");
    }
}

因为Runnable接口和Thread类之间没有继承关系，所以不能直接赋值，（什么意思？指的是直接调用start方法吗）

为了使run方法中的代码在单独的线程中运行，还需要一个Thread的实例实现对Runnable对象的包装。

为此，线程中需要包括两部分内容：

Thread提供线程的支持；Runnable实现类 提供线程执行体（即run()方法）。

、参考链接

线程组(ThreadGroup)
原文链接：https://blog.csdn.net/fr060462/article/details/79724649

线程的四种实现方式

本文链接：https://blog.csdn.net/weixin_46217160/article/details/108721306

java进阶-第十三讲 多线程

本文链接：https://blog.csdn.net/solo_jie/article/details/113861573