Thread类的基本用法

线程的创建

1. 通过继承Thread类并实现run方法创建一个线程

public class TestDemo2 {
    public static void main(String[] args) {
        Thread thread1=new myThread1();
        thread1.start();
    }
}

class myThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("myThread1");
    }
}

2. 通过实现Runnable接口，并实现run方法的方法创建一个线程

public class TestDemo2 {
    public static void main(String[] args) {
        Runnable runnable=new myThread2();
        Thread thread2=new Thread(runnable);
        thread2.start();
    }
}

class myThread2 implements Runnable {
    @Override
    public void run() {
        System.out.println("myThread2");
    }
}

3. 通过Thread匿名内部类创建一个线程

public class TestDemo2 {
    public static void main(String[] args) {
        Thread thread3=new Thread(){
            @Override
            public void run() {
                System.out.println("myThread3");
            }
        };
        thread3.start();
    }
}

4. 通过Runnable匿名内部类创建一个线程

public class TestDemo2 {
    public static void main(String[] args) {
        Thread thread4=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("myThread4");
            }
        });
        thread4.start();
    }
}

5. 通过Lambda表达式的方式创建一个线程

public class TestDemo2 {
    public static void main(String[] args) {
        Thread thread5=new Thread(()->{
            System.out.println("myThread5");
        });
        thread5.start();
    }
}

线程休眠

使用Thread.sleep()方法使线程休眠,sleep() 方法可能会抛出 InterruptedException异常

public class TestDemo2 {
    public static void main(String[] args) {
        Thread thread5=new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("myThread5");
        });
        thread5.start();
    }
}

我们再来看下面两个代码

我们会发现重写run方法里面的sleep方法必须要用try/catch语句来处理异常

这是因为父类Runnable接口的run方法没有声明这个异常

根据方法重写的规则,我们不能修改方法签名,因此我们就不能用throws来声明run方法里面的异常

线程中断

众所周知,线程的是分时复用的,我们也不知道一个可执行文件会在执行哪个线程,或者已经执行到了哪里?
那我们能不能在主线程执行到一定位置或者得到想要的结果的时候中断其他线程呢?
我们以下面代码为例

public class TestDemo2 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread5=new Thread(()->{
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("myThread5");
            }
        });
        thread5.start();
    }
}

我们知道上面的代码会一直执行while循环的内容,那我们能不能让主线程在休眠10s后关闭我们新建的这个线程呢?
答案是有的,下面提供两种方法来实现

1. 设置一个成员变量通过判断该成员变量的值进行结束循环

public class TestDemo2 {
    static boolean key=true;
    public static void main(String[] args) throws InterruptedException {
        Thread thread5=new Thread(()->{
            while (key) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("myThread5");
            }
        });
        thread5.start();
        Thread.sleep(10000);
        key=false;
    }
}

注意: 不能使用局部变量, lambda表达式要求局部变量的值不能修改

2. 通过interrupt方法设置标志位

使用currentThread方法返回对当前正在执行的线程对象的引用,从而使用isInterrupted方法判断线程是否被中断

public static void main(String[] args) throws InterruptedException {

        Thread thread5=new Thread(()->{
            while (!Thread.currentThread().isInterrupted()) {  
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("myThread5");
            }
        });
        thread5.start();
        Thread.sleep(1000);
        thread5.interrupt();

    }

如果我们把throw new RuntimeException(e);给注释了,就会发现线程又死循环了,这是为什么呢?

其实是sleep被提前唤醒,会发生下面两件事:

1. 抛出InterruptedException异常
2. 清理Thread对象的isInterrupted标志位 (因此标志位又重新设回false,导致继续循环)

因此,想让上面线程结束,我们只要加break就行了

• 当我们想让线程直接结束 (后面直接加break)
• 让线程不结束,继续执行(后面不加break)
• 让线程执行一定逻辑之后再结束 (在该逻辑后再break)

线程等待

线程等待顾名思义就是让一个线程等待另一个线程完成

我们来看下面的代码

public class TestDemo2 {
    static int count=0;
    public static void main(String[] args) throws InterruptedException {

        Thread thread5=new Thread(()->{
            for (int i = 0; i < 100; i++) {
                count++;
            }
        });
        thread5.start();
        System.out.println(count);
    }
}

相信结果大家应该都知道是0,而不是我们想要的100那我们要怎么得到100呢?
可能有的人会说使用sleep方法让主线程休眠,等到count全部加完了再执行打印
这虽然是一个解决办法但我们不知道要休眠多久,不能适用于多种情况,因此需要我们的join方法了

join方法在哪个线程使用,就是哪个线程等待使用join方法的线程

我们来看下面的示例

public class TestDemo2 {
    static int count=0;
    public static void main(String[] args) throws InterruptedException {

        Thread thread5=new Thread(()->{
            for (int i = 0; i < 100; i++) {
                count++;
            }
        });
        thread5.start();
        thread5.join();
        System.out.println(count);
    }
}

我们还可以传入一个毫秒的时间,表示线程最多等待多久就会执行

public class TestDemo2 {
    static int count=0;
    public static void main(String[] args) throws InterruptedException {

        Thread thread5=new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            for (int i = 0; i < 100; i++) {
                count++;
            }
        });
        thread5.start();
        thread5.join(500);
        System.out.println(count);
    }
}

我们就会发现上面结果又变成0了