并发编程——线程的基础知识（线程状态、创建线程、线程间的通信及源码分析）

已于 2022-09-23 09:39:19 修改
阅读量365 收藏
点赞数 1
分类专栏： 并发编程 文章标签： java
于 2022-09-06 20:56:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aguai229/article/details/126710004
版权

目录

线程简介

线程的概念

线程的状态

创建线程方式

线程的优先级

线程的启动和终止

线程初始化

启动线程

被废弃的suspend()、resume()、stop()

终止线程

线程间的通信

等待/通知机制

等待/通知经典范式

使用管道流通信 

Thread.join()的源码及使用

ThreadLocal的使用 

线程简介

线程的概念

说起线程，不可避免的我们要提一句进程。那么什么是进程呢？操作系统在运行一个程序的时候，就会为其创建一个进程。例如，我们启动一个java程序，那就会产生一个java进程。

进程：是系统进行分配和管理资源的基本单位。

 有了进程，线程就出现了。在一个进程里可以创建多个线程，这些线程拥有各自的堆栈和局部变量的属性，并且可以访问共享的内存变量。

线程：进程的一个执行单元，是进程内调度的实体，是cpu调度和分派的基本单位，是比进程更小的独立运行的基本单位。

 一个程序至少有一个进程，一个进程至少有一个线程。

一个java程序从main方法开始执行，然后按照既定的代码逻辑执行，看似没有其他线程的参与，但实际上java程序天生就是多线程程序，因为执行main方法的是一个名称为main的线程。我们可以使用JMX来查看一个java程序包含哪些线程。

public static void main(String[] args) {
        //获取java线程管理MXBean
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();

        //不需要获取同步的monitor和synchronizer信息，仅获取线程和线程堆栈信息
        ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false,false);

        //遍历线程信息，仅打印线程id和线程名称信息
        for (ThreadInfo threadInfo: threadInfos) {
            System.out.println("["+threadInfo.getThreadId()+"]"+ threadInfo.getThreadName());
        }
    }

输出如下图所示内容（输出的内容可能不同） 

 由此可以看出，一个java程序的运行不仅仅是main方法的运行，而是main线程和多个其他线程的同时运行。

线程的状态

状态名称说明
初始(NEW)新创建了一个线程对象，但还没有调用start()方法
运行(RUNNABLE)处于可运行状态的线程正在JVM中执行，但它可能正在等待来自操作系统的其他资源，例如处理器。
阻塞(BLOCKED)线程阻塞于synchronized锁，等待获取synchronized锁的状态。
等待(WAITING)Object.wait()、join()、 LockSupport.park(),进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
超时等待(TIME_WAITING)

Object.wait(long)、Thread.join()、LockSupport.parkNanos()、LockSupport.parkUntil，该状态不同于WAITING，它可以在指定的时间内自行返回。

终止(TERMINATED)表示该线程已经执行完毕。

下面就用我们上一篇提到的jstack工具来查看代码运行时的线程信息，更加深入理解线程状态。

package com.demo.controller;

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.concurrent.TimeUnit;

public class Demo {

    public static void main(String[] args) {
        new Thread(new TimeWaiting(),"超时等待线程").start();
        new Thread(new Waiting(),"等待线程").start();
        new Thread(new Blocked(),"阻塞线程1").start();
        new Thread(new Blocked(),"阻塞线程2").start();
    }

    /**
     * 该线程不断进行睡眠
     */
    static class TimeWaiting implements Runnable {
        @Override
        public void run() {
            while (true){
                try {
                    TimeUnit.SECONDS.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 该线程在waiting.class实例上等待
     */
    static class Waiting implements Runnable {

        @Override
        public void run() {
            while (true){
                synchronized (Waiting.class){
                    try {
                        Waiting.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    /**
     * 该线程在Blocked.class实例上加锁后，不会释放该锁
     */
    static class Blocked implements Runnable {

        @Override
        public void run() {
            synchronized (Blocked.class){
                while (true){
                    try {
                        TimeUnit.SECONDS.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

 运行该程序，打开终端输入jps，输出如下

可以看到运行代码对应的进程id为11976，于是我们输入jatack 11976，输出如下

 可以看到超时等待线程的状态为TIMED_WAITING

等待线程在java.lang.Class@6275b223实例上的WAITING

阻塞线程1的状态TIMED_WAITING

阻塞线程2是在java.lang.Class@437fc1b0实例上的BLOCKED, 拥有者: 阻塞线程1

 由图可知，线程创建之后，调用start()方法开始运行。当线程执行wait()方法之后，线程进入等待状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而超时等待状态相当于在等待状态的基础上增加了超时限制，也就是超时时间到达时会返回到运行状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到阻塞状态。线程在执行Runnable的run方法之后将会进入到终止状态。

创建线程方式

  • 继承Thread，并重写父类的run方法
  • 实现Runable接口，并实现run方法
  • 使用匿名内部类
  • Lambda表达式
  • 线程池

下面针对以上几种方式用代码实现

1.继承Thread，输出为“线程demo”

public class ThreadDemo extends Thread {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();
        threadDemo.setName("线程demo");
        threadDemo.start();
    }
}

2. 实现Runable接口，输出为“线程demo”

public class ThreadDemo1 implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new ThreadDemo1());
        thread.setName("线程demo");
        thread.start();
    }
}

3. 使用匿名内部类，输出为“Thread-0”

/**
 * 匿名内部类的方式
 */
public class MyThread {

    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        thread.start();
    }
}

4. Lambda表达式，输出为“Thread-0”

public class LambadaThread {

    public static void main(String[] args) {
        new Thread(()->{
            System.out.println(Thread.currentThread().getName());
        }).start();
    }
    
}

5.线程池，输出为“pool-1-thread-1”

public class ThreadPool {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(()->{
            System.out.println(Thread.currentThread().getName());
        });
    }
}

线程的优先级

线程的优先级告诉程序该线程的重要程度有多大。如果有大量线程都被堵塞，都在等候运行，程序会尽可能地先运行优先级的那个线程。 但是，这并不表示优先级较低的线程不会运行。若线程的优先级较低，只不过表示它被准许运行的机会小一些而已。

线程分配到的时间片多少也决定了线程使用处理器资源的多少，而线程优先级就是决定线程需要多或者少分配一些处理器资源的线程属性。

线程的优先级设置可以为1-10的任一数值，在线程构建的时候可以通过setPriority(int)方法来修改优先级，Thread类中定义了三个线程优先级，分别是：MIN_PRIORITY（1）、NORM_PRIORITY（5）、MAX_PRIORITY（10），默认优先级是5。

package com.demo.controller;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;


public class Priority {
    private static volatile boolean notStart = true;
    private static volatile boolean notEnd = true;

    public static void main(String[] args) throws InterruptedException {
        List<Job> jobs = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            int priority = i < 5 ? Thread.MIN_PRIORITY : Thread.MAX_PRIORITY;
            Job job = new Job(priority);
            jobs.add(job);
            Thread thread = new Thread(job,"Thread:"+i);
            thread.setPriority(priority);
            thread.start();
        }

        notStart = false;
        TimeUnit.SECONDS.sleep(10);
        notEnd = false;

        for (Job job:jobs) {
            System.out.println("Job priority:"+job.priority+", Count:"+job.jobCount);
        }
    }


    static class Job implements Runnable {

        private int priority;
        private long jobCount;

        public Job(int priority){
            this.priority = priority;
        }

        @Override
        public void run() {
            while (notStart){
                Thread.yield();
            }

            while (notEnd){
                Thread.yield();
                jobCount++;
            }
        }
    }

}

运行该程序，可以得到输出如下：

 

 由此可以看出，线程优先级没有生效，优先级1和优先级10的job计数的结果很接近，没有明显差距。这表示程序正确性不能依赖线程的优先级高低。

线程的启动和终止

线程初始化

在运行线程之前首先要构造一个线程对象，并提供构造所需要的属性，以下代码为Thread中的init方法源码

    /**
     * Allocates a new {@code Thread} object. This constructor has the same
     * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
     * {@code (null, null, gname)}, where {@code gname} is a newly generated
     * name. Automatically generated names are of the form
     * {@code "Thread-"+}<i>n</i>, where <i>n</i> is an integer.
     */
    public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }

    /**
     * Initializes a Thread.
     *
     * @param g the Thread group
     * @param target the object whose run() method gets called
     * @param name the name of the new Thread
     * @param stackSize the desired stack size for the new thread, or
     *        zero to indicate that this parameter is to be ignored.
     * @param acc the AccessControlContext to inherit, or
     *            AccessController.getContext() if null
     * @param inheritThreadLocals if {@code true}, inherit initial values for
     *            inheritable thread-locals from the constructing 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();

        /*
         * Do we have the required permissions?
         */
        if (security != null) {
            if (isCCLOverridden(getClass())) {
                security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
            }
        }

        g.addUnstarted();

        //将daemon、priority属性设置为父线程对应属性
        this.group = g;
        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);
        //将父线程的inheritableThreadLocals复制过来
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;

        /* Set thread ID */
        tid = nextThreadID();
    }

 在上述代码中，我们可以知道一个新构造的线程对象是由其父线程来进行空间分配的，子线程会继承父线程的属性和加载资源的contextClassLoader以及可继承的ThreadLocal，同时还会分配一个唯一的id来标识这个子线程。至此，一个线程对象就创建完成了，并在对内存中等待运行。

启动线程

线程对象完成初始化后，调用start()方法就可以启动这个线程。通过调用Thread类的start()方法来启动一个线程，通过源码注释也可以清晰的知道。“Causes this thread to begin execution; the Java Virtual Machine calls the <code>run</code> method of this thread.”

被废弃的suspend()、resume()、stop()

线程的暂停、恢复、停止操作对应在线程Thread的API就是suspend()、resume()和stop()。

被废弃的方法​ thread.suspend() 该方法不会释放线程所占用的资源。如果使用该方法将某个线程挂起，则可能会使其他等待资源的线程死锁​。

thread.resume() 方法本身并无问题，但是不能独立于suspend()方法存在​。可以使用的方法​ wait() 暂停执行、放弃已经获得的锁、进入等待状态​。

stop() 废弃方法，开发中建议不要使用。因为一调用，线程就立刻停止，此时有可能引发相应的线程安全性问题。

用一个代码来更加清晰的理解这三个方法。

package thread;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class Test {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new RunnableThread(),"打印线程");
        thread.setDaemon(true);
        thread.start();
        TimeUnit.SECONDS.sleep(3);

        thread.suspend();
        System.out.println("main方法暂停线程，输出停止");
        TimeUnit.SECONDS.sleep(3);

        thread.resume();
        System.out.println("main方法恢复线程，输出继续");
        TimeUnit.SECONDS.sleep(3);

        thread.stop();
        System.out.println("main方法终止线程，输出停止");
    }

    static class RunnableThread implements Runnable {

        @Override
        public void run() {
            DateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
            while (true){
                System.out.println(Thread.currentThread().getName() + ", 执行时间：" + dateFormat.format(new Date()));
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

 在执行的过程中，thread运行了3秒，随后被暂停，3秒后恢复，经过3秒后被终止。虽然suspend()、resume()和stop()方法实现了线程的暂停、恢复和终止工作，但是这些API是被废弃的方法，因此也不建议使用，这里只做了解就好，暂停和恢复操作可以使用等待/通知机制来代替。

不建议使用的原因：以suspend()方法为例，在调用后，线程不会释放已经占有的资源，而是占有资源进入睡眠状态，容易引发死锁问题。同样，stop()方法在终止一个线程时不会保证线程的资源正常释放，因此会导致程序问题可能工作在不确定状态下。正是由于这些方法带来的问题，因此才不建议使用。

终止线程

中断可以理解为线程的一个标识位属性，它表示一个运行中的线程是否被其他线程进行了中断操作，其他线程通过调用该线程的interrupt()方法对其进行中断操作。

线程通过检查自身是否被中断来进行响应，通过isInterrupted()来判断。因此，我们采用中断操作来终止线程执行。

package thread;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class Test1 {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new RunnableThread(),"计数线程");
        thread.start();

        //睡眠3秒，main线程对thread进行中断，使thread能够感知中断而结束
        TimeUnit.SECONDS.sleep(3);
        thread.interrupt();
        System.out.println("main方法暂停线程，输出停止");


        RunnableThread runnableThread = new RunnableThread();
        Thread thread2 = new Thread(runnableThread,"计数线程2");
        thread2.start();
        //睡眠3秒，main线程对runnableThread进行取消，是runnableThread感知到flag为false而结束
        TimeUnit.SECONDS.sleep(3);
        runnableThread.cancel();
        System.out.println("main方法取消线程，输出停止");
    }

    static class RunnableThread implements Runnable {
        private long i;
        private volatile boolean flag = true;
        @Override
        public void run() {

            DateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
            while (flag && !Thread.currentThread().isInterrupted()){
                i ++;
            }
            System.out.println("i=" + i + ", 执行时间：" + dateFormat.format(new Date()));
        }

        public void cancel(){
            flag = false;
        }
    }

}

输出结果如下所示

 

由代码可知，main方法使用中断操作Thread.interrupt()方法和cancel()均可以使thread终止，这种通过标识位或者中断操作的方式能够使线程在终止的时候释放资源，更加安全。

线程间的通信

等待/通知机制

方法名称说明
notify()通知一个在对象上等待的线程，使其从wati()方法返回。即随机唤醒一个等待的线程。
notifyAll()唤醒所有在该对象上等待的线程。
wait()调用该方法的现场进行WAITING状态，只有等待其他线程的通知或被中断才会返回，wait()会释放锁资源
wait(long)超时等待一段时间，单位毫秒，即等待n毫秒，如果没有通知就超时返回

 等待/通知机制，就是指一个线程A调用了对象o的wait()方法进入等待状态，另一个线程B调用了对象o的notify()或者notifyAll()方法，线程A收到通知后从对象o的wait()方法返回，进行后续操作。

package thread;

public class Demo1 {
    
    private static volatile boolean flag = false;

    public static void main(String[] args) throws InterruptedException {

        Object obj = new Object();

        new Thread(()->{
            while (!flag){
                synchronized (obj){
                    try {
                        System.out.println("false");
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
            System.out.println("true");
        }).start();

        new Thread(()->{
            while (!flag){
                synchronized (obj){
                    try {
                        System.out.println("false");
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
            System.out.println("true");
        }).start();

        Thread.sleep(1000L);

        new Thread(()->{
            flag = true;
            synchronized (obj){
                obj.notifyAll();
            }

        }).start();

    }


}

输出为一下内容：

这段代码主要是介绍了notifyAll()方法，两个线程在对象o上进入等待状态，notifyAll唤醒了所有的等待线程。

⚠️注意：

  1. 使用wait()、notify()、notifyAll()时需要先对调用对象加锁
  2. 调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。
  3. notify()、notifyAll()方法调用后，等待县城依旧不会从wait()返回，需要调用notify()或notifyAll()的线程释放锁之后，等待线程才有机会从wait()返回。
  4. notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。
  5. 从wait()方法返回的前提是获得了调用对象的锁。

 等待/通知经典范式

等待方（消费者）和通知方（生产者）

等待方遵循以下原则：

  1. 获取对象锁。
  2. 如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件。
  3. 条件满足则执行对应逻辑。

对应的伪代码：

synchronized (obj){
    while(条件){
       obj.wait();
    }
    处理逻辑
}

通知方遵循原则：

  1. 获取对象锁
  2. 改变条件
  3. 通知所有等待在对象上的线程 

对应的伪代码：

synchronized (obj){
    改变条件
    obj.notifyAll();
}

结合等待/通知机制部分的实例代码，也可以看出代码遵循了以上原则。

使用管道流通信 

管道输入/输出流和普通的输入/输出流的区别在于，它是以内存为媒介，用于线程之间的数据传输。主要有面向字节：【PipedOutputStream、PipedInputStream】、面向字符【PipedReader、PipedWriter】

package thread;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

public class Piped {

    public static void main(String[] args) throws InterruptedException, IOException {
        PipedInputStream pipedInputStream = new PipedInputStream();
        PipedOutputStream pipedOutputStream = new PipedOutputStream();

        //将输出流和输入流进行连接，否则在使用的时候会抛出IOException
        pipedOutputStream.connect(pipedInputStream);

        new Thread(new Reader(pipedInputStream)).start();

        BufferedReader bufferedReader = null;
        try{
            bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            pipedOutputStream.write(bufferedReader.readLine().getBytes());
        }finally {
            pipedOutputStream.close();
            if (bufferedReader != null){
                bufferedReader.close();
            }
        }
    }

    static class Reader implements Runnable {
        private PipedInputStream pipedInputStream;
        public Reader(PipedInputStream pipedInputStream){
            this.pipedInputStream = pipedInputStream;
        }

        @Override
        public void run() {
            if (pipedInputStream != null){
                String collect = new BufferedReader(new InputStreamReader(pipedInputStream)).lines().collect(Collectors.joining("\n"));
                System.out.println(Thread.currentThread().getName() + ", 输出：" + collect);
            }
            try {
                pipedInputStream.close();
            } catch (Exception e){
            }
        }
    }

}

运行该代码，输入字符串，可以看到被thread进行了原样输出。输出内容如下：

Thread.join()的源码及使用

使用场景：线程A执行到一半，需要一个数据，这个数据需要线程B去执行修改，只有B修改完成之后，A才能继续操作线程A的run方法里面，调用线程B的join方法，这个时候，线程A会等待线程B运行完成之后，再接着运行。

package thread;

public class JoinDemo {

    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(()->{
            System.out.println(Thread.currentThread().getName() +"开始运行");
            try {
                Thread.sleep(3000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() +"结束运行");
        },"线程1");


        new Thread(()->{
            System.out.println(Thread.currentThread().getName() +"开始运行");
            thread.start();
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() +"结束运行");
        },"线程2").start();


    }


}

输出结果如下：

从上述输出可以看到，线程2终止的前提是前驱线程也就是线程1的终止，线程2等待线程1终止后，才从join()方法返回，这里涉及了等待/通知机制（等待前驱线程结束，接收前驱线程结束通知）。

源码分析：

//加锁当前线程对象
public final synchronized void join(long millis)
    throws InterruptedException {
        //获取当前系统时间
        long base = System.currentTimeMillis();
        //定义now
        long now = 0;

        //进行判断，等待时间肯定不能小于0，否则抛出异常
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        //等于0表示无限制
        if (millis == 0) {
            //条件不满足，继续等待
            while (isAlive()) {
                wait(0);
            }
        } else {
            //循环判断，条件符合，方法返回
            while (isAlive()) {
                //计算时间差
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

ThreadLocal的使用 

ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构。为每个线程单独存放一份变量副本，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。

只要线程处于活动状态并且ThreadLocal实例可访问，那么每个线程都拥有对其本地线程副本的隐式引用变量。一个线程消失后，它的所有副本线程局部实例受垃圾回收（除非其他存在对这些副本的引用）

可以通过set(T)方法来设置一个值，在当前线程下再通过get()方法获取到原先设置的值。

package thread;

public class ThreadLocalDemo {

    ThreadLocal<Integer> num = ThreadLocal.withInitial(()-> 0);

    /**
     * 自增并输出num值
     */
    public void create(){
        Integer myNum = num.get();
        myNum++;
        System.out.println(Thread.currentThread().getName() +",myNum:"+myNum);
        num.set(myNum);
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadLocalDemo threadLocalDemo = new ThreadLocalDemo();
        for (int i = 1; i < 3; i++) {
            new Thread(()->{
                while(true){
                    threadLocalDemo.create();
                    try {
                        Thread.sleep(3000L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }


}

 输出如下内容：

 由上述输出可知，ThreadLocal为每一个线程都单独存放一份变量副本。

好啦，本篇的内容分享就到这里了，觉得不错的同学记得收藏点赞支持一下哦~~拜拜

一口八宝周
关注
专栏目录
Java多线程创建、线程同步、线程通信相关笔记
FrankHu2021的博客
10-20 197
Java多线程创建、线程同步、线程通信相关笔记
多线程——线程实现、线程状态、线程同步、线程通信、线程池
weixin_44090845的博客
11-22 3529
多线程一、线程1.普通方法调用和多线程2.程序、进行、线程二、线程创建1.继承Thread类2.实现Runable接口3.实现Callable接口4.静态代理模式5、Lamda表达式三、线程状态1.线程状态2.线程方法3.线程停止4.线程休眠sleep5.线程礼让5.join6.线程状态观测7.线程优先级8.守护(daemon)线程四、线程同步1.并发与并行2.线程同步——等待机制2.1 队列 和 锁2.2 线程同步2.3 同步方法2.4 同步块3.死锁4. Lock锁 一、线程 1.普通方法调用和多线程
线程有几个状态
NewBeeMu的博客
01-28 190
由源码可知：6个 public enum State { //新生 /** * Thread state for a thread which has not yet started. */ NEW, //运行 /** * Thread state for a runnable thread. A thread in the runnable * st
java多线程之线程创建、线程状态、线程同步、线程通讯
绝不认输的程序媛的博客
07-23 167
真实对象和代理对象都要实现同一个接口代理对象要代理真实角色任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口}对于函数式接口，可以通过lambda表达式创建该接口的对象lambda表达式只能有一行代码的情况下才能简化为一行，若有多行，必须用代码块包裹。前提接口必须是函数式接口多个参数也可以去掉参数类型，要去掉都去掉，必须加括号。...
线程的6种状态,通过源码查看
A_BCDS的博客
08-06 277
线程6种状态 NEW New 新建 线程刚被创建，但未启动。还没有调用 start()方法 RUNNABLE Runnable 可运行 线程可以在java的虚拟机中运行的状态，可能正在运行，也可能是在等待CPU资源，简单来说就是调用了start()方法zh BLOCKED Blocked 阻塞 当线程调用sleep()或者join()方法就会进入Blocked状态，但是要注意的是阻塞的线程是不释放当前所占有的系统资源，当sleep()结束或者join()等待其他线程来到，当前线程则进入Run.
Java理论一：线程的基础概念----启动和终止，线程的五大状态，线程同步，线程交互
mumu_nuli的博客
04-24 221
Java线程的基础概念----启动和终止，线程的五大状态，线程同步，线程交互 参考链接：https://blog.csdn.net/kwame211/article/details/78963044 1 线程介绍 1、什么是线程？ 线程是进程的一个执行流程，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。一个进程中可以有多个线程。 一个线程---->独占一套：一个虚拟机栈、PC寄存器、操作数栈，本地方法栈 进程和线程的区别： 多线程的意义在于一个进程中，有多个执行部分可以同时执.
并发编程——Java线程的6种状态及切换（csdn）————程序.pdf
12-05
并发编程——Java线程的6种状态及切换（csdn）————程序
并发编程——认识java里的线程（csdn）————程序.pdf
12-05
并发编程——认识 Java 里面的线程 在 Java 编程中，并发编程是一个非常重要的概念。Java 程序天生就是多线程的，main 方法开始执行后，按照既定的代码逻辑执行，看似没有其他线程参与，但实际上 Java 程序天生就是...
iOS高级程序员进阶——多线程编程核心技术模式篇
06-18
作为开发者，我们除了能够熟练使用常用的多线程编程技术外，对于复杂场景的多线程及决方案也要有所了解，例如互相依赖的任务的线程分配，多队列组的应用、死锁场景的分析和优化等。 本课程将详细介绍pthread、...
并发编程——并发工具类.pdf
06-06
并发工具类是Java并发编程中非常重要的部分，它们提供了线程间协作的基础组件。合理使用这些工具类，可以有效地管理并发执行的任务，确保线程间的有序交互，避免死锁和资源竞争等并发问题。通过本资料的学习，读者...
线程源代码-线程6种状态
czl315的博客
11-21 319
package com.czl.thread.state; import java.util.concurrent.locks.LockSupport; /** czl createTime:2019/11/21 线程源代码-线程6种状态:参考《java.lang.Thread》 NEW新增；RUNNABLE可运行；BLOCKED阻塞；WAITING等待；TIMED_WAITING设定时间的等待...
Java线程的六种状态 -- 源码解读
豆小匠的博客
06-08 128
Thread源码 很多地方说是五种，不过Java源码里面Thread的状态是有六种的。 public enum State { // 新生 NEW, // 可运行 RUNNABLE, // 阻塞 BLOCKED, // 等待 WAITING, // 超时等待 TIMED_WAITING, // 终止 TERMINATED; } 经典图解 图中可以看到甚至可以分为7种状态，不过中
从JVM源代码的角度一步一步给你讲清楚线程状态的本质以及线程状态的由来
最新发布
唐欢
03-06 391
从源码可知，根据操作java字段把java状态的偏移量拿出来，java状态的偏移量就是thread中的成员threadstatus（线程状态）的相对于它对象的头部偏移量，然后把状态state放进去，简单说就是C++中操作java的成员变量，把threadstatus的地址拿出来，把线程的state值放进去，把线程状态修改为sleeping。接来敲黑板，考试重点来了， 线程状态是如何修改的，以javaThread::sleep(jlong millis)为例进行解释，这个过程是在C++中进行的。
Java中线程优先级、线程的状态以及启动和终止线程
...
06-18 297
线程概念：现代操作系统调度的最小单元是线程，也叫轻量级进程（Light Weight Process），在一个进程中可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换。 线程优先级 现代操作系统基本采用时分的形式调度运行的线程。线程分配到的时间片多少也就决定了使用处理器资源多少，而线程优先级就是决定线程需要多或少分配一些处理器资源的线程属性。 在Java线程中，通过一个整型成员变量priority来控制优先级，优先级范围从1~10，在线
java线程的6种状态.源码有铁证
chudaxiakkk的专栏
08-20 197
最近面试多次被问到线程状态了。以前有些印象，但是一直没有深究。回答的不如人意。所以来一次源码探究。 最讨厌就是网络的文章，一个个说的有头有脸，线程状态也是命名各种差异。 线程的状态，明显是一个枚举类型，所以jdk源码上就有了。 java.lang.Thread.State,是Thread类定义的内部类 /** A thread state. A thread can be in one of the following states: NEW A thread that has not yet starte
彻底理解Java线程的创建 深入源码 生动分析
weixin_43954951的博客
08-18 403
深入浅出地分析了 Java 中线程创建的过程，深入源码，对与创建线程有关的类进行逐个分析，理清它们之间的联系与区别，最终得出结论，即“Java 中的线程创建方式有且只有一种，那就是 new 一个 Thread 对象，并给它一个 Runnable 类型的对象， Thread 对象负责启动线程， Runnable 对象负责执行线程”。......
Java 线程 配合源码解析
一枚爪洼同鞋
07-06 101
配合源码详解java多线程及线程池使用。
线程1(Thread)
ZJRUIII的博客
03-06 4696
文章目录一、线程的介绍二、线程的概念三、线程的资源分配四、操作系统管理线程的方式五、画图理解进程和线程之间的关系六、利用代码观察线程七、多线程并发执行和单线程的对比 一、线程的介绍 所谓线程，可以理解成一种轻量级的进程，因为他所需的资源比进程要少。创建一个线程比创建一个进程成本低。销毁一个线程也比销毁一个进程成本低。线程也是一种并发编程的方式。 成本低的原因是：新创建一个线程，不需要给这个线程分配很多新的资源，大部分资源都是和原来的线程共享的。如果新创建一个进程，就需要给这个进程分配较多的资源。 线程比进程
Java并发编程：线程基础与实战
Java并发编程中的线程基础是开发高效并发应用的关键。多线程编程允许程序同时执行多个独立的...理解并掌握这些Java并发编程的基础知识，能够帮助开发者构建安全、高效的多线程应用，避免常见的并发问题，提升程序性能。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值