Java中线程的创建和使用。进程、线程、并发、并行的基本介绍。1.通过继承Thread类。2.通过实现Runable接口。

基本介绍

• 进程(Process)：正在运行的程序实例。它包括程序代码、执行状态、打开的文件、使用的资源等。在Java中，可以通过Runtime类或ProcessBuilder类来创建和控制进程。
• 线程(Thread)：进程中独立运行的一段代码。它可以与其他线程共享进程的资源，也可以拥有自己的资源。Java中可以通过Thread类和Runnable接口来创建和控制线程。
• 并发(Concurrency)：多个任务在同一时间段内执行，在同一时刻只执行一个进程，在极短的时间内交替执行各个进程。它们之间可能会相互影响或者协同工作。Java中并发编程可以使用synchronized关键字、Lock接口、volatile关键字等方式来实现线程之间的同步和互斥。
• 并行(Parallelism)：多个任务在同一时间段内同时执行 ，在同一时刻执行多个多个进程，各自独立地工作。Java中可以使用Executor框架和Fork/Join框架来实现并行计算。在Java 8之后，还可以使用Stream API和Parallel Stream API来实现并行计算。

1.通过继承Thread类来创建线程

通过一段代码来实现线程的创建：通过继承Thread类。
步骤：

1. 继承Thread类，保证该类重写run()方法来实现线程中要执行的代码
2. 在run()方法中实现自己的业务
3. 创建该类的对象,调用start方法来启动进程

注意：

1. 开一个线程是通过调用start()方法 ,最终会执行Tag类中的run方法。不会阻塞主线程,线程之间交替执行。在start()中主要是调用private native void start0();其中native是本地的,是JVM来调用的。而不是直接调用run()方法，run()方法只是一个普通的方法，调用此方法并不会启动线程。
2. 当主线程main结束后程序(进程)并不会退出 ,因为还有子线程没有结束,当所有的线程都结束后程序(进程)才会结束

public class ThreadUse {
    public static void main(String[] args) throws InterruptedException {
        Tag tag = new Tag();
        tag.start();//开一个线程,最终会执行Tag类中的run方法。不会阻塞主线程,线程之间交替执行。这边的start()中主要是调用private native void start0();其中native是本地的,是JVM来调用的
        //tag.run();//run方法就是Tag类中的一个普通方法,并没有开一个线程,这边程序会把run方法执行完毕后才会向下执行
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程名"+Thread.currentThread().getName());//获取线程名
            Thread.sleep(1000);//当主线程main结束后程序(进程)并不会退出,因为还有子线程没有结束,当所有的线程都结束后程序(进程)才会结束
        }
    }

}


class Tag extends Thread{
    int times =0;
    @Override
    public void run() {
        while (true){
        System.out.println("冲啊"+Thread.currentThread().getName());
            try {
                Tag.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(++times == 8){
                break;
            }
        }
    }
}

2.通过实现Runable接口来创建线程

通过一段代码来实现线程的创建：通过实现Runnable接口。

步骤：

1. 实现Runnable接口，保证该类重写run()方法来实现线程中要执行的代码
2. 在run()方法中实现自己的业务
3. 创建该类的对象,创建Thread类的对象，并将该类的对象作为Thread类的形参 ，因为该类的对象无法调用start方法，只能通过Thread类的对象来调用start方法 。这是一种代理模式。

注意：

1. 开一个线程无法通过该类的对象来调用start()方法，只能将该类的对象作为Thread类的形参，通过Thread类的对象来调用start方法 ,之后的步骤和继承Thread类一样。最终会执行Tag类中的run方法。不会阻塞主线程,线程之间交替执行。在start()中主要是调用private native void start0();其中native是本地的,是JVM来调用的。而不是直接调用run()方法，run()方法只是一个普通的方法，调用此方法并不会启动线程。
2. 当主线程main结束后程序(进程)并不会退出 ,因为还有子线程没有结束,当所有的线程都结束后程序(进程)才会结束

public class RunnableUse {
    public static void main(String[] args) {
        Tag tag = new Tag();
        //tag.start();tag中没有start方法,因为这里是implements的Runnable而不是extends的Thread,Thread类中才有start方法
        Thread thread = new Thread(tag);//这边相当于是一个代理模式
        thread.start();
    }
}

class Tag implements Runnable{
    int times =0;
    @Override
    public void run() {//这个run()并非是Thread类中的方法,而是Thread类实现接口Runnable的方法:public abstract void run();
        while (true){
            System.out.println("冲啊"+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(++times == 8){
                break;
            }
        }
    }
}