zoukankan      html  css  js  c++  java
  • Java多线程并发01——线程的创建与终止,你会几种方式

    本文开始将开始介绍 Java 多线程与并发相关的知识,多谢各位一直以来的关注与支持。关注我的公众号「Java面典」了解更多 Java 相关知识点。

    线程的创建方式

    在 Java 中,用户常用的主动创建线程的方式有三种,分别是 继承 Thread 类实现 Runnable 接口通过Callable 和 Future

    继承 Thread 类

    • 定义 Thread 类的子类,并重写该类的 run 方法;
    • 调用线程对象的 start() 方法来启动该线程。

    通过继承 Thread 实现的线程类,多个线程间无法共享线程类的实例变量(需要创建不同 Thread 对象)。

    /**
     * 通过继承Thread实现线程
     */
    public class MyThread extends Thread {
        public void run() {
            System.out.println("MyThread.run()");
        }
    }
    
    MyThread myThread = new MyThread();
    myThread.start();
    

    实现 Runnable 接口

    • 如果自己的类已经 extends 另一个类,就无法直接 extends Thread,此时,可以实现一个 Runnable 接口;
    • 调用线程对象的start()方法来启动该线程。
    /**
     * 通过实现Runnable接口实现的线程类
     */
    public class RunnableTest implements Runnable {
        @Override
        public void run() {
            System.out.println("RunnableTest.run()");
        }
    
        public static void main(String[] args) {
            RunnableTest runnableTest = new RunnableTest() ;
            Thread thread = new Thread(runnableTest);
            thread.start();
        }
    }
    

    通过 Callable、Future

    从 Thread 和 Runnable 两种方式可以看出,两种方式都不支持返回值,且不能声明抛出异常

    而 Callable 接口则实现了此两点,Callable 接口如同 Runable 接口的升级版,其提供的 call() 方法将作为线程的执行体,同时允许有返回值。

    但是 Callable 对象不能直接作为 Thread 对象的 target,我们可以使用 FutureTask 类来包装 Callable 对象,该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。

    import java.util.concurrent.Callable;
    import java.util.concurrent.FutureTask;
    
    public class CallableTest {
        public static void main(String[] args) {
            CallableTest callableTest = new CallableTest() ;
            //因为Callable接口是函数式接口,可以使用Lambda表达式
            FutureTask<String> task = new FutureTask<Integer>((Callable<String>)()->{
              System.out.println("FutureTask and Callable");
              return "hello word";
            });
    
           try{
               System.out.println("子线程返回值 : " + task.get());
            } catch (Exception e){
               e.printStackTrace();
            }
        }
    }
    

    线程的终止方式

    线程除了正常结束外,还可以通过特定方式终止线程,终止线程常用的方式有以下三种:使用退出标志退出线程、** Interrupt 方法结束线程stop 方法终止线程**。

    使用退出标志退出线程

    最常使用的方式其实现方式是:定义一个 boolean 型的标志位,在线程的 run() 方法中根据这个标志位是 true 还是 false 来判断是否退出,这种情况一般是将任务放在 run() 方法中的一个 while 循环中执行的。

    public class ThreadSafe extends Thread {
        public volatile boolean exit = false;
        public void run() {
            while (!exit){
                //do work
            }
        }
    
        public static void main(String[] args) throws Exception  {  
            ThreadFlag thread = new ThreadFlag();  
            thread.start();  
            sleep(5000); // 主线程延迟5秒  
            thread.exit = true;  // 终止线程thread    
            thread.join();  
            System.out.println("线程退出!");  
        }
    }
    

    Interrupt 方法结束线程

    使用 interrupt() 方法来中断线程有两种情况:

    1. 线程处于阻塞状态。如使用了 sleep,同步锁的 wait,socket 中的 receiver,accept 等方法时,会使线程处于阻塞状态。使用 interrupt 方法结束线程的时候,一定要先捕获 InterruptedException 异常之后通过 break 来跳出循环,才能正常结束 run 方法。
    public class ThreadInterrupt extends Thread {  
        public void run()  {  
            try {  
                sleep(50000);  // 延迟50秒  
            }  
            catch (InterruptedException e) {  
                System.out.println(e.getMessage());  
            }  
        }  
        public static void main(String[] args) throws Exception  {  
            Thread thread = new ThreadInterrupt();  
            thread.start();  
            System.out.println("在50秒之内按任意键中断线程!");  
            System.in.read();  
            thread.interrupt();  
            thread.join();  
            System.out.println("线程已经退出!");  
        }  
    }
    
    1. 线程未处于阻塞状态。使用 isInterrupted() 判断线程的中断标志来退出循环。当使用 interrupt() 方法时,中断标志就会置 true,和使用自定义的标志来控制循环是一样的道理。
    public class ThreadSafe extends Thread {
        public void run() {
            while (!isInterrupted()) { //非阻塞过程中通过判断中断标志来退出
                try {
                    Thread.sleep(5*1000);//阻塞过程捕获中断异常来退出
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;//捕获到异常之后,执行 break 跳出循环
                }
            }
        }
    }
    

    stop 方法终止线程

    使用 stop 方法可以强行终止正在运行或挂起的线程。我们可以使用如下的代码来终止线程:

    thread.stop();
    

    采用 stop 是不安全的,主要影响点如下:

    1. thread.stop() 调用之后,创建子线程的线程就会抛出 ThreadDeatherror 的错误;
    2. 调用 stop 会释放子线程所持有的所有锁。导致了该线程所持有的所有锁的突然释放(不可控制),那么被保护数据就有可能呈现不一致性。

    总结

    • 线程创建:推荐使用 Runnable 或者 Callable 方式创建线程,相比继承,接口实现可以更加灵活,不会受限于Java的单继承机制。
    • 线程终止:线程终止推荐使用 标志位 或 Interrupt 方式终止,stop 方式对线程不安全,易导致数据不一致。
  • 相关阅读:
    面试范围
    Spark集群基础概念 与 spark架构原理
    RDD 算子补充
    常用Actoin算子 与 内存管理 、共享变量、内存机制
    常用Transformation算子
    spark core (二)
    Spark 介绍
    JSON对象和string的相互转换
    javascript中substring和substr方法
    mongodb学习相关网址
  • 原文地址:https://www.cnblogs.com/weechang/p/12499987.html
Copyright © 2011-2022 走看看