Thread 类的基本用法

一、线程的创建

1.1 Thread的常见构造方法

1.2 继承Thread的方式创建线程

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("t");
    }
 
    public static void main(String[] args) {
        MyThread t=new MyThread();
        t.start();//启动线程
        System.out.println("main");//主线程的打印
    }
}

MyThread 类继承了 Thread 类，并重写了 run() 方法。创建 MyThread 的实例并通过调用 start() 方法来启动新线程。

1.2 通过实现Runnable接口创建线程

创建一个实现 Runnable 接口的新类，并实现 run() 方法。然后，将这个类的实例传递给 Thread 类的构造函数。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("这里是线程运行的代码");
    }
    public static void main(String[] args) {
        Thread t=new Thread(new MyRunnable());
        t.start();
        System.out.println("main");
    }
}

1.3 使用匿名内部类创建线程

创建一个匿名内部类，同时继承 Thread 类或实现 Runnable 接口，并在创建时定义线程任务。

//使用匿名内部类实现继承thread
public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t=new Thread(){
            @Override
            public void run(){
            while (true){
                System.out.println("t");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            }
        };
        t.start();
        while (true){
            System.out.println("main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

另外一种实现runable接口的方式去实现线程的创建

//匿名内部类实现ThreadRunable接口
 
public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("t");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        while (true){
            System.out.println("main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

1.4 使用lambda 表达式创建 Runnable 子类对象

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t=new Thread(() ->{
            while (true){
                System.out.println("t");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        while (true) {
            System.out.println("main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

使用lambda表达式是为了使代码看起来更加简洁，跟其他创建线程方法功能一样，除此之外，工作中使用的最多的也是这种

1.5 start方法和run方法的区别

run() 方法 只是线程的一个普通方法，调用它不会创建一个新的线程，而只是按顺序执行其中的代码。因此，如果直接调用 run() 方法，那么其中的代码会在当前线程中执行，不会开启新的线程。

start() 方法 才是真正启动一个新线程并开始执行其中的 run() 方法。当调用 start() 方法时，Java 会创建一个新的线程，并在新的线程中执行 run() 方法中的代码。因此，如果要启动一个新线程并执行其中的代码，就必须使用 start() 方法。

当主线程main调用t.start()方法的时候,另外一个线程就已经启动,开始执行run方法.代表另一个线程线程已经开始,但同时主线程也在启动.进而产生并发.

二.线程中断

线程中断是指在多线程程序中，中断正在运行的线程的执行，通常是由其他线程通过调用目标线程的interrupt()方法来实现。被中断的线程可以捕获这个中断信号并做出相应的处理。

2.1 interrupt()方法

interrupt() 方法是一种请求中断线程的机制。它不会立即停止线程的执行，而是设置线程的中断状态，使线程能够根据这个状态来决定自己的行为。interrupt() 方法是 Thread 类的一个实例方法，可以被任何其他线程调用，用来请求中断目标线程。

1. 设置中断状态：当 interrupt() 方法被调用时，它会将目标线程的中断状态设置为 true。

2. 线程检查中断状态：线程需要定期检查自己的中断状态。这通常在执行关键操作之后或者在循环的检查点进行。

3. 响应中断：线程可以选择响应中断状态，执行必要的清理工作，并安全地退出。线程也可以选择忽略中断状态，继续执行。

class InterruptibleTask implements Runnable {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                // 执行任务
                Thread.sleep(1000); // 休眠1秒
                System.out.println("执行任务");
            } catch (InterruptedException e) {
                // 处理中断
                System.out.println("程序已经被中断了");
                // 清理资源
                return; // 退出run方法
            }
        }
    }
}
 
public class test {
    public static void main(String[] args) {
        Thread taskThread = new Thread(new InterruptibleTask());
        taskThread.start();
 
        // 让任务线程运行一段时间
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        // 请求中断任务线程
        taskThread.interrupt();
        System.out.println("请求中断");
    }
}

InterruptibleTask 在一个循环中执行任务，并在每次迭代后检查是否被中断。当主线程调用 taskThread.interrupt() 时，任务线程会捕获 InterruptedException 并安全地退出。 

2.2 interrupted()方法

interrupted() 是 Java 中 Thread 类的一个静态方法，它用于检查当前线程的中断状态，并且与 isInterrupted() 方法不同，interrupted() 在检查后会清除中断状态。这个方法通常用于流式操作中，以便在处理中断时能够保持中断状态的一致性。

检查中断状态：interrupted() 方法检查当前线程的中断状态。

清除中断状态：无论中断状态如何，interrupted() 方法都会将中断状态重置为未中断（false）。

返回中断状态：该方法返回当前线程的中断状态。

public class Demo {
    private static class MyRunnable implements Runnable {
        @Override
        public void run() {
            // 两种方法均可以
            while (!Thread.interrupted()) {
            //while (!Thread.currentThread().isInterrupted()) {
                System.out.println(Thread.currentThread().getName()
                        + ": 别管我，我忙着转账呢!");
                try {
                    Thread.sleep(1000);
               } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println(Thread.currentThread().getName()
                            + ": 有内鬼，终止交易！");
                    // 注意此处的 break
                    break;
               }
           }
            System.out.println(Thread.currentThread().getName()
                    + ": 啊！险些误了大事");
       }
   }
    public static void main(String[] args) throws InterruptedException {
        MyRunnable target = new MyRunnable();
        Thread thread = new Thread(target, "李四");
        System.out.println(Thread.currentThread().getName()
                + ": 让李四开始转账。");
        thread.start();
        Thread.sleep(10 * 1000);
        System.out.println(Thread.currentThread().getName()
                + ": 老板来电话了，得赶紧通知李四对方是个骗子！");
        thread.interrupt();
   }
}

3.isInterrupted()方法 

在Java中，isInterrupted()方法是用来检查线程的中断状态，但不会清除线程的中断状态。这个方法是一个实例方法，可以通过Thread类的实例来调用。

查询中断状态：isInterrupted() 方法检查调用它的线程的中断状态。

返回中断状态：该方法返回一个布尔值，表示线程的中断状态。如果线程被中断过，或者中断状态被设置过，它将返回 true。

中断状态不清除：调用 isInterrupted() 方法后，线程的中断状态保持不变。

package threrading;
 
public class Demo9 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
           
           while (!Thread.currentThread().isInterrupted()){
               System.out.println("hello t");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   
                   e.printStackTrace();
                   break;
               }
           }
        });
 
        t.start(); 
 
       
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
      
        t.interrupt();  
 
  
    }
}
 

三、线程等待

有时，我们需要等待一个线程完成它的工作后，才能进行自己的下一步工作。例如，张三只有等李四转 账成功，才决定是否存钱，这时我们可以使用join方法明确等待线程的结束。

阻塞等待：当线程A调用线程B的join()方法时，线程A会暂停执行，直到线程B的run()方法执行完毕。
释放锁：在join()方法调用期间，线程A会释放它持有的任何同步锁，这允许其他线程在这些锁上操作。
继续执行：一旦线程B完成执行，线程A会解除阻塞，并继续执行join()方法之后的代码。

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Runnable target = () -> {
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() 
                                       + ": 我还在工作！");
                    Thread.sleep(1000);
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }
           }
            System.out.println(Thread.currentThread().getName() + ": 我结束了！");
       };
        Thread thread1 = new Thread(target, "李四");
        Thread thread2 = new Thread(target, "王五");
        System.out.println("先让李四开始工作");
        thread1.start();
        thread1.join();
        System.out.println("李四工作结束了，让王五开始工作");
        thread2.start();
        thread2.join();
        System.out.println("王五工作结束了");
   }
}

四、线程休眠

线程休眠是通过 Thread 类中的 sleep() 方法实现的。当一个线程调用 sleep() 方法时，它会进入休眠状态，暂停执行一段时间，然后重新开始执行。

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        System.out.println(System.currentTimeMillis());
        Thread.sleep(3 * 1000);//让此线程休眠3秒
        System.out.println(System.currentTimeMillis());
   }
}

五、获取当前线程引用

获取线程的实例非常的简单，就是调用Thread.currentThread()方法，因为线程的调度是不可控的，所以，这个方法只能保证实 际休眠时间是大于等于参数设置的休眠时间的。

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