详解Javase 多线程：彻底搞懂线程(上）-阿里云开发者社区

1.进程、线程（难度：⭐⭐⭐）

1.1什么是进程？什么是线程？

进程是一个应用程序（1个进程是一个软件）。
线程是一个进程中的执行场景/执行单元。
一个进程可以启动多个线程。

1.2（举例）对于Java程序来说，什么是进程？什么是线程？

当在DOS命令窗口中输入：Java Helloword 回车之后。
首先会先启动JVM,而JVM就是一个进程。
JVM再启动一个主线程调用main方法。
同时再启动一个垃圾回收线程负责看护，回收垃圾。
最起码，现在的Java程序中至少有两个线程并发，
一个是垃圾回收线程，一个是执行main方法的主线程。

1.2.进程和线程是什么关系？举个例子

阿里巴巴：进程

马云：阿里巴巴的一个线程

保安：阿里巴巴的一个线程

京东：进程

强东：京东的一个线程

妹妹：京东的一个线程

进程可以看做是现实生活中的公司
线程可以看作是公司中的某个员工

1.2.1注意：

进程A和进程B的内存独立不共享（阿里巴巴和京东内存不会共享的！）
线程A和线程B呢？
在Java语言中：
线程A和线程B,堆内存和方法区内存共享。
但是栈内存独立，一个线程一个栈。
假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行小各自的，这就是多线程并发。
火车站中的每一个售票窗口可以看作是一个线程。
我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。
所以多线程并发可以提高效率。
Java中之所以有多线程机制，目的就是为了提高程序的处理效率。

1.3.思考一个问题：

使用了多线程之后，main方法结束，是不是有不会结束。

main方法结束只是主线程结束了，主栈空了，其他的栈（线程）可能还在压栈弹栈。

1.3.1一个线程一个栈 [ 图文 ]

1.4.对于单核的CPU来说，真的可以做到真正的多线程并发吗？

1、对于多核的CPU电脑来说，真正的多线程并发是没有问题的。

4核CPU表示同一时间点上，可以真正的有4个进程并发执行

2、什么是真正的多线程并发？

t1线程执行t1的
t2线程执行t2的
t1不会影响t2，t2也不会影响t1,这叫做真正的多线程并发。

3、单核的CPU表示只有一个大脑

不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。
对于单核CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，跟人的感觉是：多个事情同时在做！！

1.5.分析程序有几个线程

package com.newXianCheng.XianC01;
/**
 * @Description: 分析有几个线程
 * @auther:Li Ya Hui
 * @Time:2021年5月10日上午10:40:54
 */
public class Test01 {
  public static void main(String[] args) {
    System.out.println("main begin");
    m1();
    System.out.println("main over");
  }
  private static void m1() 
  {
    System.out.println("m1 begin ");
    m2();
    System.out.println("m1 over ");
  }
  private static void m2()
  {
    System.out.println("m2 begin ");
    m3();
    System.out.println("m2 over ");
  }
  private static void m3()
  {
    System.out.println("m3 execute!");
  }
}

只有一个线程主栈
没有启动分支栈，没有启动分支线程
所以这个只有一个主线程

2.实现线程的两种方式（难度：⭐⭐⭐）

其他后期再补充）

2.1.继承Thread

java支持多线程机制，并且Java已经实现了，我们只需要继承就行了

第一种方式：编写一个类，直接继承java.lang.Thread，重写run方法

package com.newXianCheng.ThreadTest02;
/**
 * @Description: 实现线程的第一种方式
 *    编写一个类，直接继承java.lang.thread 重写run方法
 * 
 *    怎么创建线程对象？
 *    怎么启动线程呢？
 * @auther:Li Ya Hui
 * @Time:2021年5月12日上午8:36:11
 */
public class Test01 {
  public static void main(String[] args) {
    //这里是main方法，这里的代码属于主线程，在主栈中运行
    //新建一个分支线程对象
    MyThread myThread = new MyThread();
    //启动线程
    //myThread.run(); //不会启动线程，不会分配新的分支栈。（这种方式就是单线程）
    //start()方法的作用是：启动一个分支线程，在jvm中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。
    //这段代码的任务只是为了开启一个新的栈空间出来，start方法就结束了，线程就启动成功了。
    //启动成功的线程会自动调用run方法，并且run方法在分支线程的栈底部（压栈）
    //run方法在分支栈的栈底部，main方法在主栈的栈底部，run和main是平级的。
    myThread.start();
    //这里的代码还是运行在主线程中。
    for (int i = 0; i < 1000; i++) {
      System.out.println("主线程"+i);
    }   
  }
}
class MyThread extends Thread{
  @Override
  public void run() {
    //编写程序，这里程序运行在分支线程中（分支栈）。
    for (int i = 0; i < 1000; i++) {
      System.out.println("分支线程"+i);
    }
  }
}

2.2.实现Runnable接口实现Run方法

实现线程的第二种方式，编写一个类实现java.lang.Runnable接口

//定义一个可运行的类
class MyRunnable implements Runnable{
  public void run() {
  }
}
//创建线程对象
Thread  t = new Thread(new MyRunnable());
//启动线程
t.start

package com.newXianCheng.RunnableTesto1;
/**
 * @Description:实现线程的第二种方式 java.lang.Runnable接口
 * @auther:Li Ya Hui
 * @Time:2021年5月12日上午10:42:58
 */
public class Test01 {
  public static void main(String[] args) {
    //创建一个可运行对象
    MyRunnable myRunnable = new MyRunnable();
    //将可运行的对象封装到一个线程对象
    Thread t = new Thread(myRunnable);
    //启动线程
    t.start();
    for (int i = 0; i < 10; i++) {
      System.out.println(Thread.currentThread().getName());
    }
  }
}
//这并不是一个线程类，是一个可运行的类，他还不是一个线程类。
class MyRunnable implements Runnable{
  @Override
  public void run() {
    for (int i = 0; i < 10; i++) {
      System.out.println(Thread.currentThread().getName());
    }
  }
}

注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其他的类，更灵活。

2.2.1采用匿名内部类可以吗？

package com.newXianCheng.RunnableTesto1;
/**
 * @Description: 采用匿名内部类可以吗？
 * @auther:Li Ya Hui
 * @Time:2021年5月12日上午11:36:02
 */
public class Test02 {
  public static void main(String[] args) {
    //创建线程对象，采用匿名内部类方式
    Thread t = new Thread(new Runnable() {
      @Override
      public void run() {
      }
    }); 
  }
}

2.3.run方法和start的区别

myThread.run(); //不会启动线程，不会分配新的分支栈。（这种方式就是单线程）
start()方法的作用是：启动一个分支线程，在jvm中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。
这段代码的任务只是为了开启一个新的栈空间出来，start方法就结束了，线程就启动成功了。
启动成功的线程会自动调用run方法，并且run方法在分支线程的栈底部（压栈）
run方法在分支栈的栈底部，main方法在主栈的栈底部，run和main是平级的。

run方法运行图

2.4.线程的生命周期

新建状态
就绪状态
运行状态
阻塞状态
死亡状态

3.线程的一些内置方法（难度：⭐⭐⭐）

3.1如何设置/获取线程的名字

获取当前线程对象？

static Thread.currentThread()

class MyThread02 extends Thread{
  public void run() 
  {
    for (int i = 0; i < 100; i++) {
      //获取当前线程的对象
      System.out.println(Thread.currentThread());
    }
  }
}

获取线程对象的名字

String name = 线程对象。getName();

修改线程对象名字

线程对象.setName(“线程名字”)；

当线程没有设置名字的时候，默认的名字有什么规律？（了解一下）

Thread-0

Thread-1

Thread-2

…

package com.newXianCheng.ThreadTest02;
/**
 * @Description: 怎么获取当前线程对象
 *         怎末获取对象的名字
 *         修改线程的名字
 * @auther:Li Ya Hui
 * @Time:2021年5月12日下午7:52:37
 */
public class Test02 {
  public static void main(String[] args) {
    //创建线程对象
    MyThread02 myThread02 = new MyThread02();
    //设置线程的名字
  myThread02.setName("tttt");
    //获取线程的名字
    String name = myThread02.getName();
    System.out.println(name);
    //启动线程
    myThread02.start();
  }
}
class MyThread02 extends Thread{
  public void run() 
  {
    for (int i = 0; i < 100; i++) {
      System.out.println("分支线程-->"+i);
    }
  }
}

3.2.线程睡眠

static void sleep(long millis)
静态方法 sleep(1000)；
参数是毫秒
作用：让当前的线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其他线程使用。

这行代码出现在A线程，A线程进入睡眠

class MyThread02 extends Thread{
  public void run() 
  {
    for (int i = 0; i < 100; i++) {
      //获取当前线程的对象
      System.out.println(Thread.currentThread().getName());
      try {
        //让当前线程每次循环运行睡眠1秒
        Thread.sleep(1000*1);
      } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }
  }
}

3.2.2sleep睡眠方法的面试题

为什么分支线程的睡眠方法会让主线程睡眠，因为sleep是静态方法

package com.newXianCheng.ThreadTest02;
/**
 * @Description: 关于Thread.slppe的一个面试题
 * @auther:Li Ya Hui
 * @Time:2021年5月12日下午9:46:25
 */
public class SleepExam {
  public static void main(String[] args) throws InterruptedException {
    //创建线程对象
    Thread thread = new Thread(new Runnable() {
      @Override
      public void run() {
        for (int i = 0; i < 10; i++) {
          System.out.println(1);
        }
      }
    });
    //尽管是分支线程调用的睡眠，但是因为 sleep是  static
    Thread.sleep(1000);
  }
}

3.3.终止线程的睡眠

sleep睡眠太久了，如果希望半道上醒来，你应该怎么办？也就是说怎么叫醒一个正在睡眠的线程呢？

重点：

run()方法当中的异常不能throws ,只能try catch
因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常。

语法

package com.newXianCheng.ThreadTest02;
/**
 * @Description: 唤醒正在睡眠的线程
 * @auther:Li Ya Hui
 * @Time:2021年5月12日下午9:46:25
 */
public class SleepExam {
  public static void main(String[] args) throws InterruptedException {
    //创建线程对象
    MyThread03 myThread03 = new MyThread03();
    Thread thread = new Thread( myThread03);
    //尽管是分支线程调用的睡眠，但是因为 sleep是  static
    thread.start();
    //唤醒线程
    thread.interrupt();
  }
}
class MyThread03 extends Thread{
  public void run() 
  {
      try {
        //让当前线程睡眠一年
        Thread.sleep(1000*60*60*24*365);
        System.out.println("s");
      } catch (InterruptedException e) {
        System.out.println("线程被中断");
      }
  }
}

3.4.线程的终止方法

3.4.1.stop方法

缺点容易造成数据损坏（不推荐使用）

//终止线程，缺点容易造成数据丢失
    thread.stop();

3.4.2.stop方法

设置一个布尔标记
什么时候想终止，直接改布尔为 false 就可以

package com.newXianCheng.ThreadTest02;
/**
 * stop方法不推荐使用
 * @Description: 怎末合理的终止一个线程 这种方式是很常用的
 * @auther:Li Ya Hui
 * @Time:2021年5月13日下午3:29:11
 */
public class Test03 {
  public static void main(String[] args) {
    //任务
    MyRunnable03 myRunnable03 = new MyRunnable03();
    //线程类
    Thread  t  = new Thread(myRunnable03);
    //线程启动
    t.start();
    try {
      //线程睡眠三秒后
      Thread.sleep(3000);
    } catch (InterruptedException e) {
    }
    //终止线程    想要什么时候终止线程t的执行，那么你把标记修改为false，就结束了
    myRunnable03.run= false ;
  }
}
class MyRunnable03 implements Runnable {
  boolean run = true;
  @Override
  public void run() {
    for (int i = 0; i < 10; i++) 
    {
      if(run==true) 
      {
        try
        {
          Thread.sleep(1000);
          System.out.println(Thread.currentThread().getName()+"  ");
        } 
        catch (InterruptedException e) 
        {
        }
      }
    }
  }
}

3.5.线程调度

3.5.1常见的线程调度模型有哪些？

抢占式调度模型

哪个线程的优先级比较高，抢到的cpu时间片的概率就高一些/多一些
java采用的就是抢占式调度模型

均分式调度模型

平均分配cpu时间片，每个线程占有的cpu时间片时间长度一样。
平均分配，一切平等。
有一些编程语言，线程调度模型采用的是这种方式

3.5.2.Java中提供了哪些方法是和线程调度有关系的呢？

线程优先级

线程优先级越高，获得CPU 时间片的概率就越大，但线程优先级的高低与线程的执行顺序并没有必然联系
void setPriority(int newPriority) 设置线程的优先级
int getPriority()获取线程优先级
最低优先级1
默认优先级5
最高优先级10
优先级比较高的获取cpu时间片可能会多一些（但也不完全是，大概率是多的）
语法

package com.newXianCheng.ThreadTest02;
/**
 * @Description: 线程优先级的使用与讲解  优先级指的是 处于运行状态的时间多一些
 * @auther:Li Ya Hui
 * @Time:2021年5月13日下午4:46:43
 */
public class Test04 {
  public static void main(String[] args) {
    //线程静态成员变量
    System.out.println("最高优先级"+Thread.MAX_PRIORITY);
    System.out.println("最低优先级"+Thread.MIN_PRIORITY);
    System.out.println("默认优先级"+Thread.NORM_PRIORITY);
    //获取当前线程对象，获取当前线程的优先级
    Thread curreThread = Thread.currentThread();
    //main线程优先级默认是5
    System.out.println(curreThread.getName() + "线程的默认优先级是："+curreThread.getPriority());
    //创建分支线程
    Thread t = new Thread(new MyRunnable4());
    //调整分支线程优先级
    t.setPriority(10);
    //调整main线程优先级
    Thread.currentThread().setPriority(1);
    //启动分支线程
    t.start();
    //优先级较高的，只是抢到的CPU时间片相对多一些
    //大概率方向更偏向于优先级比较高的
    for (int i = 0; i < 100; i++) {
      System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
  }
}
class MyRunnable4 implements Runnable{
  @Override
  public void run() {
    //获取线程优先级
//    System.out.println(Thread.currentThread().getName() + "线程的默认优先级是："+Thread.currentThread().getPriority());
    for (int i = 0; i < 300; i++) {
      System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
  }
}

让位方法

static void yield（）让位方法
暂停当前正在执行的线程对象，并执行其他线程
yield（）方法不是阻塞方法，让当前线程让位，让给其他线程使用。
yield ( )方法的执行会让当前从“运行状态”回到就绪状态。
注意：再回到就绪之后，有可能还会再次抢到。
语法

package com.newXianCheng.ThreadTest02;
/**
 * @Description: 让位，当前线程暂停，回到就绪状态，让给其他线程。
 *    静态方法：thrad.yield()：
 * @auther:Li Ya Hui
 * @Time:2021年5月13日下午5:18:23
 */
public class Test05 {
  public static void main(String[] args) {
    Thread t = new Thread(new MyRunnable5());
    t.setName("分支线程1");
    t.setPriority(1);
    t.start();
    for (int i = 1; i < 10000; i++) {
      System.out.println(Thread.currentThread().getName() + "-->" + i);
    }
  }
}
class MyRunnable5 implements Runnable{
  @Override
  public void run() {
    for (int i = 1; i < 10000; i++) {
      if (i%100 == 0)
      {       
        // 当前线程暂停一下，让给主线程。  
        //yield方法不是阻塞方法，让当前线程让位，让给其他线程使用。
        //会让当前线程从运行状态回到就绪状态 回到就绪之后，有可能还会再次抢到。
        Thread.yield();
      }
      System.out.println(Thread.currentThread().getName() + "-->" + i);
    }
  }
}

合并线程

void join （）合并线程

class MyThread extends Thread{
  public void doSome()
  {
    MyThread2 t = new MyThread2();
    t.join();//当前线程进入阻塞状态，t线程执行，直到t线程结束。当前线程才可以继续执行
  }
}

详解Javase 多线程：彻底搞懂线程(上）

1.进程、线程（难度：⭐⭐⭐）

1.1什么是进程？什么是线程？

1.3.思考一个问题：

1.3.1一个线程一个栈 [ 图文 ]

1.4.对于单核的CPU来说，真的可以做到真正的多线程并发吗？

1.5.分析程序有几个线程

2.实现线程的两种方式（难度：⭐⭐⭐）

2.1.继承Thread

2.2.实现Runnable接口实现Run方法

2.2.1采用匿名内部类可以吗？

2.3.run方法和start的区别

2.4.线程的生命周期

3.线程的一些内置方法（难度：⭐⭐⭐）

3.1如何设置/获取线程的名字

3.2.线程睡眠

3.2.2sleep睡眠方法的面试题

3.3.终止线程的睡眠

3.4.线程的终止方法

3.4.1.stop方法

3.4.2.stop方法

3.5.线程调度

3.5.1常见的线程调度模型有哪些？

3.5.2.Java中提供了哪些方法是和线程调度有关系的呢？

热门文章

最新文章

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

详解Javase 多线程：彻底搞懂线程(上）

1.进程、线程（难度：⭐⭐⭐）

1.1什么是进程？什么是线程？

1.3.思考一个问题：

1.3.1一个线程一个栈 [ 图 文 ]

1.4.对于单核的CPU来说，真的可以做到真正的多线程并发吗？

1.5.分析程序有几个线程

2.实现线程的两种方式（难度：⭐⭐⭐）

2.1.继承Thread

2.2.实现Runnable接口实现Run方法

2.2.1采用匿名内部类可以吗？

2.3.run方法和start的区别

2.4.线程的生命周期

3.线程的一些内置方法（难度：⭐⭐⭐）

3.1如何设置/获取线程的名字

3.2.线程睡眠

3.2.2sleep睡眠方法的面试题

3.3.终止线程的睡眠

3.4.线程的终止方法

3.4.1.stop方法

3.4.2.stop方法

3.5.线程调度

3.5.1常见的线程调度模型有哪些？

3.5.2.Java中提供了哪些方法是和线程调度有关系的呢？

热门文章

最新文章

相关电子书

1.3.1一个线程一个栈 [ 图文 ]