【Java】多线程(篇一) : 通过Thread类创建线程的方法

hello，我是~小鹿，对你有帮助可以收藏随时找到这里哦

线程(Thread)本身是操作系统提供 的概念
操作系统也提供了一些API供程序猿使用(Linux的pythread库)
Java中, 就把操作系统的API又进行了封装,提供了Thread类
学习使用这个类 就可以完成多线程的编程

Thread类是由JVM用来管理线程的一个类
在Java中 每个线程执行流都是通过Thread类的对象来描述的
JVM会将这些Thread对象组织起来,用于线程调度,线程管理

1. 创建一个类, 继承Thread, 重写run方法

用线程来写一个简单的 hello word:

代码:

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("hello word");
    }
}

public class demo {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

讲解:
创建线程需要先继承一个java标准库中自带的类Thread
Thread 是来自于 java.lang 这个包
java.lang 这个包比较特殊 不需要手动 import 直接默认就能使用

class MyThread extends Thread{
    @Override
    //让子类重写父类的方法:
    public void run() {
        System.out.println("hello word");
    }
}

这里的 run方法就相当于线程的入口
线程具体跑起来之后 要什么事情都是通过这个run来描述的

public class demo {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }

这里的 start 就是在创建线程 :
这个操作就会在底层调用操作系统提供的"创建线程"的API , 同时就会在操作系统内核里创建出对应的pcb结构 , 并加入到对应的链表中.
此时在这个新创建出来的线程就会参与到 cpu 的调度中.
这个线程接下来要执行的工作就是刚刚上面重写的 run方法.

当点击运行程序后 就会创建出一个java进程
(这个示例包含两个线程 : 执行 main 方法的线程 以及自己创建的 执行 run方法的线程)
这个进程中就包含了至少一个线程, 这个线程也叫做主线程,也就是负责执行的main方法的线程

每个线程都能被独立的调度执行
也就是说当执行到 myThread.start() 时 , 此时由两个线程在同时执行 : 执行 main 方法的线程 以及自己创建的 执行 run方法的线程

public class demo {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.run();
    }

当直接调用run方法时 , 也是可以运行出 hello world 的
但 run 只是上面的入口方法(就是普通的方法)
并没有调用系统 api , 也就是没有创建出真正的线程

多线程的无限循环 以及调试器

多线程的无线循环hello thread , hello main :
代码:

class MyThread extends Thread{
    @Override
    public void run() { //创建的新线程
        while(true) { //新线程任务:
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class demo {
    public static void main(String[] args) throws InterruptedException { //主线程
        MyThread myThread = new MyThread();
        myThread.start();

        while(true){ //主线程任务
            System.out.println("hello mian");
            Thread.sleep(1000);
        }
    }
}

讲解:

class MyThread extends Thread{
    @Override
    public void run() { 
        while(true) {
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Thread.sleep() : 让线程休眠一段时间后自动唤醒
这里 Thread.sleep(1000) 指让线程休眠1秒后自动唤醒
目的是让循环输出的慢一点(方便观察)

注意使用 Thread.sleep 需要抛异常
此处的 run 方法是重写 , 对于父类的 run 方法来说 , 就没有throws xxx 这种异常这样的设定 , 所以在重写的时候就不能throws异常了
所以只能使用 try catch 不能 throws

    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.start();

        while(true){ 
            System.out.println("hello mian");
            Thread.sleep(1000);
        }
    }

当运行 myThread.start() 时 :
创建出新的线程 执行run中的代码

原来的主线程继续往下执行 也就是hello main
主线程 和 新线程 分别执行自己的循环
这两个线程都能参与到cpu的调度当中
这俩的线程(这俩的while循环)并发式的执行

每个线程都是独立的执行流 , 每个线程都可以执行一段代码 , 多个线程之间时并发关系

运行后结果并不是有规律的交替打印 hello thread 与 hello main

当两个线程都唤醒后 谁先调度谁后调度可以视为"随机"的
这样的"随机"调度过程 , 称为 “抢占式执行”

调试器

当创建出线程后 , 也是可以通过一些方式直观的观察到 :
1. idea调试器
点击debug 调试

随便打一个断点

在idea左下角 点击

可以查看线程的运行情况

2. jconsole (常用)
这是官方在 jdk 中给我们提供的一个调试工具
打开自己的 jdk 所在位置 -> bin -> jconsole

如果不知道自己 jdk 所在位置:
在idea中 : File -> project structure -> SDKs
这里包含 jdk 所在路径

程序运行后 -> 点击 jconsole -> 上面会列出系统正在运行的所有java进程
如果一个都不显示 -> 右键 ->按照管理员方式运行

点击 demo -> 连接

(若出现这个点击不安全连接即可)

点击线程:

左下角会列出当前进程中所有的线程:
不仅仅是主线程(main) 和 自己创建的线程(Thread-0)
剩下的都是JVM里自带的负责完成一些其他方面的工作

点击某个线程 右边会显示该线程的详细信息

2. 创建一个类, 实现Runnable , 重写 run 方法

使用 Runnable 的方法来创建线程

与上一个多线程的无限循环基本一样

区别:

• Thread这里是直接把要完成的工作,放到了 Thread 的 run 方法中.

• Runnable这里 则是分开了 , 把要完成的工作放到 Runnable 中,在让 Runnable 和 Thread 配合 , 把线程要执行的任务和线程本身进一步结合了.

• 采用并发编程的方式 来完成某个工作
  使用Runnable描述这个工作的具体细节

代码 :

class MyRunnable implements Runnable{//接口
    @Override
    public void run() {
        while(true) {
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class demo {
    public static void main(String[] args) throws InterruptedException {
        MyRunnable runnable = new MyRunnable();
        // runnable.start();  光一个Runnable是没有start方法的
        Thread t = new Thread(runnable);//需要把它传到构造方法里
        t.start();//然后通过start方法启动线程

        while(true){
            System.out.println("hello mian");
            Thread.sleep(1000);
        }
    }
}