多线程_01（继承Thread类、实现Runnable接口、线程生命周期）

1.进程概述

进程：是正在运行的程序

• 是系统进行资源分配和调用的独立单位
• 每一个进程都有他自己的内存空间和系统资源

线程：是进程中的单个顺序控制流，是一条执行路径

• 单线程：一个进程如果有一条执行路径，则称为单线程程序
• 多线程：一个进程如果多条执行路径，则称为多线程程序

2.多线程的实现方案

2.1方案1：继承Thread类

1. 定义一个类MyThread继承Thread类
2. 在MyThread类中重写run()方法
3. 创建MyThread类的对象
4. 启动线程

两个小问题：
为什么要重写run()方法？
因为run()是用来封装被线程执行的代码
run()方法和start()方法的区别？
run()：封装线程执行的代码，直接调用，相当于普通方法的调用
start()：启动线程；然后由JVM调用此线程的run()方法

2.1.1设置和获取线程名称：

• void setName(String name):将此线程的名称更改为等于参数name
• String getName():返回此线程的名称
• 通过构造方法也可以设置线程名称

如何获取main()方法所在的线程名称？

• public static Thread currentThead():返回对当前正在执行的线程对象的引用

MyThread.java

/**
 * @Author:gaoyuan
 * @Description:获取和设置线程名称的方法
 * @DateTime:2021/1/21 8:30
 **/
public class MyThread extends Thread{
    public MyThread() {
    }
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i <10; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}

MyThreadDemo.java

public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        //将此线程的名称更改为等于参数name
        myThread1.setName("大王");
        myThread2.setName("小王");

       MyThread myThread3 = new MyThread("大哥");//带参构造方法
        MyThread myThread4 = new MyThread("小哥");
        myThread1.start();
        myThread2.start();
        myThread3.start();
        myThread4.start();
  //返回对当前正在执行的线程对象的引用
        System.out.println(Thread.currentThread().getName());//main
    }
}

运行结果：

大王:0
大王:1
小王:0
小王:1
小王:2
小王:3
小王:4
小王:5
小王:6
小王:7
小王:8
小王:9
大哥:0
大哥:1
大哥:2
大哥:3
大哥:4
大哥:5
大哥:6
大哥:7
大哥:8
大哥:9
main
大王:2
大王:3
大王:4
大王:5
大王:6
大王:7
大王:8
大王:9
小哥:0
小哥:1
小哥:2
小哥:3
小哥:4
小哥:5
小哥:6
小哥:7
小哥:8
小哥:9

2.1.2线程调度：

• 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片。
• 抢占式调度模型：优先让优先级高的线程使用Cpu，优先级高的线程获取CPU的时间片相对多一些。若线程的优先级相同，会随机选择一个。
  JAVA使用的是抢占式调度模型（多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的）

2.1.3Thread类中设置和获取线程优先级的方法

• public final int getPriority():返回此线程的优先级
• public final void setPriority(int newPriority):更改此线程的优先级

线程默认优先级是5；线程优先级的范围是：1-10
线程优先级高仅仅表示线程获取的CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到你想要的效果

ThreadPriority.java

public class ThreadPriority extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}

ThreadPriorityDemo.java

public class ThreadPriorityDemo {
    public static void main(String[] args) {
        ThreadPriority tp1 = new ThreadPriority();
        ThreadPriority tp2 = new ThreadPriority();
        ThreadPriority tp3 = new ThreadPriority();

        tp1.setName("白银");
        tp2.setName("黄金");
        tp3.setName("钻石");

       System.out.println(tp1.getPriority());//优先级5
        System.out.println(tp2.getPriority());//优先级5
       System.out.println(tp3.getPriority());//优先级5

        //线程优先级范围(1-10)
        System.out.println(Thread.MAX_PRIORITY);//10
        System.out.println(Thread.MIN_PRIORITY);//1
        System.out.println(Thread.NORM_PRIORITY);//5

        //更改线程优先级
        tp1.setPriority(10);//优先级高，只是线程获取CPU时间片的概率高，还是靠随机获取来的。
        tp2.setPriority(1);
        tp3.setPriority(2);

        tp1.start();
        tp2.start();
        tp3.start();
    }
}

结果输出：

5
5
5
10
1
5
白银:0
白银:1
白银:2
白银:3
白银:4
钻石:0
钻石:1
钻石:2
钻石:3
钻石:4
黄金:0
黄金:1
黄金:2
黄金:3
黄金:4

2.1.4线程控制：

static viod sleep(long millis):使当前正在执行的线程停留（暂停执行）指定的毫秒数。
未停留前：
ThreadSleep.java

/**
 * @Author:gaoyuan
 * @Description:使当前正在执行的线程停留（暂停执行）指定的毫秒数
 * @DateTime:2021/1/21 10:20
 **/
public class ThreadSleep extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <5; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}

ThreadSleepDemo.java

public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep ts1 = new ThreadSleep();
        ThreadSleep ts2 = new ThreadSleep();
        ThreadSleep ts3 = new ThreadSleep();

        ts1.setName("曹操");
        ts2.setName("刘备");
        ts3.setName("孙权");

        ts1.start();
        ts2.start();
        ts3.start();
    }
}

结果输出;

曹操:0
刘备:0
刘备:1
孙权:0
孙权:1
曹操:1
曹操:2
曹操:3
刘备:2
曹操:4
孙权:2
孙权:3
孙权:4
刘备:3
刘备:4

停留后：
ThreadSleep.java

public class ThreadSleep extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <5; i++) {
            System.out.println(getName() + ":" + i);
            try {
                Thread.sleep(1000);
                TimeUnit.SECONDS.sleep(2);//休眠秒
                 TimeUnit.HOURS.sleep(2);//休眠小时
                 TimeUnit.DAYS.sleep(2);//休眠天
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

ThreadSleepDemo.java

public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep ts1 = new ThreadSleep();
        ThreadSleep ts2 = new ThreadSleep();
        ThreadSleep ts3 = new ThreadSleep();

        ts1.setName("曹操");
        ts2.setName("刘备");
        ts3.setName("孙权");

        ts1.start();
        ts2.start();
        ts3.start();
    }
}

结果输出：

曹操:0
孙权:0
刘备:0
孙权:1
曹操:1
刘备:1
刘备:2
孙权:2
曹操:2
孙权:3
刘备:3
曹操:3
孙权:4
曹操:4
刘备:4

viod join():等待这个线程死亡
未启用 join前：
TheadJoin.java

public class TheadJoin extends Thread{
@Override
    public void run() {
        for (int i = 0; i <5; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}

TheadJoinDemo.java

public class TheadJoinDemo {
    public static void main(String[] args) {
        TheadJoin tj1 = new TheadJoin();
        TheadJoin tj2 = new TheadJoin();
        TheadJoin tj3 = new TheadJoin();

        tj1.setName("康熙");
        tj2.setName("四阿哥");
        tj3.setName("八阿哥");

        tj1.start();
        tj2.start();
        tj3.start();
    }
}

运行结果：

八阿哥:0
四阿哥:0
四阿哥:1
康熙:0
四阿哥:2
康熙:1
八阿哥:1
康熙:2
四阿哥:3
康熙:3
八阿哥:2
八阿哥:3
八阿哥:4
康熙:4
四阿哥:4

启用 join后：
TheadJoin.java

public class TheadJoin extends Thread{
@Override
    public void run() {
        for (int i = 0; i <5; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}

TheadJoinDemo.java

public class TheadJoinDemo {
    public static void main(String[] args) {
        TheadJoin tj1 = new TheadJoin();
        TheadJoin tj2 = new TheadJoin();
        TheadJoin tj3 = new TheadJoin();

        tj1.setName("康熙");
        tj2.setName("四阿哥");
        tj3.setName("八阿哥");

        tj1.start();
        try {
            tj1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tj2.start();
        tj3.start();
    }
}

结果输出：

康熙:0
康熙:1
康熙:2
康熙:3
康熙:4
四阿哥:0
八阿哥:0
八阿哥:1
八阿哥:2
八阿哥:3
四阿哥:1
四阿哥:2
四阿哥:3
四阿哥:4
八阿哥:4

void setDaemon(boolean on):将此线程标记为守护线程，当运行的线程都是守护线程时，java虚拟机将退出。
TheadDaemon.java

public class TheadDaemon extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <10; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}

TheadDaemonDemo.java

public class TheadDaemonDemo {
    public static void main(String[] args) {
        TheadDaemon td1 = new TheadDaemon();
        TheadDaemon td2 = new TheadDaemon();

        td1.setName("关羽");
        td2.setName("张飞");
        //设置主线程为刘备
        Thread.currentThread().setName("刘备");
        //设置守护线程
        td1.setDaemon(true);
        td2.setDaemon(true);

        td1.start();
        td2.start();

        for (int i = 0; i <2 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

结果输出：

刘备:0
刘备:1
关羽:0
关羽:1
关羽:2
关羽:3
关羽:4
关羽:5
关羽:6
关羽:7
关羽:8
关羽:9
张飞:0
张飞:1
张飞:2
张飞:3

刘备死后，张飞和关羽很快死亡（但不会立即死亡）

2.2方案2：实现Runnable接口

2.2.1多线程的实现方式：

• 继承Thread类（上面）
• 实现Runnable接口
  实现Runnable接口的好处
• 避免了Java单继承性的局限性
• 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

2.2.2多线程的实现方式2：
1.定义一个类MyRunnable实现Runnable接口
2.在MyRunnable类中重写run()方法
3.创建MyRunnable类的对象
4.创建Thread类的对象，把MyRunnable对象作为构造方法的参数
5.启动线程

MyRunnable.java

public class MyRunnable implements Runnable {//实现的是Runnable接口，没有基础Thread类
    //不能直接用getName()
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);//只能通过Thread.currentThread()拿到当前线程，才能调用getName()
        }
    }
}

MyRunnableDemo.java

public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();
//创建Thread类的对象，把MyRunnable对象作为构造方法的参数
////Thread（Runnable target）
//        Thread t1 = new Thread(my);
//        Thread t2 = new Thread(my);
//Thread（Runnable target,String name）
        Thread t1 = new Thread(my,"王炸");//创建对象的时候就命名
        Thread t2 = new Thread(my,"小炸");
//启动线程
        t1.start();
        t2.start();
    }
}

运行结果：

王炸:0
小炸:0
王炸:1
小炸:1
小炸:2
王炸:2
小炸:3
小炸:4
王炸:3
王炸:4

线程生命周期