Java 创建线程

Java创建线程有两种方法，启动线程会默认调用run方法

方法一

继承Thread类，重写run方法

创建子线程

public class Thread_01 extends Thread{

    @Override
    public void run() {

    }

}

在测试类中启动子线程

    @Test
    public void test01(){
//        创建子线程对象
        Thread_01 thread_01 = new Thread_01();
//        启动子线程
        thread_01.start();
    }
}

方法二

实现Runnable接口，实现接口中的run方法

创建子线程

public class Thread_02 implements Runnable{
    
    @Override
    public void run() {
        
    }
    
}

在测试类中启动子线程

    @Test
    public void test01(){
//        创建子线程对象
        Thread_02 thread_02 = new Thread_02();
        Thread thread = new Thread(thread_02);
//        启动子线程
        thread.start();
    }
}

示例

执行三个循环，两个子线程各执行一个循环，主线程执行一个循环，每个循环花费10秒钟

创建子线程MyThread_01

public class MyThread_01 extends Thread{

    @Override
    public void run() {
        for (int i = 0;i < 10;i++){
            System.out.println("This is Thread_01" + " " + i);
            try {
//                睡眠一秒
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

创建子线程MyThread_02

public class MyThread_02 implements Runnable{

    @Override
    public void run() {
        for (int i = 0;i < 10;i++){
            System.out.println("This is Thread_02" + " " + i);
            try {
//                睡眠一秒
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

测试类

在测试类中记录执行三个循环所花费的时间

public class MyTest {

    @Test
    public void test(){
        Date time1 = new Date();

//        创建MyThread_01子线程对象
        MyThread_01 myThread_01 = new MyThread_01();
//        启动子线程
        myThread_01.start();

//        创建MyThread_02子线程对象
        MyThread_02 myThread_02 = new MyThread_02();
        Thread thread = new Thread(myThread_02);
//        启动子线程
        thread.start();

        for (int i = 0;i < 10;i++){
            System.out.println("This is main" + " " + i);
            try {
//                睡眠一秒
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        Date time2 = new Date();
        System.out.println("执行时间：" + (time2.getTime()-time1.getTime())/1000);

    }
}

效果演示

通过执行结果我们可以发现：执行三个循环用了10秒钟，多线程执行是没有规律的

一个循环花费10秒，而使用多线程执行三个循环一共花费了10秒，所以这里就涉及到了线程的并行和并发

并行和并发的区别

并发：任务数大于CPU核心数，CPU在不同任务上切换，在一个任务上执行一段时间再切换到另一个任务上执行一段时间

并行：只能发生在多核CPU上，任务数小于或等于CPU核心数，CPU同时执行多个任务

并行：在一个“时间点”有多个任务同时执行

---

并发：在一个“时间段”有多个任务同时执行

---

有不对的地方还请指出呀，一定虚心请教 [嘻嘻]