java中的线程使用

线程是我们在日常工作中经常使用的类，接下来将介绍线程的基本使用方法。

线程创建

我们常用的线程有五种创建方式：

• 继承Thread重写Run方法
• 将Run方法封装到继承Runnable接口的类中
• 匿名类
• 使用重写Runnale中Run方法的匿名类
• lambda

继承Thread重写Run方法

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

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

将Run方法封装到继承Runnable接口的类中

public class MyThread2 extends Thread{
    public static void main(String[] args) {
        Thread t=new Thread(new MyRunnable());
        t.start();
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("利用Runnable来实现的Thread的应用 ");
    }
}

匿名类

public class demo1 {

   public static void main(String[] args) {
      
       //匿名类
       Thread t=new Thread(){
           @Override
           public void run() {
               System.out.println("匿名类");
           }
       };
       t.start();
   }


}

使用重写Runnale中Run方法的匿名类

public class demo2 {

   public static void main(String[] args) {
       
        //重写Runnable中的run方法
       Thread t4=new Thread(new MyRunnable()){
           @Override
           public void run() {
               System.out.println("使用runnable");
           }
       };
       t.start();
   }
}

lambda方法

public class demo3 {

   public static void main(String[] args) {
       //lambda方法
       Thread t5=new Thread(() -> {
           System.out.println("使用lambda");
       }); 
       t.start();
   }
}

线程的休眠

Thread.sleep()是Thread类中内置的一个休眠方法，它的作用是让当前线程休眠

public class demo4 {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            try {
                Thread.sleep(1000);
                System.out.println("休眠1s");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        t.start();
    }
}

线程中断

线程中断即线程运行过程中被其他线程给打断了，它与 stop 最大的区别是：stop 是由系统强制终止线程，而线程中断则是给目标线程发送一个中断信号，如果目标线程没有接收线程中断的信号并结束线程，线程则不会终止，具体是否退出或者执行其他逻辑由目标线程决定。

我们来看下线程中断最重要的 3 个方法，它们都是来自 Thread 类！

1、java.lang.Thread#interrupt

中断目标线程，给目标线程发一个中断信号，线程被打上中断标记。

2、java.lang.Thread#isInterrupted()

判断目标线程是否被中断，不会清除中断标记。

3、java.lang.Thread#interrupted

判断目标线程是否被中断，会清除中断标记。

线程等待

一个主线程有多个子线程，如何能使子线程的业务执行完成之后，再执行主线程业务逻辑。

对于这个问题，我们可以使用线程中的join方法

主线程等待子线程的终止。也就是说主线程的代码块中，如果碰到了join()方法，此时主线程需要等待（阻塞），等待子线程结束了(Waits for this thread to die.),才能继续执行join()之后的代码块。

public static void demo5() throws InterruptedException {
    List<Thread> threadSet = new ArrayList<>();
    for (int i = 1; i < 10; i++) {
        Thread thread = new Thread(() -> {
            //线程执行
            System.out.println("子线程执行");
        });
        thread.start();
        threadSet.add(thread);
    }
    for (Thread thread : threadSet) {
        thread.join();
    }
    System.out.println("子线程执行完，主线程继续执行");
}