Java并发编程（一）：线程的启动和停止

淡淡的烟草味﹌ 2022-05-14 04:19 34阅读 0赞

### 文章目录 ###

*   *   *  1、如何构造线程
         *  2、如何使用线程
         *   *  2.1、继承Thread类
             *  2.2、实现Runnable接口
         *  3、如何启动线程
         *  4、如何停止线程
         *   *  4.1、如何判断线程是否停止
             *  4.2、 try..catch与this.interrupt方法终止线程
             *  4.3、过期的 suspend()、 resume() 和 stop()方法终止线程

### 1、如何构造线程 ###

在运行线程之前需要先构造线程对象，线程对象的构造需要指定线程所需要的属性，比如：所属线程组、线程优先级、是否为Daemon线程等信息。下面我们看一下，java.lang.Thread中对线程初始化的方法：

private void init(ThreadGroup g, Runnable target, String name,
                          long stackSize, AccessControlContext acc,
                          boolean inheritThreadLocals) {
            if (name == null) {
                throw new NullPointerException("name cannot be null");
            }
            //线程名称
            this.name = name;
            //当前线程就是该线程的父线程
            Thread parent = currentThread();
            SecurityManager security = System.getSecurityManager();
            if (g == null) {
                /* Determine if it's an applet or not */
    
                /* If there is a security manager, ask the security manager
                   what to do. */
                if (security != null) {
                    g = security.getThreadGroup();
                }
    
                /* If the security doesn't have a strong opinion of the matter
                   use the parent thread group. */
                if (g == null) {
                    g = parent.getThreadGroup();
                }
            }
    
            /* checkAccess regardless of whether or not threadgroup is
               explicitly passed in. */
            g.checkAccess();
    
            /*
             * 是否有访问权限
             */
            if (security != null) {
                if (isCCLOverridden(getClass())) {
                    security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
                }
            }
    
            g.addUnstarted();
            //线程组
            this.group = g;
            //使用父线程的daemon、priority属性
            this.daemon = parent.isDaemon();
            this.priority = parent.getPriority();
            if (security == null || isCCLOverridden(parent.getClass()))
                this.contextClassLoader = parent.getContextClassLoader();
            else
                this.contextClassLoader = parent.contextClassLoader;
            this.inheritedAccessControlContext =
                    acc != null ? acc : AccessController.getContext();
            this.target = target;
            setPriority(priority);
            if (inheritThreadLocals && parent.inheritableThreadLocals != null)
                this.inheritableThreadLocals =
                    ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
            /* Stash the specified stack size in case the VM cares */
            this.stackSize = stackSize;
    
            /* 分配一个线程ID */
            tid = nextThreadID();
        }

一个 新 构造 的 线程 对象 是 由其 parent 线程 来 进行 空间 分配 的， 而 child 线程 继承 了 parent 是否 为 Daemon、 优先级 和 加载 资源 的 contextClassLoader 以及 可继承 的 ThreadLocal， 同时 还会 分配 一个 唯一 的 ID 来 标识 这个 child 线程。 至此， 一个 能够 运行 的 线程 对象 就 初始化 好了， 在 堆 内存 中 等待 着 运行。

我们构造一个Thread thread=new Thread（），打上断点，可以看到thread对象的属性如下：  
![image][]

### 2、如何使用线程 ###

实现多线程编程的方式主要有两种：一种是继承Thread类，一种是实现Runnable接口，使用继承Thread类最大的局限性是不支持多继承，由于java单继承的特性，为了突破单继承的限制，于是就有了另一个实现方式，就是实现Runnable接口。使用这两种方式创建的线程工作性质是一样的，没有本质的区别。

#### 2.1、继承Thread类 ####

public class MyThread extends Thread {
        @Override
        public void run() {
            super.run();
            System.out.println("我是自定义线程MyThread");
        }
    }

#### 2.2、实现Runnable接口 ####

public class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("我是Runnable");
        }
    }

### 3、如何启动线程 ###

线程对象初始化完成后，调用线程的start()方法就可以启动线程了，start()方法是告诉Java虚拟机，如果线程规划期空闲，应该立即启动调用了start()方法的线程。

同一个线程不能多次 调用 start（） 方法， 否则会出现异常 Exception in thread" main" java. lang. IllegalThreadStateException。

线程的start()方法，会新启动一个线程，而线程run()方法则是同步等待当前线程调用。

### 4、如何停止线程 ###

#### 4.1、如何判断线程是否停止 ####

在介绍如何停止线程的知识点前， 先看一下如何判断线程是否停止的状态。 Thread.java类中提供了两个很重要的方法：

1） this.interrupted（）： 判断当前线程是否已经中断

2） this.isInterrupted（）： 判断线程是否已经中断

那么这两种方法的区别是什么呢？ 先来看看 this.interrupted（）方法： 判断当前线程是否已经中断，当前线程是指运行 this. interrupted（）方法 的 线程。

public static void main(String[] args) {
            Thread.currentThread().interrupt();
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " 当前线程是否已停止：=" + Thread.interrupted());
            System.out.println(threadName + " 当前线程是否已停止：=" + Thread.interrupted());
    
        }
    main 当前线程是否已停止：=true
    main 当前线程是否已停止：=false

从执行结果可知 interrupt()方法确实停止了线程，但是第二个判断结果为什么是false呢，通过查看官方文档当解释得知。interrupted() 具有清除状态的功能，所以第二个判断结果为false

下面我们接着查看 isInterrupted()方法：

public static void main(String[] args) {
            Thread.currentThread().interrupt();
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " 当前线程是否已停止：=" + Thread.currentThread().isInterrupted());
            System.out.println(threadName + " 当前线程是否已停止：=" + Thread.currentThread().isInterrupted());
    
        }
        
    main 当前线程是否已停止：=true
    main 当前线程是否已停止：=true

输出的结果都为true，isInterrupted()并未清除状态标志，最后我们得出如下结论：

1） this.interrupted（）： 判断线程终止的状态， 执行后具有将状态标志置为false的功能

2） this.isInterrupted（）：判断线程终止的状态，不具有清除状态标志的功能

#### 4.2、 try…catch与this.interrupt方法终止线程 ####

public class MyThread extends Thread {
        @Override
        public void run() {
            super.run();
            for (int i = 0; i < 5000; i++) {
                if (interrupted()) {
                    System.out.println(Thread.currentThread().getName() + " 我被停止了，退出循环");
                    break;
                }
                System.out.println(" i=" + (i + 1));
            }
        }
    }
    
    public static void main(String[] args) {
            MyThread thread = new MyThread();
            thread.setName("Thread-interrupt-0");
            thread.start();
            try {
                Thread.sleep(1);
                thread.interrupt();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(" 结束!");
        }
        
    输出结果：
    .....
    i=32
     i=33
     i=34
     i=35
     i=36
     i=37
     i=38
     i=39
     i=40
     i=41
     结束!
    Thread-interrupt-0 我被停止了，退出循环

#### 4.3、过期的 suspend()、 resume() 和 stop()方法终止线程 ####

suspend()在调用后线程不会释放已经占有的资源，二是占有着资源进入睡眠状态，这样容易引发死锁问题。同样的stop()方法在终止一个线程时不会保证线程的资源正常释放，通常线程没有机会去释放资源，因此会导致程序工作状态的不确定性。

正是因为 suspend()、 resume() 和 stop() 方法 带来的副作用， 这些方法才被标志位不建议使用的过期方法， 而暂停和恢复可以使用 等待/ 通知机制 来替代。

[image]: http://om6hv2adi.bkt.clouddn.com/thread_init.png