透视Java多线程之二：多线程的创建，关闭和状态

最新推荐文章于 2022-07-14 09:11:48 发布

纵横千里，捭阖四方

最新推荐文章于 2022-07-14 09:11:48 发布

阅读量250

点赞数

分类专栏： JavaEE

本文链接：https://blog.csdn.net/xueyushenzhou/article/details/105905776

版权

JavaEE 专栏收录该内容

85 篇文章 6 订阅

订阅专栏

1.线程和进程的区别

每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。线程是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行，也可以把它理解为代码运行的上下文。所以线程基本上是轻量级的进程，它负责在单个程序里执行多任务。通常由操作系统负责多个线程的调度和执行。
使用线程可以把占据时间长的程序中的任务放到后台去处理，程序的运行速度可能加快，在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下可以释放一些珍贵的资源如内存占用等等。
如果有大量的线程,会影响性能，因为操作系统需要在它们之间切换，更多的线程需要更多的内存空间，线程的中止需要考虑其对程序运行的影响。通常块模型数据是在多个线程间共享的，需要防止线程死锁情况的发生。
总结:进程是所有线程的集合，每一个线程是进程中的一条执行路径。按照操作系统教科书的说法，进程是资源调度的基本单位，线程是执行调度的基本单位。进程和线程是相对的，很多时候不是那么严格。一般来说我们自己写的一个程序我们就设计为一个进程，由OS进行管理，进程内部都是线程，自己来管理。在《红海行动-公路遇袭》中，我们可以认为整个小组抵抗袭击是一个进程，每个人就是一个线程。每个人不同时间执行的不同工作又是子线程，子线程有可以有自己的子线程。

2.创建线程的几种方式

实现线程有两种基本的方式：lang包下的继承Thread类和实现Runnable方法。在Jdk1.5还可以使用Callable接口和Future方法。
下面分别介绍
第一种方式：继承Thread类，充血run方法
新建一个ThreadDemo1类，然后添加如下代码：

class CreateThreadDemo extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("t1: " + i);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadDemo1 {

    public static void main(String[] args) {
        // 1.创建一个线程
        CreateThreadDemo createThreadDemo = new CreateThreadDemo();
        // 2.开始执行线程 注意 开启线程不是调用run方法，而是start方法
        createThreadDemo.start();
         for (int i = 0; i < 20; i++) {
            System.out.println("t2: " + i);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

第二种方式：实现Runnable接口，重写run方法
代码，首先创建一个ThreadDemo2类，然后添加如下代码：

class CreateThreadDemo2 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("t1: " + i);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) {
        //创建一个新线程
        CreateThreadDemo2 createThreadDemo = new CreateThreadDemo2();
        Thread thread=new Thread(createThreadDemo);
        thread.start();
         for (int i = 0; i < 20; i++) {
            System.out.println("t2: " + i);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

这里首先实现Runnable接口，然后用来初始化Thread，最后通过Thread的start方法来执行。其实可以通过内部类的方式来简化上面的代码，例子：

public class ThreadDemo3 {
    public static void main(String[] args) {
        //创建一个新线程
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println("t1: " + i);
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        thread.start();
    }
}

第三种方式：使用Callable接口，该属于concurrent包，接口形式和Runable很像，但是其call方法有返回值，并且能抛出异常。

问题：1.使用继承Thread类还是使用实现Runnable接口好？
一般认为实现Runnable接口好一些，因为继承的问题是灵活性差，实现了接口可以继续继承，而继承了类不能再继承。
问题2:启动线程是调用start()还是run方法？
开始执行线程使用的是start方法，如果直接使用run就是在主线程里顺序执行了。在上面的例子中，如果将start换成run会发现程序没有报错，而是是顺序执行的。
这里可以这么理解，写start()相当于告诉程序，这里要开始某个线程了，而具体执行什么，则是系统自动调用run来执行。
守护线程
Java中存在两种线程，一种是用户线程，另外一种是守护线程。用户线程是指用户自定义创建的线程，主线程停止，用户线程不会停止。当进程不存在或主线程停止，守护线程也会自动停止。典型的守护线程就是垃圾回收线程，当进程中没有非守护线程了，则垃圾回收线程在完成回收工作之后就没有存在的必要了，自动销毁。
将一个线程变成守护线程的方法非常简单，使用setDaemon(true)方法设置一下就行了。

public class DaemonThread {
   public static void main(String[] args) {
       Thread thread = new Thread(new Runnable() {
           @Override
           public void run() {
               //问题在这里，如果不是守护线程，这里将一直循环下去，不断打印“我是子线程”
               //是守护线程时，与正常的线程执行关系类似
               while (true) {
                   try {
                       Thread.sleep(100);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println("我是子线程");
               }
           }
       });
       thread.setDaemon(true);
       thread.start();

       for (int i = 0; i < 10; i++) {
           try {
               Thread.sleep(100);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("我是主线程");
       }

       System.out.println("主线程执行完毕");
   }
}

3.多线程运行状态

多线程的几种状态和转换关系

线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。
新建状态
当用new操作符创建一个线程时，例如new Thread®，线程还没有开始运行，此时线程处在新建状态。当一个线程处于新生状态时，程序还没有开始运行线程中的代码。
就绪状态
一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。
处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。
运行状态
当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法.
阻塞状态
线程运行过程中，可能由于各种原因进入阻塞状态:
1>线程通过调用sleep方法进入睡眠状态；
2>线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
3>线程试图得到一个锁，而该锁正被其他线程持有；
4>线程在等待某个触发条件；

死亡状态
有两个原因会导致线程死亡：

run方法正常退出而自然死亡，
一个未捕获的异常终止了run方法而使线程猝死。
为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true；如果线程仍旧是new状态且不是可运行的，或者线程死亡了，则返回false.

4.控制线程的顺序和优先级

有时候需要先让某些线程执行，然后再执行其他的。比如在红海行动中，需要先确定地方针对才能让狙击手行动。这可以通过join关键字来控制。而狙击手在消灭阵地时，需要先将对方狙击手压制住，因此后者的优先级比前者还高，这就需要Priority来控制。队员在执行任务时需要队友掩护，此时自己必须先暂停等待时机再行动，这就需要yield关键字来控制。
在计算机的多线程里，我们这么描述：
join作用是让其他线程变为等待, t1.join();// 让其他线程变为等待，直到当前t1线程执行完毕，才释放。
thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。
例如，我们创建一个线程，要求子线程执行完毕之后主线程才执行。

class JoinThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "---i:" + i);
        }
    }
}

public class JoinThreadDemo {
    public static void main(String[] args) {
        JoinThread joinThread = new JoinThread();
        Thread thread1 = new Thread(joinThread);
        Thread thread2 = new Thread(joinThread);
        thread1.start();
        thread2.start();

        try {
            thread1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "---i:" + i);
        }
    }
}