java线程的创建

一个标准的线程由：bai线程ID，当前指令指针(PC），寄du存器集zhi合和堆栈组成。

线程有时被称为轻量级进dao程，是程序执行流的最小单元。

线程ID：线程标识符
当前指令指针（PC）
寄存器集合：存储单元寄存器的集合

堆栈：堆栈是两种数据结构。堆栈都是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。在单片机应用中，堆栈是个特殊的存储区，主要功能是暂时存放数据和地址，通常用来保护断点和现场。要点：堆，队列优先,先进先出。栈，先进后出。

方式一：继承于Thread类
1.创建一个继承于Thread类的子类
2.重写Thread类的run() —> 将此线程执行的操作声明在run()中
3.创建Thread类的子类的对象
4.通过此对象调用start()
例子：遍历一百以内的所有的偶数

package com.atguigu.java;


/**
* @author ljs
* @create 2020-05-31-10:08
*/
public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类的对象
        MyThread myThread = new MyThread();


        //4.通过此对象调用start()：①启动当前线程 ②调用当前线程的run()
        myThread.start();

//问题一：
//我们不能通过直接调用run()的方式启动线程。
//      myThread.run();
//问题二：
//再启动一个线程遍历100以内的偶数，不可以还让已经start()的线程去执行，会报 IllegalThreadStateException异常
//      myThread.start();
        //我们需要重新创建一个线程的对象
        MyThread myThread1 = new MyThread();
        myThread1.start();


        //主线程
        for (int i = 0; i < 100; i++) {
            if (i%2 != 0){
                System.err.println(i + "******main()******");
            }
        }
    }
}
/**
* 1.创建一个继承于Thread类的子类
*/
class MyThread extends Thread{
//2.重写Thread类的run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2 == 0){
                System.err.println(i);
            }
        }
    }
}

创建过程中两个问题的说明：
问题一：
我们不能通过直接调用run()的方式启动线程。

问题二：
再启动一个线程遍历100以内的偶数，不可以还让已经start()的线程去执行，会报 IllegalThreadStateException异常
我们需要重新创建一个线程的对象

方式二：实现Runnable接口
1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start():①启动线程②调用当前线程的run()–>调用Runnable类型的target的run()

//1.创建一个实现了Runnable接口的类
class MThread implements Runnable{


    //2.实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            } 版本 
        }
    }
}


public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread mThread = new MThread();
        //4.将此对象作为参数Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程一");
        //5.通过Thread类的对象调用start():①启动线程②调用当前线程的run()-->调用Runnable类型的target的run()
        t1.start();




        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程二");
        t2.start();
    }
}

比较创建线程的两种方式。
开发中：优先选择：实现Runnable接口的方式
原因：1. 实现的方式没有类的单继承的局限性
2. 实现的方式更适合来处理多个线程有共享数据的情况
联系：public class implements Runnable
相同点：两种方式都需要重写run()，将线程要实行的逻辑声明在run()中。

JDK 5.0 中新增线程的创建方式：
新增的方式一：实现Callable接口

新增的方式二：使用线程池