【Java中Tread和Runnable创建新的线程的使用方法】

喜欢博主的关注一下,不喜欢的再看看。٩( •̀㉨•́ )و get!

文章目录

  • 前言
  • 一、继承Thread
  • 二、实现Runnable
  • 三、匿名内部类
    • 1. 扩展Thread类
    • 2. 扩展Runnable类
  • 四、lambda表达式写法
  • 五、Java 的线程 和 操作系统线程 的关系


前言

什么是线程?

线程(Thread)是操作系统能够进行运算调度的最小单位,它被包含在进程中,是进程中的实际执行单位。与进程不同的是,同一进程中的线程共享相同的内存空间,可以访问进程中的共享数据,线程的切换开销比进程小,因此线程通常比进程更高效。线程也被称为轻量级进程。

线程可以并发执行,一个进程中可以包含多个并发执行的线程,每个线程可以独立地执行不同的任务。在多核处理器的情况下,多个线程可以被分配到不同的核心上同时执行,从而提高处理器的利用率和程序执行的效率。


创建线程的不同方式

一、继承Thread

//自定义类MyThread
class MyThread extends Thread {//继承Thread重写run()
    @Override
    public void run() {//线程入口
        while (true) {
            System.out.println("Hello MyThread!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();//会创建新的线程,执行run()
        //t.run();//同样会执行run方法,但是不会创建新的线程

        while (true) {//main线程执行的任务
            System.out.println("Hello main!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

二、实现Runnable

//自定义MyRunnable类
class MyRunnable implements Runnable {//实现Runnable接口,重写run()
    @Override
    public void run() {
        while (true) {
            System.out.println("Hello t!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) {
    	//Runnable不能直接使用
        MyRunnable runnable = new MyRunnable();
        //需要将runnable放入Thread中才能调用
        Thread t = new Thread(runnable);
        t.start();
    }
}

三、匿名内部类

1. 扩展Thread类

public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread() {//匿名内部类,扩展Thread
          @Override
          public void run() {
              while (true) {
                  System.out.println("Hello t");
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          }
        };

        t.start();

        while (true) {
            System.out.println("Hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2. 扩展Runnable类

public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {//匿名内部类,扩展Runnable
            @Override
            public void run() {
                while (true) {
                    System.out.println("Hello t");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        t.start();

        while (true) {
            System.out.println("Hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

四、lambda表达式写法

lambda实际也是匿名内部类的一种简洁写法

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {//lambda表达式写法,推荐写法
        //{}内就是run()方法内部
            while (true) {
                System.out.println("Hello t");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t.start();

        while (true) {
            System.out.println("Hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

五、Java 的线程 和 操作系统线程 的关系

  • Java 的线程是建立在操作系统线程之上的。Java 程序通过 JVM(Java 虚拟机)来运行,JVM 将 Java线程映射到操作系统线程上,以便在操作系统上调度和执行。
  • 操作系统线程是由操作系统负责管理的,因此 Java 程序需要在操作系统上获得足够的权限才能访问和操作这些线程。
  • Java 线程管理和操作系统线程管理的主要区别在于,Java 线程的创建、销毁和调度是由 JVM 来完成的,而不是由操作系统来完成的。
  • Java 线程的资源消耗相对较小,因为 Java 线程的创建和销毁是由 JVM 来完成的,而不是由操作系统来完成的(操作系用的调用会消耗更多的资源),这也就意味着 Java 应用程序可以同时运行更多的线程,而不需要过多地消耗系统资源。
简单来说
  1. 线程是操作系统中的概念. 操作系统内核实现了线程这样的机制, 并且对用户层提供了一些 API 供用户使用(例如 Linux 的 pthread 库)

  2. Java 标准库中 Thread 类可以视为是对操作系统提供的 API 进行了进一步的抽象和封装

你可能感兴趣的:(java,java-ee)