带你从零学大数据系列之Java篇---第二十章:多线程基础

课程重点:

  • 线程相关概念的理解
  • 线程的生命周期
  • 线程的常用方法

20.1. 线程的简介

20.1.1. 串行与并发

如果在程序中,有多个任务需要被处理,此时的处理方式可以有串行并发

  • 串行(同步):所有的任务,按照一定的顺序,依次执行。如果前面的任务没有执行结束,后面的任务等待。
  • 并发(异步):将多个任务同时执行,在⼀个时间段内,同时处理多个任务。
生活中, 其实有很多串行和并发的案例。 最常见的就是排队买饭。 小明到KFC吃饭, 发现有好几个窗口可以点餐。 选择了其中的一个窗口进行排队。 此时, KFC采用的模式就是串行加并发的模式。 每一个窗口之前, 有很多顾客在排队, 此时他们的任务是串行的, 前面的顾客没有处理完之后, 后面的顾客只能等待。 同时, 多个窗口之间的顾客是可以同时点餐的, 他们是并发的。
使用并发任务, 也可以在一定程度上提高效率。 例如: 小明下班回到家, 需要洗衣服、做饭、扫地。 假设, 洗衣服耗时10分钟, 做饭耗时10分钟, 洗衣服耗时10分钟, 那么这些任务如果都给小明一件件的做, 一共要耗时30分钟。 如果小明找两个帮手, 比如雇两个保姆, 他们三个人每人处理一件任务, 则共耗时10分钟。
在程序中, 有些任务是比较耗时的, 特别是涉及到非常大的文件的处理、或者网络文件的处理。 此时就需要用异步任务来处理, 否则就会阻塞主线程, 导致用户的交互卡顿。 合适的使用并发任务, 可以在一定程度上提高程序的执行效率。

20.1.2. 并发的原理

一个程序如果需要被执行, 必须的资源是CPU和内存。 在内存上开辟空间, 为程序中的变量进行数据的存储; 同时需要CPU处理程序中的逻辑。 现在处于一个硬件过剩的时代, 但是即便是硬件不发达的时代, 并发任务也是可以实现的。 以单核的CPU为例, 处理任务的核心只有一个, 那就意味着, 如果CPU在处理一个程序中的任务, 其他所有的程序都得暂停。 那么并发是怎么实现的呢?

其实所谓的并发, 并不是真正意义上的多个任务同时执行。 而是CPU快速的在不同的任务之间进行切换。 在某一个时间点处理任务A, 下一个时间点去处理任务B, 每一个任务都没有立即处理结束。 CPU快速的在不同的任务之间进行切换, 只是这个切换的速度非常快, 人类是识别不了的, 因此会给人一种“多个任务在同时执行”的假象。

因此, 所谓的并发, 其实就是CPU快速的在不同的任务之间进行切换的一种假象。

思考:
既然多个任务并发, 可以在一定程度上提高程序的执行效率, 那么并发数量是不是越高越好呢?
并不是! 多个任务的并发, 其实就是CPU在不同的任务之间进行切换。 如果并发的数量过多, 会导致分配到每一个任务上的CPU时间片较短, 也并不见得会提高程序的执行效率。 而且, 每一个任务的载体(线程)也是需要消耗资源的, 过多的线程, 会导致其他资源的浪费。
例如: 上述案例中, 我们说到了小明雇保姆干活, 那么是不是保姆越多越好呢?
不一定! 雇保姆需要花钱, 就类比于开辟线程执行并发的任务需要消耗资源一样。 那么在雇保姆的时候就得想, 你真的需要这么多保姆吗? 家里有十件事情需要处理, 那么就一定需要雇十个保姆吗? 没有必要!

20.1.3. 进程和线程

  • 进程, 是对一个程序在运行过程中, 占用的各种资源的描述。
  • 线程, 是进程中的一个最小的执行单元。 其实, 在操作系统中, 最小的任务执行单元并不是线程, 而是句柄。 只不过句柄过小, 操作起来非常的麻烦, 因此线程就是我们可控的最小的任务执行单元。

其实, 对于操作系统来说, 一个任务就是一个进程。 例如, 打开了QQ, 就是一个QQ的进程; 再打开一个QQ, 就是一个新的QQ的进程; 打开了一个微信, 就是一个微信的进程。 在一个任务中, 有的时候是需要同时处理多件事情的, 例如打开一个QQ音乐, 需要同时播放声音和播放歌词。 那么这些进程中的子任务, 就是一个个的线程。

每一个进程至少要处理一件任务, 因此, 每一个进程中至少要包含一个线程。 如果一个进程中所有的线程都结束了, 那么这个进程也就结束了。

多个线程的同时执行, 是需要这些线程去争抢CPU资源, 而CPU资源的分配是以时间片为单位的。 即某一个线程抢到了0.01秒的CPU时间片, 在这个时间内, CPU处理这个线程的任务。 至于哪一个线程能够抢到CPU时间片, 则由操作系统进行资源调度。

20.1.4. 进程和线程的异同

相同点: 进程和线程都是为了处理多个任务并发而存在的。

不同点: 进程之间是资源不共享的, 一个线程中不能访问另外一个进程中的数据。 而线程之间是资源共享的, 多个线程可以共享同一个数据。 也正因为线程之间是资源共享的, 所以会出现临界资源的问题。

20.1.5. 进程和线程的关系

一个进程, 在开辟的时候, 会自动的创建一个线程, 来处理这个进程中的任务。 这个线程被称为是主线程。 在程序运行的过程中, 还可以开辟其他线程, 这些被开辟出来的其他线程, 都是子线程。

也就是说, 一个进程中, 是可以包含多个线程。 一个进程中的某一个线程崩溃了, 只要还有其他线程存在, 就不会影响整个进程的执行。 但是如果一个进程中, 所有的线程都执行结束了, 那么这个进程也就终止了。

20.2. 线程的生命周期

20.2.1. 线程的状态

线程的生命周期, 指的是一个线程对象, 从最开始的创建, 到最后的销毁, 中间所经历的过程。 在这个过程中, 线程对象处于不同的状态。

  • New: 新生态, 一个线程对象刚被实例化完成的时候, 就处于这个状态。
  • Runnable: 就绪态, 处于这个状态的线程, 可以参与CPU时间片的争抢。
  • Run: 运行态, 某一个线程抢到了CPU时间片, 可以执行这个线程中的逻辑
  • Block: 阻塞态, 线程由于种种原因, 暂时挂起, 处于阻塞(暂停)状态。 这个状态的线程, 不参与CPU时间片的争抢。
  • Dead: 死亡态, 线程即将被销毁。

20.2.2. 线程的生命周期图

 

20.3. 线程的常用方法

20.3.1. 线程对象的实例化

在Java中, 使用Thread类来描述一个线程。 实例化一个线程, 其实就是一个Thread对象。

注意事项: 每一个线程, 开辟了之后, 一定要是去处理某些任务而存在的。 在进行线程的实例化的时候, 需要指定这个线程要处理什么任务。

常见的线程的实例化, 有以下两种方式:

20.3.1.1. 继承Thread类

继承自Thread类, 做一个Thread的子类。 在子类中, 重写父类中的run方法, 在这个重写的方法中, 指定这个线程需要处理的任务。

/**
 * @Description
 */
public class MyThread extends Thread {
    @Override
    public void run() {
        // 这个线程需要处理的任务
        for (int i = 0; i < 10; i++) {
            System.out.println("hello world");
        }
    }
}

20.3.1.2. 使用Runnable接口

在Thread类的构造方法中, 有一个重载的构造方法, 参数是 Runnable 接口。 因此, 可以通过Runnable接口的实现类对象进行Thread对象的实例化。

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // Runnable接口的匿名实现类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out,println("子线程处理的逻辑");
            }
        };
        // 实例化线程对象
        Thread thread = new Thread(runnable);
    }
}

20.3.1.3. 优缺点对比

  • 继承的方式: 优点在于可读性比较强, 缺点在于不够灵活。 如果要定制一个线程, 就必须要继承自Thread类, 可能会影响原有的继承体系。
  • 接口的方式: 优点在于灵活, 并且不会影响一个类的继承体系。 缺点在于可读性较差。
后面课程中, 用的比较多的方式是使用接口的方式。

20.3.2. 线程名字的设置

每一个线程, 都有一个名字。 如果在实例化线程的时候不去设定名字, 那么这个线程会拥有一个默认的名字。

  • 设置线程的名字, 使用方法 setName(String name)
/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("子线程的逻辑");
        });
        // 设置线程的名字
        thread.setName("子线程的名字");
    }
}
  • Thread类对象, 在进行实例化的时候, 可以同时设置线程的名字。
/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 使用接口的方式进行线程的实例化
        Thread thread = new Thread(() -> {}, "线程的名字");
    }
}
  • 如果使用继承Thread类的方式进行的实例化, 可以添加一个构造方法, 进行实例化对象的同时进行名称的设置。 在构造方法中, 使用 super(String) 进行父类方法的调用。
/**
 * @Description
 */
public class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }
    
    @Override
    public void run() {
        System.out.println("子线程的逻辑");
    }
}

设置线程名字, 可以使用上述三种方式, 但是获取线程线程的名字, 只有一个方法, 就是 getName()

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 使用接口的方式进行线程的实例化
        Thread thread = new Thread(() -> {}, "线程的名字");
        
        System.out.println(thread.getName());
    }
}

20.3.3. 线程的执行

线程对象刚刚被实例化的时候, 线程处于新生态。 如果需要让这个线程执行他的任务, 需要调用 start() 方法, 使线程进入到就绪态, 争抢CPU时间片。

注意事项:

使用start()方法, 不是run()方法!

使用start方法, 会使得线程进入到就绪态, 开始争抢CPU时间片, 实现并发的任务。 如果直接调用run方法, 那么任务将会直接在当前线程中执行, 并不会实现并发!

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 使用接口的方式进行线程的实例化
        Thread thread = new Thread(() -> {}, "线程的名字");
        thread.start();
    }
}

20.3.4. 线程的礼让

线程礼让, 就是是的当前已经抢到CPU资源的正在运行的线程, 释放自己持有的CPU资源, 回到就绪状态, 重新参与CPU时间片的争抢。

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 使用接口的方式进行线程的实例化
        Runnable runnable = () -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + " : " + i);
                if (i == 5) {
                    Thread.yield();
                }
            }
        };
        // 实例化两个线程, 处理的逻辑完全相同
        Thread thread0 = new Thread(runnable, "t0");
        Thread thread1 = new Thread(runnable, "t1");
        
        thread0.start();
        thread1.start();
    }
}

20.3.5. 线程的休眠

线程休眠, 就是让当前的线程休眠指定的时间。 休眠的线程进入到阻塞状态, 直到休眠结束。 阻塞的线程, 不参与CPU时间片的争抢。

注: 线程休眠的时间单位是毫秒。

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 使用接口的方式进行线程的实例化
        Runnable runnable = () -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + " : " + i);
                try {
                    // 线程休眠
                    Thread.sleep(1000);
                }
                catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        // 实例化两个线程, 处理的逻辑完全相同
        Thread thread0 = new Thread(runnable, "t0");
        Thread thread1 = new Thread(runnable, "t1");
        
        thread0.start();
        thread1.start();
    }
}

20.3.6. 线程的合并

将一个线程中的任务, 合并入到另外一个线程中执行, 此时, 合并进来的线程有限执行。 类似于: 插队。

/**
 * @Description
 */
public class Program {
    // 记录余票数量
    static int ticketCount = 100;
    
    public static void main(String[] args) {
        // 循环卖票
	   while (ticketCount > 0) {
           // 票数 -1
	   	  System.out.println("窗口卖出一张票给散客,剩余: " + --ticketCount);
	   	  // 卖出 30 张
	   	  if (ticketCount == 70) {
              // 实例化⼀个 VIP 团体线程
              Thread vip = new Thread(() -> {
                  for (int i = 0; i < 50; i++) {
                      System.out.println("窗口卖出一张票给VIP团队,剩余: " + --ticketCount);
                  }
              });
	   		// 先开启
	   		vip.start();
	   		// 再合并
	   		try {
	   			vip.join();
	    	} catch (InterruptedException e) {
	   			e.printStackTrace();
	    	}
          }
       }
	  Thread thread = new Thread(runnable);
	  thread.start();
    }
}

20.3.7. 线程的优先级设置

设置线程的优先级, 可以决定这个线程能够抢到CPU时间片的概率。 线程的优先级范围在 [1, 10], 默认的优先级是5。 数值越高, 优先级越高。 但是要注意, 并不是优先级高的线程一定能抢到CPU时间片, 也不是优先级的线程一定抢不到CPU时间片。 线程的优先级只是决定了这个线程能够抢到CPU时间片的概率。 即便是优先级最低的线程, 依然可以抢到CPU时间片。

/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 使用接口的方式进行线程的实例化
        Runnable runnable = () -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " : " + i);
            }
        };
        // 实例化两个线程, 处理的逻辑完全相同
        Thread thread0 = new Thread(runnable, "t0");
        Thread thread1 = new Thread(runnable, "t1");
        
        // 设置线程的优先级, 必须在这个线程启动之前
        thread0.setPriority(1);
        thread1.setPriority(10);
        
        thread0.start();
        thread1.start();
    }
}

20.3.8. 当前线程的获取

  • Thread.currentThread() : 可以用在任意的位置, 获取当前的线程。
  • 如果是Thread的子类, 可以在子类中, 使用this获取到当前的线程。

20.3.9. 守护线程

守护线程, 又叫后台线程。 是一个运行在后台, 并且会和前台线程争抢CPU时间片的线程。

  • 守护线程依然会和前台线程争抢CPU时间片, 实现并发的任务。
  • 在一个进程中, 如果所有的前台线程都结束了, 后台线程即便任务没有执行结束, 也会自动结束。
/**
 * @Description
 */
public class Program {
    public static void main(String[] args) {
        // 实例化一个线程
        Thread thread = new Thread(() -> {
            while (true) {
                System.out.println("守护线程在运行");
                try {
                	Thread.sleep(1000);    
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 将一个线程设置为守护线程
        thread.setDaemon(true);
        // 开启线程
        thread.start();
        
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程: " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
展开阅读全文
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值