Java_多线程

想做CTO的任同学...

已于 2023-10-10 16:45:46 修改

阅读量2.4k

点赞数 1

分类专栏： Java 文章标签： java 开发语言

于 2020-09-20 11:34:52 首次发布

本文链接：https://blog.csdn.net/qq_43408367/article/details/108676975

版权

Java 专栏收录该内容

36 篇文章 0 订阅

订阅专栏

文章目录

Java_进程的概念
Java_线程的创建

Java_进程的概念

程序 - 数据结构 + 算法，主要指存放在硬盘上的可执行文件。
进程(process)是主要指运行在内存中的可执行文件。
一个进程包括由操作系统分配的内存空间，包含一个或多个线程，并且进程是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期(如：运行中的QQ，运行中的MP3播放器)
进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

线程的概念

线程就是进程内部的程序流，也就是说操作系统内部支持多进程的，而每个进程的内部又是支持多线程的，线程是轻量的，新建线程会共享所在进程的系统资源
线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小，但是线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束
一个进程中的多个线程共享相同的内存单元/内存地址空间,多个线程从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。
多线程是采用时间片轮转法来保证多个线程的并发执行，所谓并发就是指宏观并行微观串行的机制。
多线程可以用来编写高效率的程序来达到充分利用 CPU 的目的，并且可以改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销

多线程的使用场景;

程序需要同时执行两个或多个任务。
程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
程序需要一些后台运行的程序时。

在这里插入图片描述
单核和多核

单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。即同一时间处理一个事情,有其他事情了,先排队,然后一个个处理,但是运行很快
多核的CPU话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
Java应用程序java.exe，其实至少有三个线程：main()主线程，gc() 垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片)同时执行多个任务。比如：多个人做同一件事。

Java_线程的创建

Java_线程的创建方式一：自定义类继承Thread类

Thread类的概念

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。 java.lang.Thread类代表线程，任何线程对象都是Thread类（子类）的实例。
通过该Thread对象的start()方法来启动这个线程，而非直接调用run()，每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
Thread类是线程的模板，封装了复杂的线程开启等操作，封装了操作系统的差异性。

线程的创建方式一：自定义类继承Thread类

自定义类继承Thread类并重写run方法，然后创建该类的对象调用start方法。继承 Thread：线程代码存放Thread子类run方法中。
自定义类实现Runnable接口并重写run方法，创建该类的对象作为实参来构造Thread类型的对象，然后使用Thread类型的对象调用start方法。
继承Thread类的方式代码简单，但是若该类继承Thread类后则无法继承其它类，而实现Runnable接口的方式代码复杂，但不影响该类继承其它类以及实现其它接口，因此通常使用实现Runnable接口的方式
如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
想要启动多线程，必须调用start方法。
一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。

package com.company;
// 1. 定义子类继承`Thread`类。
// 2. 子类中重写`Thread`类中的`run`方法
// 3. 创建`Thread`子类对象，即创建了线程对象。
// 4. 调用线程对象`start`方法：启动线程，调用`run`方法
// 通过继承 Thread 类的方式新建一个线程
public class Java_28 {
    public static void main(String args[]) {
        ThreadDemo T1 = new ThreadDemo( "Thread-1");
        T1.start();

        ThreadDemo T2 = new ThreadDemo( "Thread-2");
        T2.start();
    }
}
class ThreadDemo extends Thread {
    private Thread t;
    private String threadName;

    ThreadDemo( String name) {
        threadName = name;
        System.out.println("创建线程 " +  threadName );
    }

    public void run() {
        System.out.println("执行线程 " +  threadName );
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("线程名为: " + threadName + ", " + i);
                // 让线程睡眠一会
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {
            System.out.println("线程出现异常 " +  threadName + " interrupted.");
        }
        System.out.println("线程名为 " +  threadName + " exiting.");
    }

    public void start () {
        System.out.println("启动线程 " +  threadName );
        if (t == null) {
            t = new Thread (this, threadName);
            t.start ();
        }
    }
}

Thread类的常用方法

方法声明	功能介绍
Thread()	使用无参的方式构造对象
Thread(String name)	根据参数指定的名称来构造对象
Thread(Runnable target)	根据参数指定的引用来构造对象，其中Runnable是个接口类型
Thread(Runnable target, String name)	根据参数指定引用和名称来构造对象
void run()	若使用Runnable引用构造了线程对象，调用该方法时最终调用接口中的版本，若没有使用Runnable引用构造线程对象，调用该方法时则啥也不做
void start()	用于启动线程，Java虚拟机会自动调用该线程的run方法

线程的执行流程

执行main方法的线程叫做主线程，执行run方法的线程叫做新线程/子线程
main方法是程序的入口，对于start方法之前的代码来说，由主线程执行一次，当start方法调用成功后线程的个数由1个变成了2个，新启动的线程去执行run方法的代码，主线程继续向下执行，两个线程各自独立运行互不影响。
当run方法执行完毕后子线程结束，当main方法执行完毕后主线程结束。
两个线程执行没有明确的先后执行次序，由操作系统调度算法来决定。

匿名内部类的方式

使用匿名内部类的方式来创建和启动线程。

Java_线程的创建方式二：实现Runnable接口

创建一个实现 Runnable 接口的类。
为了实现Runnable,一个类只需要执行一个方法调用run():public void run(),可以重写run方法,同时 run() 可以调用其他方法，使用其他类，并声明变量，就像主线程一样。
在创建一个实现 Runnable 接口的类之后，可以在类中实例化一个线程对象。
新线程创建之后,可以调用线程的start()方法运行新线程
实现Runnable：线程代码存在接口的子类的run方法。
1. 实现Runnable 创建线程避免了单继承的局限性
2. 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。
  方式一:实现Runnable接口

package com.company;
// 使用 Runnable 接口实现线程
1. 定义子类，实现`Runnable`接口。
2. 子类中重写`Runnable`接口中的`run`方法。
3. 通过`Thread`类含参构造器创建线程对象。
4. 将`Runnable`接口的子类对象作为实际参数传递给`Thread`类的构造器中。
5. 调用`Thread`类的`start`方法：开启线程，调用`Runnable`子类接口的`run`方法。

public class Java_27 {
    public static void main(String args[]) {
        RunnableDemo R1 = new RunnableDemo( "Thread-1");
        R1.start();

        RunnableDemo R2 = new RunnableDemo( "Thread-2");
        R2.start();
    }
}

class RunnableDemo implements Runnable {
    private Thread t;
    private String threadName;

    RunnableDemo( String name) {
        threadName = name;
        System.out.println("创建线程 " +  threadName );
    }

    public void run() {
        System.out.println("启动线程 " +  threadName );
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("线程执行: " + threadName + ", " + i);
                // 让线程睡眠一会
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {
            System.out.println("线程执行出现异常 " +  threadName + " interrupted.");
        }
        System.out.println("线程执行 " +  threadName + " exiting.");
    }

    public void start () {
        System.out.println("开始执行线程 " +  threadName );
        if (t == null) {
            t = new Thread (this, threadName);
            t.start ();
        }
    }
}

Java_线程的生命周期

线程是一个动态执行的过程

在这里插入图片描述

新建状态：使用new关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。此时线程并没有开始执行。它保持这个状态直到程序 start() 这个线程。
就绪状态：当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。此时线程还是没有开始执行。
运行状态：如果就绪状态的线程获取了CPU资源,就可以执行run(),此时线程开始执行，处于运行状态,运行状态的线程最为复杂,可以变为阻塞状态,就绪状态和消亡状态
消亡状态 : 当线程的任务执行完成后进入的状态，此时线程已经终止。
阻塞状态 :当线程执行的过程中发生了阻塞事件进入的状态，如：sleep方法。阻塞状态解除后进入就绪状态。

补充：线程的阻塞状态

如果一个线程执行了sleep睡眠,suspend(挂起)等方法,在线程失去所占用的资源后,该线程就成运行状态进入阻塞状态,在睡眠时间完毕或者获得设备资源之后,就可以重新进入就绪状态

synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问。
synchronized 修饰符可以应用于四个访问修饰符。

public synchronized void showDetails(){
    .......
}

补充：线程的阻塞状态分为三种:

等待阻塞:运行状态中的线程执行wait()方法,使得线程进入等待阻塞状态
同步阻塞:线程在获取synchronized同步锁失败(因为同步锁被其他线程占用)
其他阻塞:通过调用线程的sleep()或join()发出了I/O请求时,线程就会进入阻塞状态,当sleep()状态超时时,join()等待线程终止或超时,或者I/O处理完毕,线程重新转入就绪状态

补充：线程的消亡状态

一个运行状态的线程完成任务或者其他终止条件发生时,该线程就切换到终止状态

获取线程的编号和名称

方法声明	功能介绍
long getId()	获取调用对象所表示线程的编号
String getName()	获取调用对象所表示线程的名称
void setName(String name)	设置/修改线程的名称为参数指定的数值
static Thread currentThread()	获取当前正在执行线程的引用

常用的方法

方法声明	功能介绍
static void yield()	当前线程让出处理器（离开Running状态），使当前线程进入Runnable状态等待
static void sleep(times)	使当前线程从 Running 放弃处理器进入Block状态, 休眠times毫秒, 再返回到Runnable如果其他线程打断当前线程的Block(sleep), 就会发生InterruptedException。
int getPriority()	获取线程的优先级
void setPriority(int newPriority)	修改线程的优先级。优先级越高的线程不一定先执行，但该线程获取到时间片的机会会更多一些
void join()	等待该线程终止
void join(long millis)	等待参数指定的毫秒数
boolean isDaemon()	用于判断是否为守护线程
void setDaemon(boolean on)	用于设置线程为守护线程

Java_线程同步机制

基本概念

当多个线程同时访问同一种共享资源时，可能会造成数据的覆盖等不一致性问题，此时就需要对线程之间进行通信和协调，该机制就叫做线程的同步机制。
多个线程并发读写同一个临界资源时会发生线程并发安全问题。
异步操作:多线程并发的操作，各自独立运行。
同步操作:多线程串行的操作，先后执行的顺序。

减少串行操作的解决方案

在Java语言中使用synchronized关键字来实现同步/对象锁机制从而保证线程执行的原子性，具体方式如下：
使用同步代码块的方式实现部分代码的锁定，格式如下：

 synchronized(类类型的引用) {
 	编写所有需要锁定的代码；
 } 
// 使用同步方法的方式实现所有代码的锁定。
// 直接使用synchronized关键字来修饰整个方法即可
// 该方式等价于:
 synchronized(this) { 整个方法体的代码 }

** 静态方法的锁定**

当我们对一个静态方法加锁，如:public synchronized static void xxx(){….}，那么该方法锁的对象是类对象。每个类都有唯一的一个类对象。获取类对象的方式:类名.class。
静态方法与非静态方法同时使用了synchronized后它们之间是非互斥关系的。原因在于：静态方法锁的是类对象而非静态方法锁的是当前方法所属对象。
使用synchronized保证线程同步应当注意:
1. 多个需要同步的线程在访问同步块时，看到的应该是同一个锁对象引用。
2. 在使用同步块时应当尽量减少同步范围以提高并发的执行效率。

线程安全类和不安全类

StringBuffer类是线程安全的类，但StringBuilder类不是线程安全的类。
Vector类和 Hashtable类是线程安全的类，但ArrayList类和HashMap类不是线程安全的类。
Collections.synchronizedList() 和 Collections.synchronizedMap()等方法实现安全。

死锁的概念

线程一执行的代码：
public void run(){
	 synchronized(a){ //持有对象锁a，等待对象锁b
		 synchronized(b){
		 	编写锁定的代码;
		 }
	 }
}
线程二执行的代码：
public void run(){
	 synchronized(b){ //持有对象锁b，等待对象锁a
		 synchronized(a){
		 	编写锁定的代码;
		 }
	 }
}
// 注意：尽量减少同步的资源，减少同步代码块的嵌套结构的使用！

Java_使用Lock（锁）实现线程同步

基本概念

从Java5开始提供了更强大的线程同步机制—使用显式定义的同步锁对象来实现。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。
该接口的主要实现类是ReentrantLock类，该类拥有与synchronized相同的并发性，在以后的线程安全控制中，经常使用ReentrantLock类显式加锁和释放锁。

常用的方法

方法声明	功能介绍
ReentrantLock()	使用无参方式构造对象
void lock()	获取锁
void unlock()	释放锁

使用Lock与synchronized方式的比较

Lock是显式锁，需要手动实现开启和关闭操作，而synchronized是隐式锁，执行锁定代码后自动释放。
Lock只有同步代码块方式的锁，而synchronized有同步代码块方式和同步方法两种锁
使用Lock锁方式时，Java虚拟机将花费较少的时间来调度线程，因此性能更好。

Object类常用的方法

方法声明	功能介绍
void wait()	用于使得线程进入等待状态，直到其它线程调用notify()或notifyAll()方法
void wait(long timeout)	用于进入等待状态，直到其它线程调用方法或参数指定的毫秒数已经过去为止
void notify()	用于唤醒等待的单个线程
void notifyAll()	用于唤醒等待的所有线程

Java_线程池

Java线程池表示一组正在等待作业并重复使用多次的工作线程
在线程池的情况下,创建一组固定大小的线程,来自线程池中的线程被拉去并由服务提供者分配作业,完成作业后,线程将会被再次包含在线程池中
线程池的优点:线程池提供了更好的新能,因为不需要重新创建新线程,所以节省了时间
在Servlet和JSP中使用线程池,容器创建一个线程来处理请求

线程池的由来

在服务器编程模型的原理，每一个客户端连接用一个单独的线程为之服务，当与客户端的会话结束时，线程也就结束了，即每来一个客户端连接，服务器端就要创建一个新线程。
如果访问服务器的客户端很多，那么服务器要不断地创建和销毁线程，这将严重影响服务器的性能。

概念和原理

线程池的概念：首先创建一些线程，它们的集合称为线程池，当服务器接受到一个客户请求后，就从线程池中取出一个空闲的线程为之服务，服务完后不关闭该线程，而是将该线程还回到线程池中。
在线程池的编程模式下，任务是提交给整个线程池，而不是直接交给某个线程，线程池在拿到任务后，它就在内部找有无空闲的线程，再把任务交给内部某个空闲的线程，任务是提交给整个线程池，一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

相关类和方法

从Java5开始提供了线程池的相关类和接口：java.util.concurrent.Executors类和java.util.concurrent.ExecutorService接口。

其中Executors是个工具类和线程池的工厂类，可以创建并返回不同类型的线程池，常用方法如下：

方法声明	功能介绍
static ExecutorService newCachedThreadPool()	创建一个可根据需要创建新线程的线程池
static ExecutorService newFixedThreadPool(int nThreads)	创建一个可重用固定线程数的线程池
static ExecutorService newSingleThreadExecutor()	创建一个只有一个线程的线程池

ExecutorService接口是真正的线程池接口主要实现类是ThreadPoolExecutor，常用方法如下

方法声明	功能介绍
void execute(Runnable command)	执行任务和命令，通常用于执行Runnable
Future submit(Callable task)	执行任务和命令，通常用于执行Callable
void shutdown()	启动有序关闭

package com.company;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
// 线程池实例
class WorkerThread implements Runnable {
    private String message;

    public WorkerThread(String s) {
        this.message = s;
    }

    public void run() {
        System.out.println(Thread.currentThread().getName() + " 开始信息 = " + message);
        processmessage();// call processmessage method that sleeps the thread for 2 seconds
        System.out.println(Thread.currentThread().getName() + " 结束");// prints thread name
    }

    private void processmessage() {
        try {
            Thread.sleep(2000); // 休眠 2 秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}



public class Java_30 {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);//creating a pool of 5 threads
        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);//calling execute method of ExecutorService
        }
        executor.shutdown();
        while (!executor.isTerminated()) {   }

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


}

Java_常用线程池接口和类(所在包java.util.concurrent):

Executor:线程池顶级接口
ExecutorService：线程池接口，可通过submit（Runnable task）提交任务。
Executors工具类：通过此类可以获得一个线程池。
通过newFixedThreadPool（int nThreads）：获取固定数量的线程池。参数：指定线程池中线程的数量。
newCashedThreadPool（）：获得动态数量的线程池，如不够则重新创建新的，没有上限。

package com.company;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
// 线程池实例二 :详细使用线程池
public class Java_31 {
    public static void main(String[] args){
        //创建固定个数的线程池
        // ExecutorService es=Executors.newFixedThreadPool(5);
        //创建动态线程池
        ExecutorService es= Executors.newCachedThreadPool();
        //创建单线程线程池
        //Executors.newSingleThreadExecutor();
        //创建调度线程池
        //Executors.newScheduledThreadPool();
        // 创建任务
        Runnable runnable=new Runnable() {
            private int ticket=100;
            @Override
            public void run() {
                while (true){
                    if (ticket<=0){
                        break;
                    }
                    System.out.println(Thread.currentThread().getName()+"卖了第"+ticket+"张票");
                    ticket--;
                }
            }
        };
        //提交任务
        for (int i =0;i<5;i++){//5=上面的线程池个数
            es.submit(runnable);
        }
        //关闭线程池
        es.shutdown();
    }
}

Java_线程的创建方式三：通过Callable和Future创建线程

创建 Callable 接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
创建Callable实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
调用FutureTask对象的 get() 方法来获得子线程执行结束后的返回值。

Callable接口:

Callable接口与Runnable接口类似，实现之后代表一个接口任务。
Callable具有泛型返回值,可以声明异常

常用的方法如下：

方法声明	功能介绍
V call()	计算结果并返回

FutureTask类

java.util.concurrent.FutureTask类用于描述可取消的异步计算，该类提供了Future接口的基本实现，包括启动和取消计算、查询计算是否完成以及检索计算结果的方法，也可以用于获取方法调用后的返回结果。
常用的方法如下：

方法声明	功能介绍
FutureTask(Callable callable)	根据参数指定的引用来创建一个未来任务
V get()	获取call方法计算的结果

package com.company;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
// Callable 接口样例

/**
 * 演示Callable接口的使用
 * Callable与Runnable接口的区别：
 *     1、Callable中call方法具有泛型返回值、Runnable接口中run方法没有返回值
 *     2、Callable中call方法可以声明异常，Runnable接口中run方法没有异常
 */
public class Java_33 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //功能需求，使用Callable实现1-10的和
        //1、创建Callable对象
        Callable<Integer> callable=new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName()+"开始计算");
                int sum=0;
                for (int i=0;i<=10;i++){
                    sum+=i;
                }
                return sum;
            }
        };
        //把Callable对象转成任务
        FutureTask<Integer> task=new FutureTask<>(callable);
        //创建线程
        Thread thread=new Thread(task);
        thread.start();
        //获取结果
        Integer sum = task.get();
        System.out.println("计算结果是："+sum);
    }
}

Future接口:表示将要完成任务的结果
线程池+Callable接口+Future+接口的综合使用

package com.company;

import java.util.concurrent.*;

// 线程池+Callable+Future+接口的综合使用
/**
 * 要求：计算1-100的和
 *    使用两个线程，并发计算1-50、51-100的和，再进行汇总统计。
 */
public class Java_34 {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            //创建线程池
            ExecutorService es = Executors.newFixedThreadPool(2);
            //提交任务
            Future<Integer> future=es.submit(new Callable<Integer>() {
                private int sum=0;
                @Override
                public Integer call() throws Exception {
                    System.out.println(Thread.currentThread().getName()+"开始计算");
                    for (int i=0;i<=50;i++){
                        sum+=i;
                    }
                    return sum;
                }
            });
            Future<Integer> future2=es.submit(new Callable<Integer>() {
                private int sum=0;
                @Override
                public Integer call() throws Exception {
                    System.out.println(Thread.currentThread().getName()+"开始计算");
                    for (int i=51;i<=100;i++){
                        sum+=i;
                    }
                    return sum;
                }
            });
            //汇总
            int sum=future.get()+future2.get();
            System.out.println("计算结果是："+sum);
        }
    }

Java_线程的优先级

每个线程都有一个优先级,优先级是从1-10之间的数字表示,
大多数情况下,线程调用程序根据线程的优先级(称为抢占式调用)来调用线程,但是这种情况下,不能选择调用方式

在Thread类中定义的三个常量:

public static int MIN_PRIORITY
public static int NORM_PRIORITY
public static int MAX_PRIORITY
线程的默认优先级为5(NORM_PRIORITY)。 MIN_PRIORITY的值为1，MAX_PRIORITY的值为10。

package com.company;
// 线程的优先级
public class Java_29 {
    public static void main(String args[]) {
            TestMultiPriority1 m1 = new TestMultiPriority1();
            TestMultiPriority1 m2 = new TestMultiPriority1();
            m1.setPriority(Thread.MIN_PRIORITY);
            m2.setPriority(Thread.MAX_PRIORITY);
            m1.start();
            m2.start();

        }
    }
class TestMultiPriority1 extends Thread {
    public void run() {
        System.out.println("正在运行的线程名:" + Thread.currentThread().getName());
        System.out.println("正在运行的线程的优先级:" + Thread.currentThread().getPriority());

    }
}

Java_transient 修饰符

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
ransient 修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

public transient int limit = 55;   // 不会持久化
public int b; // 持久化

Java_volatile 修饰符

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。
当volatile 修饰的成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。一个 volatile 对象引用可能是 null。

public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run() {
        active = true;
        while (active) { // 第一行
            // 代码
        }
    }
    public void stop() {
        active = false; // 第二行
    }
}

通常情况下，在一个线程调用 run() 方法（在 Runnable 开启的线程），在另一个线程调用 stop() 方法
如果第一行中缓冲区的 active 值被使用，那么在 第二行 的 active 值为 false 时循环不会停止。但是以上代码中使用了 volatile 修饰 active，所以该循环会停止。

想做CTO的任同学...

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Java_多线程

Thread类的概念Java语言的JVM允许程序运行多个线程，它通过类来体现。java.lang.Thread类代表线程，任何线程对象都是Thread类（子类）的实例。通过该Thread对象的start()方法来启动这个线程，而非直接调用run()，每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体Thread类是线程的模板，封装了复杂的线程开启等操作，封装了操作系统的差异性。线程的创建方式一：自定义类继承Thread类。
复制链接

扫一扫