JAVA Review-应用程序开发-JAVA多线程-多线程实现方式

小鱼儿 2022-05-22 09:53 286阅读 0赞

前言

本章节中我们将学习一下JAVA多线程的实现方式。首先在学习JAVA多线程之前我们需要明白几个问题:

  • java 多线程是什么鬼,它和程序、进程之间有什么苟且?
  1. * 程序
  2. 通常而言我们可以将程序定义为是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码,静态对象。
  3. * 进程
  4. 是程序的一次执行过程,或是正在运行的一个程序。 进程是指运行中的应用程序,每个进程都有自己独立的地址空间(内存空间),比如用户点击桌面的IE浏览器,就启动了一个进程,操作系统就会为该进程分配独立的地址空间。当用户再次点击左面的IE浏览器,又启动了一个进程,操作系统将为新的进程分配新的独立的地址空间。目前操作系统都支持多进程。
  5. * 线程
  6. 是进程中的一个实体,是被系统独立调度和分派的基本单位,线程自己不拥有系统资源,只拥有一点在运行中必不可少的资源,但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程,同一进程中的多个线程之间可以并发执行。线程有就绪、阻塞和运行三种基本状态。
  • 在哪些场景中我们需要用到多线程,多线程有什么优劣势?

    • 应用场景
  1. * 程序需要同时执行两个或多个任务。
  2. * 程序需要实现一些需要等待的任务时,如用户输入、文件读写操作、网络操作、搜索等。
  3. * 需要一些后台运行的程序时。
  4. * 优劣势
  5. * 优势
  6. * 用户体验更友好,能多并发地完成用户派遣的任务。
  7. * 提升CPU使用率。
  8. * 劣势
  9. * 线程过多时在线程切换过程中或消耗系统资源。

实现方法

在JAVA 中多线程实现有两种方法:继承Thread 类(最终也是实现Runnable接口)和实现Runnable 接口。

  • 继承Thread类

    • 基本实现步骤

      • 定义子类继承Thread类。
      • 子类中重写Thread类中的run方法。
      • 创建Thread子类对象,即创建了线程对象。
      • 调用线程对象start方法:启动线程,调用run方法。
    • 例子

      • 场景说明
        开启三个线程来实现三个生产者各自生产100件产品的实现
      • 代码示例

        1. package coreJavaReview.thread;
        2. /** * 实现多线程的两种方式 * 使用继承Thread类的方式实现多线程 * @author Administrator * */
        3. public class ThreadCreateByEnxtends {
        4. public static void main(String[] args) {
        5. productor1 p1 = new productor1();
        6. productor2 p2 = new productor2();
        7. productor3 p3 = new productor3();
        8. p1.setName("第一个生产者");
        9. p2.setName("第二个生产者");
        10. p3.setName("第三个生产者");
        11. p1.start();
        12. p2.start();
        13. p3.start();
        14. }
        15. }
        16. //第一个生产者在生产
        17. class productor1 extends Thread{
        18. int i = 0;
        19. public void run(){
        20. while(true){
        21. if(i<100){
        22. i++;
        23. System.out.println(Thread.currentThread().getName()+":在生产第"+i+"件产品!");
        24. }else{
        25. break;
        26. }
        27. }
        28. }
        29. }
        30. //第二个生产者在生产
        31. class productor2 extends Thread{
        32. int i = 0;
        33. public void run(){
        34. while(true){
        35. if(i<100){
        36. i++;
        37. System.out.println(Thread.currentThread().getName()+":在生产第"+i+"件产品!");
        38. }else{
        39. break;
        40. }
        41. }
        42. }
        43. }
        44. //第三个生产者在生产
        45. class productor3 extends Thread{
        46. int i =0;
        47. public void run() {
        48. while (true) {
        49. if (i < 100) {
        50. i++;
        51. System.out.println(Thread.currentThread().getName() + ":在生产第" + i + "件产品!");
        52. } else {
        53. break;
        54. }
        55. }
        56. }
        57. }
  • 实现Runnable接口

    • 基本步骤

      • 定义子类,实现Runnable接口。
      • 子类中重写Runnable接口中的run方法。
      • 通过Thread类含参构造器创建线程对象。
      • 将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法中。
      • 调用Thread类的start方法:开启线程,调用Runnable子类接口的run方法。
    • 示例说明

      • 例子

        • 场景说明
          开启三个线程来实现三个生产者各自生产100件产品的实现
        • 代码示例

          1. package coreJavaReview.thread;
          2. /** * 实现多线程的两种方式 使用 实现Runable接口 * * @author Administrator * */
          3. public class ThreadCreateByRunable {
          4. public static void main(String[] args) {
          5. Productor4 p4 = new Productor4();
          6. Productor5 p5 = new Productor5();
          7. Productor6 p6 = new Productor6();
          8. Thread t4 = new Thread(p4);
          9. //Thread t5 = new Thread(p4);
          10. //Thread t6 = new Thread(p4);
          11. Thread t5 = new Thread(p5);
          12. Thread t6 = new Thread(p6);
          13. t4.setName("第一个Tread");
          14. t5.setName("第二个Tread");
          15. t6.setName("第三个Tread");
          16. t4.start();
          17. t5.start();
          18. t6.start();
          19. }
          20. }
          21. // 第一个生产者在生产
          22. class Productor4 implements Runnable {
          23. int i = 0;
          24. public void run() {
          25. while (true) {
          26. if (i < 100) {
          27. i++;
          28. System.out.println(Thread.currentThread().getName() + ":在生产第" + i + "件产品!");
          29. } else {
          30. break;
          31. }
          32. }
          33. }
          34. }
          35. //第二个生产者在生产
          36. class Productor5 implements Runnable {
          37. int i = 0;
          38. public void run() {
          39. while (true) {
          40. if (i < 100) {
          41. i++;
          42. System.out.println(Thread.currentThread().getName() + ":在生产第" + i + "件产品!");
          43. } else {
          44. break;
          45. }
          46. }
          47. }
          48. }
          49. //第三个生产者在生产
          50. class Productor6 implements Runnable {
          51. int i = 0;
          52. public void run() {
          53. while (true) {
          54. if (i < 100) {
          55. i++;
          56. System.out.println(Thread.currentThread().getName() + ":在生产第" + i + "件产品!");
          57. } else {
          58. break;
          59. }
          60. }
          61. }
          62. }

小结

Extends Thread VS Implements Runnable:

  • 继承Thread时线程代码存放Thread子类run方法中。
  • 实现Runnable时线程代码存在接口的子类的run方法。
  • 通常而言我们更建议使Implements Runnable的方式来完成多线程的实现
  1. * 避免了单继承的局限性
  2. * 多个线程可以共享同一个接口实现类的对象,非常适合多个相同线程来处理同一份资源。(这将关系到线程安全问题,后面的章节我们将会学习到)。

发表评论

表情:
评论列表 (有 0 条评论,286人围观)

还没有评论,来说两句吧...

相关阅读

    相关 线——java实现线方式

    1、线程和进程 要理解多线程,我们必须首先弄清楚线程和进程的概念。在上一篇博文总已经较为详细的介绍过,本篇博文只做总结。 进程就是运行的程序,每个进程都有独立的代码和数据