Java创建线程

目录

既然说到线程，在这里就给大家普及一下线程。

线程（Thread）：

那么，进程是什么呢？

接下来，就让我们步入主题：

在 Java 中，是这样说线程的：

创建一个新的执行线程有两种方法。 

第一种：创建一个类实现 Thread 类

 创建线程的第二种方式：使用 Thread(Runnable target) 构造方法，创建对象

---

既然说到线程，在这里就给大家普及一下线程。

🎇🎇🎇🎇🎇🎇🎇🎇

线程（Thread）：

• 是操作系统能够进行运算调度的最小单位。
• 它被包含在进程之中，是进程中的实际运作单位。
• 一个线程指的是进程中一个单一顺序的控制流。

🥂🥂🥂

其实：进程在我们计算机中我们随时都在使用：按住 Ctrl + shift + esc

这个就是一个进程，在计算机中，线程就是进程中的一个执行单元。

那么，进程是什么呢？

进程：简简单单，我们日常中使用的QQ就是一个进程，进程可以理解为就是一个软件，线程则就是这个软件中的一些功能，多个线程同时工作，才能使得进程工作。🤔🤔🤔。

使用官方的话来描述进程：

是计算机中的程序关于某数据集合上的一次运行活动，是操作系统进行资源分配与调度的基本单位。

接下来，就让我们步入主题：

⏰⏰⏰⏰⏰⏰⏰⏰⏰⏰⏰⏰⏰⏰⏰⏰⏰⏰⏰⏰

在 Java 中，是这样说线程的：

Java中，Thread类定义为：继承 了祖先类 Object ，实现了 Runable 接口。

public class Thread extends Object implements Runnable

线程是程序（进程）中执行的线程。

Java虚拟机允许应用程序同时执行多个执行线程。 

每个线程都有优先权。 具有较高优先级的线程优先于优先级较低的线程执行。 每个线程可能也可能不会被标记为守护程序。 当在某个线程中运行的代码创建一个新的Thread对象时，新线程的优先级最初设置为等于创建线程的优先级，并且当且仅当创建线程是守护进程时才是守护线程。 

当Java虚拟机启动时，通常有一个非守护进程线程（通常调用某些指定类的名为main的方法）。 Java虚拟机将继续执行线程，直到发生以下任一情况： 

已经调用了Runtime类的exit方法，并且安全管理器已经允许进行退出操作。 
所有不是守护进程线程的线程都已经死亡，无论是从调用返回到run方法还是抛出超出run方法的run 。 

创建一个新的执行线程有两种方法。 

第一种：创建一个类实现 Thread 类

package stu.my.cdn.creadthread.p1;

/**
 * 创建线程的第一种方式：创建类，实现 Thread 方法
 */
public class MyThread extends Thread {

    /**
     * run () 方法就是子线程要执行的代码
     */
    @Override
    public void run() {
        System.out.println("这是子线程打印的东西");
    }

    /**
     * 主线程 main
     */
    public static void main(String [] args) {
        System.out.println("JVM 启动 main线程，main线程执行了main方法");
        // 创建子线程对象
        MyThread thread = new MyThread();
        // 启动线程----启动线程后，会自动执行自定义类中的 run 方法
        thread.start();
        System.out.println("mian 主线程执行结束");
    }
}

 以下是程序的输出结果：

这种程序执行分为三种方式：

串行：特殊的并行，程序排队执行，比较耗时，但安全。 

并发：一个程序执行，在等待阶段，下一个开始。

并行：简单粗暴，程序一起开始执行，一般效率高。

从硬件角度来说：如果是单核 CPU ，一个处理器一次只能执行一个线程的情况下，处理器可以使用时间片轮转技术，可以让 CPU 快速的在各个线程之间进行切换，对用户来说，感觉是三个线程在同时执行，如果是多核 CPU ，可以为不同的线程分配不同的 CPU 内核。

package stu.my.cdn.creadthread.p2;

public class MyThread2 extends Thread{

    @Override
    public void run() {
        // 处理异常快捷键 ，选中代码： Ctrl + Alt + T
        try {
            for(int i = 1; i <= 5; i++){
                System.out.println("子线程==>" + i);
                int time = (int) (Math.random() * 1000);
                Thread.sleep(time);     // 线程睡觉，单位是 毫秒， 1s = 1000ms
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        MyThread2 myThread2 = new MyThread2();
        myThread2.start();      // 开启子线程

        try {
            for(int i = 1; i <= 5; i++){
                System.out.println("主线程main==>" + i);
                int time = (int) (Math.random() * 1000);
                Thread.sleep(time);     // 线程睡觉，单位是 毫秒， 1s = 1000ms
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

 第一次执行顺序：

 

第二次执行顺序 ：

 

 创建线程的第二种方式：使用 Thread(Runnable target) 构造方法，创建对象

如果已经类已经有了继承的父类，则第一种方式便不再使用这种情况，（因为在JAVA中一个类只能有一个父类）：🤔🤔🤔🤔

 那我们便可以使用这种方式：实现接口，使用构造方法，创建线程：

 

package stu.my.cdn.creadthread.p3;

/**
 * 当线程已经有父类了，就不能继承 Thread 类的形式创建线程了，可以使用 Runnable 接口的形式
 */
public class MyRunnable implements  Runnable{
    /**
    * 这里的 run 方法 就相当于我们日常中使用的 main 方法
    * 一旦 线程 start() 就会执行这个方法 
    */
    @Override
    public void run() {
        for(int i = 0; i <= 5; i++){
            System.out.println("MyRunnable implements Runnable 's run method:" + i);
        }
    }

    public static void main(String[] args) {
        // 创建 Runnable 接口的实现类
        MyRunnable myRunnable = new MyRunnable();
        // 使用 Runnable 的 Thread(Runnable target) 方法，创建线程对象
        Thread thread = new Thread(myRunnable);
        // 开启线程
        thread.start();

        // main 线程
        for (int i = 1; i <= 5; i++){
            System.out.println("Runnable is main:" +i);;
        }

        // 使用匿名内部内实现
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0; i < 5; i++){
                    System.out.println("use anonymous interior class finished thread create :" + i);
                }
            }
        });
        // 开启 thread1
        thread1.start();
    }
}

 一样，线程每次并行执行，根据 CPU 核数的不同和允许执行线程的数量，利用对应的技术，在各个线程之间切换，提高执行的效率。

 

 本期就到这里~~~

感谢大家阅读~~~

​