Thread类的基本用法

目录

1. 线程创建
2. 线程中断
3. 线程等待
4. 线程休眠
5. 获取线程实例

---

1.线程创建

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

// 定义一个Thread类，相当于一个线程的模板
class MyThread01 extends Thread {
    // 重写run方法
    // run方法描述的是线程要执行的具体任务
    @Override
      public void run() {
        System.out.println("hello, thread.")；
    }
}
 

public class Thread_demo01 {
    public static void main(String[] args) {
        // 实例化一个线程对象
        MyThread01 t = new MyThread01();
        // 真正的去申请系统线程，参与CPU调度
        t.start();
    }
}

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

// 创建一个Runnable的实现类，并实现run方法
// Runnable主要描述的是线程的任务
class MyRunnable01 implements Runnable {
    @Overridepublic void run() {
        System.out.println("hello, thread.");
    }
}

public class Thread_demo02 {
    public static void main(String[] args) {
        // 实例化Runnable对象
        MyRunnable01 runnable01 = new MyRunnable01();
        // 实例化线程对象并绑定任务
        Thread t = new Thread(runnable01);
        // 真正的去申请系统线程参与CPU调度
        t.start();
    }
}

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

public class Thread_demo03 {
public static void main(String[] args) {
        Thread t = new Thread(){
            // 指定线程任务
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        // 真正的申请系统线程参与CPU调度
        t.start();
    }
}

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

public class Thread_demo04 {
public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            // 指定线程的任务
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());                
            }
        });
        // 申请系统线程参与CPU调度
        t.start();
    }
}

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

public class Thread_demo05 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            // 指定任务：任务是循环打印当前线程名
            while (true) {
                System.out.println(Thread.currentThread().getName());
                try {
                    // 休眠1000ms
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 申请系统线程参与CPU调度
        t.start();
    }
}

 2.线程中断

不是让线程立即就停止 而是通知线程 你应该要停止了 是否真的要停止 取决于线程这里具体的代码写法

1.使用一个标志位(flag)来控制线程是否要结束

(自定义变量这种方式 不能够及时响应 尤其是在sleep休眠比较久的时候)

public class Thread_demo06 {
    private static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
       Thread t = new Thread(() -> {
          while(flag) {
              System.out.println("hello thread");
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
       });
       t.start();
       Thread.sleep(3000);
       //在主线程里就可以随时通过flag变量的取值 来操作t线程是否结束
        flag= false;
    }
}

2.使用Thread自带的标志位，来进行判定

 t.interrupt() 终止t线程

3.线程等待

线程是一个随机调度的过程，等待线程所做的事情，就是在控制两个线程的顺序

本身执行完start之后，t线程和main线程就会并发执行，分头行动。

main继续往下执行，t也会继续往下执行，而t.jion会发生使main线程发生阻塞，一直阻塞到t线程执行结束 main线程才会从join中恢复过来，才能继续执行，所以t线程肯定会比main先结束 

public class Thread_demo07 {
    public static void main(String[] args) {
       //通过lambda表达式创建一个线程
        Thread  t = new Thread(() -> {
           for(int i =0; i < 3;i++){
            //循环打印三次hello,thread
               System.out.println("hello,thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();
        System.out.println("join之前"); //main线程执行的语句
        //此处的jion就是让当前的main线程来等待t线程执行结束
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("join之后"); //main线程执行的语句
    }
}

 

执行结果为

 

线程休眠

让线程休眠，本质上就是让这个线程不参与调度了（不去CPU上执行了）

在操作系统内核中 每个线程都有自己的PCB，处于就绪队列的PCB 都是“随叫随到”，就绪状态。而处于阻塞队列的PCB，都是阻塞状态，暂不参与CPU的调度执行。

线程A 本来处于就绪状态，而当调用sleep，A就会进入休眠状态，把A从就绪队列拎出来，放入到阻塞队列里了，操作系统在调度线程的时候只需要看就绪队列，从就绪队列里选出一个执行，阻塞队列里的PCB暂时是不会进入就绪队列里。而当sleep执行时间结束之后，会继续回到就绪队列里，但是考虑到调度的开销，对应的线程是无法在回到就绪队列后立马被执行的，实际时间间隔要大于它的休眠时间

public class Thread_demo08 {
    public static void main(String[] args) {
        Thread  t = new Thread(() -> {
           for(int i =0; i < 3;i++){
               System.out.println("hello,thread");
               try {
                   Thread.sleep(1000);//休眠
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();
      System.out.println("hello,world");
    }
}

获取线程实例

public static Thread currentThread();

public class Thread_demo09{
    public static void main(String[] args) {
        Thread  t = new Thread(() -> {
           for(int i =0; i < 3;i++){
               System.out.println("hello,thread");
               try {
                   Thread.sleep(1000);//休眠
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();
      System.out.println("hello,world");
      System.out.println(Thread.currentThread().getName());//获取线程实例
    }
}