Thread 类的基本用法（附代码）

目录

一、线程创建

(1)继承 Thread 来创建线程

(2)实现 Runnable 接口来创建线程

(3)匿名内部类创建 Thread 子类对象

(4)匿名内部类创建 Runnable 子类对象

(5)Lambda 表达式创建 Runnable 子类对象

二、线程中断

(1)自定义标志位来控制线程是否结束

(2)通过使用标准库自带的标志位对线程进行结束

三、线程等待

四、线程休眠

五、获取线程实例

---

一、线程创建

(1)继承 Thread 来创建线程

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("继承Thread方法重写run方法来创建线程");
    }
}
public class TestThread1 {

    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        myThread1.start();
    }
}

(2)实现 Runnable 接口来创建线程

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("通过实现Runnable接口，重写run方法来创建线程");
    }
}

public class TestThread2 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
    }
}

(3)匿名内部类创建 Thread 子类对象

public class TestThread3 {
    public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                System.out.println("匿名内部类创建 Thread 子类对象");
            }
        };
        t.start();
    }
}

(4)匿名内部类创建 Runnable 子类对象

public class TestThread4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类创建 Runnable 子类对象");
            }
        });
        t.start();
    }
}

(5)Lambda 表达式创建 Runnable 子类对象

public class TestThread5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("使用 lambda 表达式创建线程");
        });
        t.start();
    }
}

二、线程中断

(1)自定义标志位来控制线程是否结束

public class InterruptedThread1 {
    private static boolean isQuit; //自定义标志位
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!isQuit) {
                System.out.println(Thread.currentThread().getName() + ": 我还活着");
                try {
                    Thread.sleep(1000);//让线程堵塞1s
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        isQuit = true; //设置自定义标志位
        System.out.println("设置让t线程结束");
    }
}

(2)通过使用标准库自带的标志位对线程进行结束

要注意的是interrupted方法的行为有两种

1.如果 t 线程在运行状态会设置标志位为true

2.如果 t 线程在堵塞状态(sleep)不会设置标记位(这里不是没设置标志位，只是设置后sleep/wait等阻塞方法会清除标志位)，而是触发中断异常，这个异常会把sleep提前唤醒

• 假设出现第二种情况就需要检测到异常后自行选择结不结束线程

public class InterruptedThread2 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println(Thread.currentThread().getName() + ": 我还活着");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;//检测到异常后跳出循环从而让线程结束
                }
            }
            System.out.println("t线程执行完了");
        });
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.interrupt();
        System.out.println("设置让t线程结束");
    }
}

三、线程等待

线程之间的调度是不一样的，咱们就可以调用 join 来对线程执行顺序做出干扰，来控制线程之间的结束顺序。

在main中调用 t.join() 就会使main线程阻塞等待，等线程 t 执行完后main才继续执行。

public class TestJoin {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + "我在运行");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        System.out.println("t.join前");
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t.join后");
    }
}

四、线程休眠

        线程调用sleep就是让线程堵塞休息一会，例如 thread.sleep(1000) 就可以让线程thread堵塞1秒。

public class TestThreadSleep {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("线程开始休眠五秒");
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);//休眠1秒
                    System.out.println(i+1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("已经休眠了五秒");
        });
        thread.start();
    }
}

五、获取线程实例

 

Thread.currentThread()这个方法在哪个线程里调用就返回哪个线程的对象引用 

public class TestcurrentThread {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
    }
}

谢谢您的观看，如有错误还请指正！