JAVA系列 多线程 Thread类 耦合 线程调度 如何创建线程 弱耦合 完全解耦 思维结构整理

这估计是我JAVA系列 基础知识点梳理的最后一篇文章了吧

之后一段时间 我打算去看看之前承诺更新的JAVA的一些项目了 然后我要好好玩一段时间游戏 然后跟某些好朋友见面 所以后面会忙一点

然后就是很多同学 六级还没有考 估计很多人是开学再考把 这个假期就不要玩的太厉害了 没事就看看我之前写的关于CET6 整理的文章

CET6 历年真题原词复现 核心词汇 做题技巧 听力拿分技巧汇总（这篇文章是英语四六级考试最后的版本，谢谢大家一路陪伴）

话不多说 进入正题

本章我觉得也没什么好讲的 因为书上都很详细了，我主要的目的还是要给大家梳理思路

最重要的有些内容呢 我提下 主要的提的还是基础部分 方便唤醒各位的回忆。

还是那句话 重要的内容不要妄想通过网上的碎片化知识就觉得自己学懂了 学明白了 一定要回归教材 看看书上的内容和介绍。

线程的核心 run方法和start方法的区别 如何启动一个线程

一个线程的start方法 就是调用了Thread类中的run方法，但start调用和run调用不一样。

如果仅仅使用run方法来调用 那仍然只有一个单线程

只有使用了start方法 才又进行了一个线程 虽然start方法也是执行的run方法的内容

start方法包含了run方法 为什么这么描述 因为start执行内容和你重写的run内容是一样的。但是却多出来了一个新的线程。

核心问题 如何创建线程Thread类

也就是如何创建一个线程？

有两种比较常见的方法。

第一种 使用Thread类子类 这类方法常见的结构核心就是extends Thread。

//speakelephant类 第一种创建方法 使用Thred子类创建线程
public class speakelephant extends Thread{
public void run(){
   for(int i=0;i<20;i++)
    System.out.print(i);
 }
}

main主函数

public class Example{
public static void main(String args[]){
speakelephant test1=new speakelephant();
test1.start();
}
}

第二种就是使用Thread类 这类常见特征就是implements Runnable接口

//由于这里是使用的接口 所以我们还可以extends一个父类 更加灵活
//for example 
//public class ElephantTarget extends xxx implements Runnable  
public class ElephantTarget implements Runnable{
public void run(){
 for(int i=0;i<20;i++)
 System.out.print(i);
}
}

main主函数

    import java.util.*;
    public class Main {
        public static void main(String[] args)  {
            Thread number1=new Thread(new ElephantTarget());//使用内部类创建 先不着急 熟悉了再用
           
            ElephantTarget a=new ElephantTarget();
            Thread number2=new Thread(a);//标准创建操作  有两步 先创建一个实现了Runnable接口的类
                                //然后再用这个类创建一个Thread类 最后实现功能的是Thread类 number2

            number1.start();
            number2.start();
        }
    }

主要就是上面两种方便大家记忆。

线程调度和优先级

每个JAVA线程的优先级都在常数1和10之间，即

Thread.MIN_PRIORITY和Thread.MAX_PRIORITY之间。如果没有明确地设置线程地优先级别，每个线程地优先级都为常熟5 即Thread.NORM_PRIORITY

线程优先级可以通过setPriority（int grade）方法调整 有些操作系统只识别3个级别 1 5 10

然后接下来要讲一下

耦合的概念

public class House implements Runnable{
    public void run(){
            String name=Thread.currentThread().getName();//线性编程
            if(name.equals("Dog")){
                System.out.println(name+" is drinking water");
                System.out.println("现在是house类中的run方法中的if分支Dog在运行");
            }
            else if(name.equals("Cat")){
                System.out.println(name+" is drinking water");
                System.out.println("现在是house类中的run方法中的if分支Cat在运行");
            }
    }
}

    import java.util.*;
    import java.io.*;
    public class Main {
        public static void main(String[] args)  {
            House a=new House();


            Thread dog=new Thread(a);//他们都是用house类创建的Thread类
            Thread cat=new Thread(a);//他们都是用house类创建的Thread类
            //但是为什么可以这样 首先house类实现了Runnable接口 所以依旧可以创建 这里二者还没开始分家


            dog.setName("Dog");
            cat.setName("Cat");//这一步 线程拥有了自己的名字 我们再去看我们的house类代码
//你会发现 由于house类中有分支结构 分别给了cat和dog不同的if路径 所以在设置完线程名称后 二者开始分家了
                                
            dog.start();


            System.out.println("-------------------------------------");
//这一步很明显我想把二者打印的东西分开来 
//但是大家看我的输出结果出现了问题 
//没如我所愿 这是一个意外 因为主线程跑的比dog线程更快
// 因为dog线程还包含了启动时间 这个时候主线程已经运行到这里了



            cat.start();
                
        }
    }

运行结果：

上面展示的是

完全解耦

也就是目标对象与线程的完全解耦

书上是这样写的：“创建目标对象的House类并没有组合cat和dog线程对象，也就是说House创建的目标对象不包含cat和dog线程对象的引用（完全解耦），在这种情况下，目标对象经常需要获得线程的名字（因为无法获得线程对象的引用）

String name =Thread.currentThread().getName();

以便确定是哪个线程正在占用CPU资源。

那书上这一段话是什么意思呢 我看了半天都没有看懂。

思考了一番过后 我来谈谈我的理解

完全解耦的意思是 我的实现Runnable接口的那个类

也就是创建Thread类时 经常使用的 代码 Thread a=new Thread（xxxx）

这个xxx就是我们说的实现Runnable接口的类 然后我们这个类如果自身不包含Thread类成员

并且命名线程名字的时候都是在main函数 就像这样（刚才那部分代码也有）

  import java.util.*;
    import java.io.*;
    public class Main {
        public static void main(String[] args)  {
            House a=new House();


            Thread dog=new Thread(a);//他们都是用house类创建的Thread类
            Thread cat=new Thread(a);//他们都是用house类创建的Thread类
            //但是为什么可以这样 首先house类实现了Runnable接口 所以依旧可以创建 这里二者还没开始分家


            dog.setName("Dog");
            cat.setName("Cat");

而不是在类里面直接创建一个cat 或者dog的Thread类（这句话可能有点抽象 我现在给你展示）

弱耦合

import java.util.Currency;

public class House implements Runnable{

   Thread dog;
   Thread cat;
   House(){//构造函数
       dog=new Thread(this);//用this作为target来构建 说明dog和cat同时拥有相同的public run方法
       cat=new Thread(this);//用this作为target来构建 说明dog和cat同时拥有相同的public run方法
   }


    public void run(){
          while(true){
              Thread t= Thread.currentThread();
              if(t==dog){//t==dog是用地址来判断 不是线程的名字来判断的
                  System.out.println("现在是dog线程");
              }
              else if(t==cat){
                  System.out.println("现在是cat线程");
              }
          }
    }
}

public class Main {
    public static void main(String argu[]){
    House a=new House();
    a.cat.start();
    a.dog.start();
    }
}

上面的这两段代码就是弱耦合

按照书上的原话来说：”目标对象可以组合线程，将线程作为自己的成员（弱耦合），比如让线程cat和dog在House中。当创建目标对象的类组合线程对象时，目标对象可以通过获得线程对象的引用：

Thread.currentThread();

来确定哪个线程正在占用CPU资源，即被JVM正在执行。“

换句话说 也就是cat和dog这样的Thread类、

就在House这个类里面作为成员存在。

并且他们拥有相同的House类的run方法 因为你看上面的代码 他们就是用House来构建的Thread类

dog=new Thread(this);
cat=new Thread(this);

其他

书后面还有什么

线程的常用方法啊

线程同步机制的一些内容

就请同学们自己去看看书啦 那么今天的内容就到这里结束了 这篇文章也是花了我不少时间呢

方便的话麻烦点个赞捏 谢谢各位

最近想出一片关于经济的文章 不知道csdn发的出来不 发不出来就在知乎发好了

估计会耗时若干天 尽请期待