Java基础 线程2 线程的基本使用

线程的基本使用

案例1

线程应用案例1-继承Thread类

1、请编写程序，开启一个线程，该线程每隔1秒，在控制台输出“喵喵，我是小猫咪"

2、对上题进行改：当输出80次时，结束该线程

3、使用JConsole监控线程执行情况，并画出程序示意图

//查看cpu核心数/线程数

/**
 * @ClassName CpuNum
 * @Description
 * @Author 小黄debug
 * @Date 2022/3/20 13:01
 * @Version 1.0
 **/
public class CpuNum {
    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
        //获取当前电脑的cpu数量/线程数
        int cpuNums = runtime.availableProcessors();
        System.out.println("当前有cpu个数="+cpuNums);

    }
}

//创建线程并使用

/**
 * @ClassName Thread01
 * @Description     通过继承Thread类创建线程
 * @Author 小黄debug
 * @Date 2022/3/20 13:06
 * @Version 1.0
 **/
public class Thread01 {
    public static void main(String[] args) throws InterruptedException{
        //创建一个Cat对象，当成线程使用
        Cat cat = new Cat();
        //启动线程，当start调用时，会调用run方法

        //源码分析
        /*
        //
        (1)
        public synchronized void start() {
            start0();
        }
        (2)
        //start0()是一个本地方法，是JVM调用，底层是c/c++实现的
        //真正实现多线程的效果，是start0(),而不是run
        private native void start0();
         */


        cat.start();    //启动线程 -> 最终会执行cat的run方法

        //cat.run();  //如果只执行run方法，run方法就是一个普通 的方法，没有启动子线程，就会把run方法执行完毕，才向下执行
        //说明：当main线程启动一个子线程，Thread-0，主线程不会阻塞，会继续执行
        //这时 主线程和子线程是交替执行。。
        for(int i = 0; i < 60; i++){
            System.out.println("主线程在执行中i="+i+"主线程名称="+Thread.currentThread().getName());
            //让主线程休眠
            Thread.sleep(1000);
        }


    }
}
//1、当一个类继承了Thread类，该类就可以当做线程使用
//2、我们会重写run方法，写上自己的业务代码
//3、run Thread类实现了Runnable接口的run方法
/*
@Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 */
class Cat extends Thread{

    int times = 0;
    //重写run方法
    public void run(){
        while(true) {
            //该线程每隔1秒，在控制台输出"喵喵,我是小猫咪"
            System.out.println("喵喵,我是小猫咪"+(++times)+"子线程名称="+Thread.currentThread().getName());
            //让该线程休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times == 80){
                break;
            }
        }

    }
}

使用JConsole监控线程情况

当程序run起来后，在Termainal中输入jconsole后回车

进入到jconsole中，以不安全的方式连接，选择Thread-01(与类名相同)可以看到以下内容

案例2

说明：

1、Java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时再用继承Thread类方法来创建线程显然不可能了

2、Java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程

线程使用应用案例-实现Runnable

请编写程序，该程序 可以每隔1秒。在控制台输出"hi!",当输出10次后，自动退出，请使用Runnable接口的方式实现（这里底层使用了设计模式[代理模式-静态代理]=》代码模拟）

package com.hsydebug.threaduse;

/**
 * @ClassName Thread02
 * @Description 通过实现接口Runnable来开发线程
 * @Author 小黄debug
 * @Date 2022/3/20 14:19
 * @Version 1.0
 **/
public class Thread02 {
    public static void main(String[] args) {
//        Dog dog = new Dog();
//        //dog.start();这晨不能调用start;
//        //创建了Thread对象，把dog对象（实现Runnable)，放入Thread
//        Thread thread = new Thread(dog);
//        thread.start();
        
        //==================================
        Tiger tiger = new Tiger();
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.start();
    }
}
class Dog implements Runnable{
    int count = 0;
    public void run(){  //普通方法
        while(true){
            System.out.println("小狗汪汪叫：hi!="+(++count)+"="+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count == 10){
                break;
            }
        }
    }
}
//========================================
class Animal{}
class Tiger extends Animal implements Runnable{
    public void run(){
        System.out.println("老虎叫。。。。");
    }
}



//线程代理类，模拟一个极简的Thread类
class ThreadProxy implements Runnable{

    private Runnable target = null; //属性：类型是Runnable

    public ThreadProxy(Runnable target){
        this.target = target;
    }

    public void run(){
        if(target != null){
            target.run();
        }
    }

    public void start(){
        start0();//这个方法是真正实现多线程方法
    }
    public void start0(){
        run();
    }
}

案例3

线程使用应用案例-多线程执行

请编写一个程序 ，创建两个线程，一个线程每隔1秒输出 "hello,world",输出10次，退出，一个线程每隔1秒输出“hi",输出5次退出。Thread03.java

package com.hsydebug.threaduse;

/**
 * @ClassName Thread03
 * @Description
 * @Author 小黄debug
 * @Date 2022/3/20 16:09
 * @Version 1.0
 **/
public class Thread03 {
    public static void main(String[] args) {
//        A a = new A();
//        a.start();
//        B b = new B();
//        b.start();
        C c = new C();
        Thread threadC = new Thread(c);
        threadC.start();
        D d = new D();
        Thread threadD = new Thread(d);
        threadD.start();

    }
}

class A extends Thread{
    int count = 0;

    public void run(){
        while(true){
            System.out.println("线程A第"+(++count)+"次");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count == 10){
                break;
            }
        }
    }
}
class B extends Thread{
    int count = 0;

    public void run(){
        while(true){
            System.out.println("线程B第"+(++count)+"次");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count == 5){
                break;
            }
        }
    }
}

class ThreadSupper{}
class C extends ThreadSupper implements Runnable{

    int count = 0;

    public void run(){
        while(true){
            System.out.println("线程C第"+(++count)+"次");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count == 10){
                break;
            }
        }
    }
}
class D extends ThreadSupper implements Runnable{

    int count = 0;

    public void run(){
        while(true){
            System.out.println("线程D第"+(++count)+"次");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count == 5){
                break;
            }
        }
    }
}

1、从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了

2、实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制

3、售票系统，编程模拟三个售票窗口100，分别使用继承Thread和实现Runnable方式，并分析有什么问题，（超卖了），问题留在这里，后面解决

/**
 * @ClassName SellTicket
 * @Description 使用多线程模拟三个窗口同时售票100张
 * @Author 小黄debug
 * @Date 2022/3/20 16:58
 * @Version 1.0
 **/
public class SellTicket {
    public static void main(String[] args) {
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //出现票数超卖
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket03.start();

        //使用接口方式查看是否存在超卖
        SellTicker02 sellTicker02 = new SellTicker02();
        new Thread(sellTicker02).start();
        new Thread(sellTicker02).start();
        new Thread(sellTicker02).start();
    }
}

class SellTicket01 extends Thread{
    private static int ticketNum = 100;   //让多个线程共享ticketNum

    @Override
    public void run() {
        while(true){
            if(ticketNum <= 0){
                System.out.println("售票结束 。。");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口"+Thread.currentThread().getName()
                    +"售出一张票，剩余票数"+(--ticketNum));
        }
    }
}

class SellTicker02 implements Runnable{
    //为什么这里不用静态，是因为SellTicker02只new了一次，所有的都ticketNum都指向这里
    private int ticketNum = 100;   //让多个线程共享ticketNum

    @Override
    public void run() {
        while(true){
            if(ticketNum <= 0){
                System.out.println("售票结束 。。");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口"+Thread.currentThread().getName()
                    +"售出一张票，剩余票数"+(--ticketNum));
        }
    }
}

线程终止

基本说明

1、当线程完成任务后，会自动退出

2、还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

/**
 * @ClassName ThreadExit_
 * @Description
 * @Author 小黄debug
 * @Date 2022/3/20 17:41
 * @Version 1.0
 **/
public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();
        //如果希望main线程去控制t1线程中止，就必须可以修改loop变量
        //让t1退出run方法，从而终止t1线程 -->通知方式
        Thread.sleep(10000);
        System.out.println("通知t1线程中止");
        t1.setLoop(false);
    }
}

class T extends Thread{
    int count = 0;
    //设置一个控制变量
    private boolean loop = true;
    @Override
    public void run() {
        while(loop){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T运行中。。。。"+(++count));
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

线程常用方法

1、setName        //设置线程名称，使之与参数name相同

2、getName        //返回该线程的名称

3、start                //使线程开始执行;Java虚拟机底层调用该线程的start()方法

4、run                //调用线程对象run方法

5、setPriority       //更改线程优先级

6、getPriority        //获取线程的优先级

7、sleep                //在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

8、interrupt                //中断线程

注意事项和细节

1、start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程

2、线程优先级的范围

3、interrupt中断线程，但并没有真正的线束线程，所以一般用于中断正在休眠的线程

4、sleep:线程的静态方法，使当前线程休眠

/**
 * @ClassName ThreadMethod01
 * @Description
 * @Author 小黄debug
 * @Date 2022/3/20 18:15
 * @Version 1.0
 **/
public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        //测试相关的方法
        T t = new T();
        t.setName("小黄");
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();//启动子线程

        //主线程打印5hi,然后中断子线程的休眠
        for(int i = 0; i < 5; i++){
            Thread.sleep(1000);
            System.out.println("hi"+i);
        }
        System.out.println(t.getName()+"线程优先级="+t.getPriority());
        t.interrupt();
    }
}

class T extends Thread{
    @Override
    public void run() {
        while(true) {
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName() 获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + "吃包子~~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + "休眠中~~~");
                Thread.sleep(20 * 1000);
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt方法时，就会catch一个异常，可以加入自己的业务代码
                //InterruptedException是捕获到一个中断异常
                System.out.println(Thread.currentThread().getName() + "被interrupt了");
            }
        }
    }
}

线程常用方法

常用方法第二组

1、yield：线程和礼让，让出cpu,让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功

2、join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

案例：创建一个子线程，每隔1S输出hello,输出20次，主线程每隔1秒，输出hi,输出20次。要求：两个线程同时执行，当主线程输出5次后，就让子线程远行完毕，主线程再继续

/**
 * @ClassName ThreadMethod02
 * @Description
 * @Author 小黄debug
 * @Date 2022/3/20 18:41
 * @Version 1.0
 **/
public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();

        for(int i = 1; i<=20; i++){
            Thread.sleep(1000);
            System.out.println("主线程吃了"+i+"包子");
            if(i == 5){
                System.out.println("主线程礼让子线程");
                //join,线程插队
                //t2.join();//这里是相当于让t2线程先执行完毕
                t2.join();
                //Thread.yield();//礼让，不不定成功

                System.out.println("线程（老大）吃完了，主线程（小弟）接着吃。。");
            }
        }

    }
}
class T2 extends Thread{
    @Override
    public void run() {
        for(int i = 1; i <= 20; i++){
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程吃了"+i+"包子");
        }
    }
}

线程常用方法

练习

ThreadMethodExercise.java

1、主线程每隔1s,输出hi，一共10次

2、当输出到hi 5时，启动一个子线程（要求实现Runnable),每隔1s输出hello,等该线程输出10次hello后，退出

3、主线程继续输出hi,直到主线程退出

4、如图，完成代码，其实线程插队

/**
 * @ClassName ThreadMethodExercise
 * @Description
 * @Author 小黄debug
 * @Date 2022/3/20 18:55
 * @Version 1.0
 **/
public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        Thread t3 = new Thread(new T3());
        for (int i = 1; i <= 10; i++) {
            Thread.sleep(1000);
            System.out.println("主线程hello="+i);
            if(i == 5) {
                t3.start();
                t3.join();  //t3进行抢占
            }
        }
    }

}
class T3 implements Runnable{
    @Override
    public void run() {
        for(int i = 1; i <= 10; i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程hello="+i);
        }
    }
}
//运行结果
/*
主线程hello=0
主线程hello=1
主线程hello=2
主线程hello=3
主线程hello=4
主线程hello=5
子线程hello=1
子线程hello=2
子线程hello=3
子线程hello=4
子线程hello=5
子线程hello=6
子线程hello=7
子线程hello=8
子线程hello=9
子线程hello=10
主线程hello=6
主线程hello=7
主线程hello=8
主线程hello=9
 */

线程的常用方法

用户线程和守护线程

1、用户线程：也叫工作线程，当线程的任务执行完或通知方式结束 

2、守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

3、常见的守护线程：垃圾回收机制

应用案例ThreadMethod03.java

测试如何 将一个线程设置成守护线程

/**
 * @ClassName ThreadMethod03
 * @Description
 * @Author 小黄debug
 * @Date 2022/3/20 19:14
 * @Version 1.0
 **/
public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果我们希望当main线程结束后，子线程自动结束
        //只需要将子线程设为守护线程即可
        myDaemonThread.setDaemon(true);
        myDaemonThread.start();
        
        for(int i = 1; i <= 10; i++){
            System.out.println("我爱学习我爱学习");
            Thread.sleep(1000);
        }
    }
}

class MyDaemonThread extends Thread{
    public void run(){
        for(;;){    //无限循环
            try {
                Thread.sleep(1000);   //休眠1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("不如跳舞");
        }
    }
}