Thread类的基本用法

1.线程创建

线程创建的3种方式

• 继承Thread类
• 实现Runnable接口
• 使用Lambda表达式

---

继承Thread类

继承Thread重写run()方法

class ExThread extends Thread {
    @Override
    public void run() {
        System.out.println("通过继承Thread类创建线程");
    }
}

public class Main{
    public static void main(String[] args) {
        Thread t = new ExThread();
        //启动线程
        t.start();
    }
}

---

继承Thread匿名内部类

public class HomeWork {
    public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                System.out.println("通过继承Thread类创建线程");
            }
        };
    }
}

---

实现Runnable接口

实现Runnable接口重写run()方法

class ExRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("通过实现Runnable接口创建线程");
    }
}

public class HomeWork {
    public static void main(String[] args) {
        ExRunnable runnable = new ExRunnable();
        Thread t = new Thread(runnable);
		//启动线程
        t.start();
    }
}

---

实现Runnable接口匿名内部类

public class HomeWork {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("通过实现Runnable接口创建线程");
            }
        });
    }
}

---

使用Lambda表达式

public class HomeWork {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("使用Lambda创建线程"); 
        });
    }
}

---

2.线程中断

线程中断就是让线程停下来
那么如何才能让线程停下来呢?
那就是让该线程的入口方法执行完毕

下面来简单介绍下3种线程中断的情况

1.线程立即中断
2.线程稍等片刻中断
3.线程不中断

举个栗子

你正在打游戏,然后你的女朋友打电话叫你去陪她逛街
这时候你有3个选择
1.立刻把游戏停了陪她逛街(线程立即中断)
2.和她说打完这把再去(线程稍等片刻中断)
3.直接把电话挂了,继续打游戏(线程不中断)

下面来看下代码

线程立即中断

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            //currentThread是获取到当前线程的实例
            //此处currentThread()得到的对象就是t
            //isInterrupted()是t对象自带的标志位-->默认是false
            //可以理解成while(!false) --> while(true) --> 死循环
            while(!Thread.currentThread().isInterrupted()) {
                System.out.println("hello t1");
                try {
                    //休眠0.5s
                    Thread.sleep(500);
                } catch(InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
            System.out.println("线程立即中断");
        });

        //启动线程
        t.start();

        try {
            //休眠3s
            Thread.sleep(3000);
        } catch(InterruptedException e) {
            e.printStackTrace();
        }

        t.interrupt();//将标志位设置为true
    }
}

---

稍等片刻中断

public class Test1 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(!Thread.currentThread().isInterrupted()) {
                System.out.println("hello t2");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException ee) {
                        ee.printStackTrace();
                    }
                    break;
                }
            }
            System.out.println("线程稍等片刻中断");
        });

        //启动线程
        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t.interrupt();
    }  
}

---

线程不中断

public class Test1 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(!Thread.currentThread().isInterrupted()) {
                System.out.println("hello t3");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程不中断");
        });

        //启动线程
        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t.interrupt();
    }
}

---

3.线程等待

等于这上述代码
我们无法确定打印顺序
先输出hello t 还是先输出hello bibu

但在main线程加入了t.join()(线程等待)之后,就会先去打印hello t了

这是因为在main线程中加入t.join(),如果此时的 t线程还没有执行完,main线程就会发生堵塞
也就是说,等到 t线程执行完毕后再去执行main线程的程序

需要注意的是

• 在t1线程中调用t2.join(),就是t2先执行完毕再去执行t1
• 在t2线程种调用t3.join(),就是t3先执行完毕再去执行t2
• t.join()这个方法也可以设置一个时间

解释

• 这里设置的时间就是说最多等待 t线程执行1000ms(1s),如果还没有执行完.那main线程就会继续执行
• 举个栗子
  • 你的女朋友让你在她宿舍楼下等她10分钟
  • 你可以选择一直等着她( t.join())
  • 也可以选择就等10分钟( t.join(1000))

---

4.线程休眠

让线程进入一定时间的停止

public class Main{
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(true) {
                try {
                    //让线程进入休眠
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        t.start();
    }
}

5.线程的六种状态

• NEW: 安排了工作, 还未开始行动
• RUNNABLE: 就绪状态. 又可以分成正在工作中和即将开始工作
• TERMINATED:系统中的线程已经执行完了,Thread对象还在
• TIMED_WATING:指定时间等待
• BLOCKED:等待出现状态
• WAITING:使用wait方法出现的状态

具体参考: 多线程的几种状态

结尾

如果大家有什么不太理解的，可以私信或者评论区留言，一起加油