Java：线程详解

于 2021-03-08 20:47:54 发布
阅读量559 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 实习面试 # Java 笔记 文章标签： 多线程 队列 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SongXJ_01/article/details/114534346

目录

进程与线程

进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，即进程空间。进程不依赖于线程而独立存在，一个进程中可以启动多个线程。比如在 Windows 系统中，一个运行的 exe 就是一个进程。

线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如 Java.exe 进程中可以运行很多线程。线程总是属于某个进程，线程没有自己的虚拟地址空间，与进程内的其他线程一起共享分配给该进程的所有资源。

“同时”执行是人的感觉，在线程之间实际上轮换执行。

进程在执行过程中拥有独立的内存单元，进程有独立的地址空间，而多个线程共享内存，从而极大地提高了程序的运行效率。

线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

线程是进程的一个实体，是 CPU 调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器,一组寄存器和栈），但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程包含以下内容：

  • 一个指向当前被执行指令的指令指针；
  • 一个栈；
  • 一个寄存器值的集合，定义了一部分描述正在执行线程的处理器状态的值 一个私有的数据区。

我们使用Join()方法挂起当前线程，直到调用Join()方法的线程执行完毕。该方法还存在包含参数的重载版本，其中的参数用于指定等待线程结束的最长时间（即超时）所花费的毫秒数。如果线程中的工作在规定的超时时段内结束，该版本的Join()方法将返回一个布尔量True。

简而言之：

一个程序至少有一个进程，一个进程至少有一个线程。线程的划分尺度小于进程，使得多进程程序的并发性高。另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

在 Java 中，每次程序运行至少启动2个线程：一个是main线程，一个是垃圾收集线程。因为每当使用 Java 命令执行一个类的时候，实际上都会启动一个 JVM ，每一个 JVM 实际上就是在操作系统中启动了一个进程。

Java中的线程

在 Java 中，“线程”指两件不同的事情：

  1. Java.lang.Thread 类的一个实例；

  2. 线程的执行。

在 Java程序中，有两种方法创建线程：

  1. 对 Thread 类进行派生并覆盖 run 方法；

  2. 通过实现 Runnable 接口创建。

使用 Java.lang.Thread 类或者 Java.lang.Runnable 接口编写代码来定义、实例化和启动新线程。

一个 Thread 类实例只是一个对象，像 Java 中的任何其他对象一样，具有变量和方法，生死于堆上。Java 中，每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。

一个 Java 应用总是从 main() 方法开始运行，main() 方法运行在一个线程内，他被称为主线程。一旦创建一个新的线程，就产生一个新的调用栈。

线程总体分两类：用户线程和守候线程。当所有用户线程执行完毕的时候，JVM自动关闭。但是守候线程却不独立于 JVM，守候线程一般是由操作系统或者用户自己创建的。

Java线程：创建与启动

定义线程

  1. 扩展 java.lang.Thread 类。

此类中有个run()方法，应该注意其用法：public void run()。如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run() 方法；否则，该方法不执行任何操作并返回。Thread 的子类应该重写该方法。

  1. 实现 java.lang.Runnable 接口。

void run()，使用实现接口 Runnable 的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的 run 方法。

实例化线程

  1. 如果是扩展 java.lang.Thread 类的线程，则直接 new 即可。

  2. 如果是实现了 java.lang.Runnable 接口的类，则用 Thread 的构造方法：

Thread(Runnabletarget)  
Thread(Runnabletarget, String name)  
Thread(ThreadGroupgroup, Runnable target)  
Thread(ThreadGroupgroup, Runnable target, String name)  
Thread(ThreadGroupgroup, Runnable target, String name, long stackSize)

其中：

  • Runnable target：实现了 Runnable 接口的类的实例。
  • String name：线程的名子。这个名子可以在建立 Thread 实例后通过 Thread 类的 setName 方法设置。默认线程名：Thread-N，N 是线程建立的顺序，是一个不重复的正整数。
  • ThreadGroup group：当前建立的线程所属的线程组。如果不指定线程组，所有的线程都被加到一个默认的线程组中。
  • long stackSize：线程栈的大小，这个值一般是 CPU 页面的整数倍。

启动线程

在线程的 Thread 对象上调用 start() 方法，而不是 run() 或者别的方法。

在调用 start() 方法之前：线程处于新状态中，新状态指有一个 Thread 对象，但还没有一个真正的线程。

在调用 start() 方法之后：发生了一系列复杂的事情——

  1. 启动新的执行线程（具有新的调用栈）；
  2. 该线程从新状态转移到可运行状态；
  3. 当该线程获得机会执行时，其目标 run() 方法将运行。

注意：对 Java 来说，run() 方法没有任何特别之处。像 main() 方法一样，它只是新线程知道调用的方法名称（和签名）。因此，在 Runnable 上或者 Thread 上调用 run 方法是合法的，但并不启动新的线程。

例子

实现Runnable接口的多线程例子

/** 
 * 实现Runnable接口的类 
 */  
public class RunnableImpl implements Runnable{  
    private Stringname;  
    public RunnableImpl(String name) {  
       this.name = name;  
    }  
    @Override  
    public void run() {  
       for (int i = 0; i < 5; i++) {  
           for(long k=0;k<100000000;k++);  
           System.out.println(name+":"+i);  
       }       
    }  
}  
   
/** 
 * 测试Runnable类实现的多线程程序 
 */  
public class TestRunnable {  
    public static void main(String[] args) {  
       RunnableImpl ri1=new RunnableImpl("李白");  
       RunnableImpl ri2=new RunnableImpl("屈原");  
       Thread t1=new Thread(ri1);  
       Thread t2=new Thread(ri2);  
       t1.start();  
       t2.start();  
    }  
}  

/** 
执行结果：
屈原:0  
李白:0  
屈原:1  
李白:1  
屈原:2  
李白:2  
李白:3  
屈原:3  
李白:4  
屈原:4
 */

扩展Thread类实现的多线程例子

/** 
 * 测试扩展Thread类实现的多线程程序 
 */  
public class TestThread extends Thread {  
    public TestThread(String name){  
       super(name);  
    }  
    @Override  
    public void run() {  
       for(int i=0;i<5;i++){  
           for(long k=0;k<100000000;k++);  
           System.out.println(this.getName()+":"+i);  
       }  
    }  
    public static void main(String[] args){  
       Thread t1=new TestThread("李白");  
       Thread t2=new TestThread("屈原");  
       t1.start();  
       t2.start();        
    }  
}  

/** 
执行结果：
屈原:0  
李白:0  
屈原:1  
李白:1  
屈原:2  
李白:2  
屈原:3  
屈原:4  
李白:3  
李白:4
 */

一些常见问题

  1. 线程的名字，一个运行中的线程总是有名字的，名字有两个来源，一个是虚拟机自己给的名字，一个是你自己的定的名字。在没有指定线程名字的情况下，虚拟机总会为线程指定名字，并且主线程的名字总是mian，非主线程的名字不确定。

  2. 线程都可以设置名字，也可以获取线程的名字，连主线程也不例外。

  3. 获取当前线程的对象的方法是：Thread.currentThread()；

  4. 在上面的代码中，只能保证：每个线程都将启动，每个线程都将运行直到完成。一系列线程以某种顺序启动并不意味着将按该顺序执行。对于任何一组启动的线程来说，调度程序不能保证其执行次序，持续时间也无法保证。

  5. 当线程目标 run() 方法结束时该线程完成。

  6. 一旦线程启动，它就永远不能再重新启动。只有一个新的线程可以被启动，并且只能一次。一个可运行的线程或死线程可以被重新启动。

  7. 线程的调度是 JVM 的一部分，在一个 CPU 的机器上上，实际上一次只能运行一个线程。一次只有一个线程栈执行。JVM 线程调度程序决定实际运行哪个处于可运行状态的线程。众多可运行线程中的某一个会被选中做为当前线程。可运行线程被选择运行的顺序是没有保障的。

  8. 尽管通常采用队列形式，但这是没有保障的。队列形式是指当一个线程完成“一轮”时，它移到可运行队列的尾部等待，直到它最终排队到该队列的前端为止，它才能被再次选中。事实上，我们把它称为可运行池而不是一个可运行队列，目的是帮助认识线程并不都是以某种有保障的顺序排列而成一个一个队列的事实。

  9. 尽管我们没有无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。

阻止线程执行

睡眠 sleep()

睡眠的位置：为了让其他线程有机会执行，可以将 Thread.sleep() 的调用放线程 run() 之内。这样才能保证该线程执行过程中会睡眠。

for(int i=0;i<5;i++){  
           // 很耗时的操作，用来减慢线程的执行  
           //for(longk=0;k<100000000;k++);  
           try {  
                Thread.sleep(3);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
           System.out.println(this.getName()+":"+i);  
    }

这样，线程在每次执行过程中，总会睡眠3毫秒，睡眠了，其他的线程就有机会执行了。

注意：

  1. 线程睡眠是帮助所有线程获得运行机会的最好方法。

  2. 线程睡眠到期自动苏醒，并返回到可运行状态，不是运行状态。sleep() 中指定的时间是线程不会运行的最短时间。因此，sleep() 方法不能保证该线程睡眠到期后就开始执行。

  3. sleep() 是静态方法，只能控制当前正在运行的线程。

线程的优先级和线程让步 yield()

线程的让步是通过 Thread.yield() 来实现的。yield() 方法的作用是：暂停当前正在执行的线程对象，并执行其他线程。

要理解 yield()，必须了解线程的优先级的概念。线程总是存在优先级，优先级范围在 1~10 之间。JVM 线程调度程序是基于优先级的抢先调度机制。在大多数情况下，当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。

注意：当设计多线程应用程序的时候，一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作。

设置线程的优先级：线程默认的优先级（5）是创建它的执行线程的优先级。可以通过 setPriority(int newPriority) 更改线程的优先级。例如：

Thread t = new MyThread();  
t.setPriority(8);  
t.start();

Thread.yield() 方法

Thread.yield() 方法作用是：暂停当前正在执行的线程对象，并执行其他线程。

yield() 应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用 yield() 的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证 yield() 达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

join() 方法

Thread 的非静态方法 join() 让一个线程 B 加入到另外一个线程 A 的尾部。在 A 执行完毕之前，B 不能工作。例如：

Thread t = new MyThread();  
t.start();  
t.join();

另外，join() 方法还有带超时限制的重载版本。例如 t.join(5000); 则让线程等待 5000 毫秒，如果超过这个时间，则停止等待，变为可运行状态。

线程的加入 join() 对线程栈导致的结果使线程栈发生了变化，当然这些变化都是瞬时的。下面给示意图：

在这里插入图片描述

小结

到目前位置，介绍了线程离开运行状态的 3 种方法：

  1. 调用 Thread.sleep()：使当前线程睡眠至少多少毫秒（尽管它可能在指定的时间之前被中断）。

  2. 调用 Thread.yield()：不能保障太多事情，尽管通常它会让当前运行线程回到可运行性状态，使得有相同优先级的线程有机会执行。

  3. 调用 join() 方法：保证当前线程停止执行，直到该线程所加入的线程完成为止。然而，如果它加入的线程没有存活，则当前线程不需要停止。

除了以上三种方式外，还有下面几种特殊情况可能使线程离开运行状态：

  1. 线程的 run() 方法完成。

  2. 在对象上调用 wait() 方法（不是在线程上调用）。

参考文章：https://blog.csdn.net/kwame211/article/details/78963044

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值