重学Java并发编程(Thread类)

最新推荐文章于 2022-06-03 23:21:54 发布

三天饿九顿的萌新

最新推荐文章于 2022-06-03 23:21:54 发布

阅读量444

点赞数 1

分类专栏： Java多线程文章标签： JAVA 多线程并发编程高并发编程

本文链接：https://blog.csdn.net/qq_42168438/article/details/121418930

版权

Java多线程专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

重学Java并发编程(Thread类)

重学Java并发编程(Thread类)

如何使用Thread类创建一个线程

Java中创建线程是使用Thread类来实现的，并且使用start方法来启动一个线程，我们先来看一下start方法的实现

    /**
     * 启动线程,Java虚拟机将会新启动一个线程，并调用此线程的run方法
     * 如果线程已经被启动过，将抛出IllegalThreadStateException一次
     */
    public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
            
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }

	private native void start0();

当我们执行start方法的时候，Java虚拟机会创建一个线程，并且执行Thread类的run方法，那让我们一起来看一下run方法的实现。

	/* What will be run. */
    private Runnable target;
	
	...
	...

    /**
     * 如果此线程是使用Runnable对象构造的,则调用该Runnable对象的run方法;否则,此方法不执行任何操作并返回。
     * 如果使用了线程的子类,应该重写此方法
     */
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

我们可以看到run方法首先判断了target对象是否为空,如果不为空就会执行target的run方法，而target对象是一个Runnable的接口

@FunctionalInterface
public interface Runnable {
    void run();
}

根据start和run方法的源码可以做出几点总结:

Thread被构造后处于NEW状态，threadStatus这个内部属性值为0
不能两次启动Thraed线程，否则就会抛出IllegalThreadStateException异常
线程启动后将会被加入到一个ThreadGroup中
一个线程生命周期结束，也就是到TERMINATED状态，再次调用start方法是不允许的
如果要让一个线程帮助我们执行我们的任务，需要重写run方法，将我们的任务放到run方法中，也可以将我们的任务放到Runnable类的run方法中，将Runnable传给Thread类，Thread类默认的run方法就会执行我们的target类的run方法
启动线程的时候一定要执行start方法，这样JVM才会帮我们创建一个线程，执行run方法，如果直接执行run方法相当于在当前线程执行，并不会创建新的线程。

下面我们看一下四种创建线程的例子:

其实创建多线程的方式本质上只有一种，就是创建一个Thread对象，执行start方法，然后JVM就会创建一个线程帮助我们异步的执行run方法。

方式一:

使用匿名内部类的方式重写run方法，将我们的任务放到run方法中。

public class LearnThreadStart1 {

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

        new Thread("test_thread") {
            @Override
            public void run() {
                helloWorld();
            }
        }.start();

        TimeUnit.SECONDS.sleep(1);

        helloWorld();
    }

    static void helloWorld() {
        System.out.println(Thread.currentThread().getName() + ": " + "hello world!");
    }
}

jdk1.5以后，引入了一个枚举TimuUnit，采用了模板方法设计模式，对sleep、join、wait进行了很好的封装，不得不说，很秀。

方式二:

创建一个类，继承Thread类，重写run方法。
Thread的start和run方法就是一个比较经典的模板方法设计模式，父类编写算法结构代码，子类实现逻辑细节。

public class LearnThreadStart2 {

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

        new MyTask("test_thread").start();

        TimeUnit.SECONDS.sleep(1);

        helloWorld();
    }

    static void helloWorld() {
        System.out.println(Thread.currentThread().getName() + ": " + "hello world!");
    }

    static class MyTask extends Thread {

        public MyTask(String threadName) {
            super(threadName);
        }

        @Override
        public void run() {
            helloWorld();
        }
    }
}

方式三:

创建一个Runnable的对象，将Runnable对象传给Thread。
Runnable定义了一系列算法，并将每个算法封装起来，使它们可以互相替换，这一点与GoF中的策略模式很类似。

public class LearnThreadStart3 {

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

        new Thread(new MyTask(), "test_thread_1").start();

        // Runnable是一个函数式接口,所以也可以采用Java 8 Lambda的方式
        Runnable task = LearnThreadStart3::helloWorld;
        new Thread(task, "test_thread_2").start();

        TimeUnit.SECONDS.sleep(1);

        helloWorld();
    }

    static void helloWorld() {
        System.out.println(Thread.currentThread().getName() + ": " + "hello world!");
    }

    static class MyTask implements Runnable {
        @Override
        public void run() {
            helloWorld();
        }
    }
}

方式四:

使用Callable + FutureTask的方式执行:
不懂FutureTask的同学这里先看看怎么用就行，后面再一起分析FutureTask的源码

public class LearnThreadStart4 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> task = () -> {
            int num = ThreadLocalRandom.current().nextInt(3, 10);
            TimeUnit.SECONDS.sleep(num);
            return num;
        };

        // 采用FutureTask的方式获取返回值
        FutureTask<Integer> futureTask = new FutureTask<>(task);
        new Thread(futureTask, "test_thread").start();
        
        System.out.println("任务已经提交等待获取返回结果...");
        long startTime = System.currentTimeMillis();
        Integer result = futureTask.get();

        System.out.printf("futureTask的返回值为: %s 耗时为:%s ms\n", result, (System.currentTimeMillis() - startTime));
    }
}

线程的生命周期

我们一起看一下Thread中有哪些线程状态

    /**
     * 线程在给定时间点只能处于一种状态。这些状态是虚拟机状态，不反映任何操作系统线程状态。
     */
    public enum State {
        /**
         * 尚未启动的线程的线程状态。
         */
        NEW,

        /**
         * 可运行线程的线程状态。处于可运行状态的线程正在Java虚拟机中执行，但它可能正在等待来自操作系统的其他资源，如处理器。
         */
        RUNNABLE,

        /**
         * 阻塞状态，等待获取monitor lock锁(synchronized)的线程状态
         * 处于阻塞状态的线程正在等待synchronized方法或代码块或者调用{@link Object#wait}后重新进入同步代码块或者方法
         */
        BLOCKED,

        /**
         * 等待线程的线程状态。
         */
        WAITING,

        /**
         * 具有指定等待时间的等待线程的线程状态。
         */
        TIMED_WAITING,

        /**
         * 终止线程的线程状态。线程已完成执行
         */
        TERMINATED;
    }

我们可以看到线程一共有6个状态，分别是NEW、RUNNABLE、BLOCKED、WAITING、TIME_WAITING、TERMINATED，并且代码的注释中也说明了什么情况下线程会处于什么样的状态。
我们通过画图来帮助理解线程的状态转换

线程状态流转

可以看到Thread类刚被new出来时处于NEW状态，如果执行了start方法线程就会进入RUNNABLE方法，但是此时并不一定会真正执行run方法，需要等CPU调度到的时候才会真正的执行，而当我们执行wait、join、park等没有超时时间的等待方法时，会进入WAITING状态，执行带有超时时间的等待方法，就会进入到TIMED_WAITING状态，在等待获取monitor锁(synchronized)的时候会进入BLOCKED状态，获取到锁之后又会进入RUNNABLE状态，当任务执行完毕后会进入TERMINATED状态。

我们挑几个例子来验证下

public class ThreadStateTest {

    private static final long WAIT_TIME = 1000 * 60 * 10;

    private static final List<Thread> THREAD_LIST = new ArrayList<>();

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

        // 尚未执行start的线程(NEW)
        // 当我们new了一个Thread对象后,它只是个对象而已,还没有调用start0()方法实际的创建一个线程,所以NEW状态只是Thread对象的状态而已,跟实际线程没什么关系
        Thread testNewThread = new Thread("testNewThread");

        // 已经获取synchronized同步状态的线程(RUNNABLE)
        Thread testSynchronized = new Thread(ThreadStateTest::testSynchronized, "testSynchronized");
        THREAD_LIST.add(testSynchronized);

        // 处于等待获取同步状态的线程,只有处于等待获取锁的线程才会处于BLOCKED状态,已经获取到锁的线程将会进入RUNNABLE状态 (BLOCKED)
        Thread testWaitSynchronized = new Thread(ThreadStateTest::testSynchronized, "testWaitSynchronized");
        THREAD_LIST.add(testWaitSynchronized);

        // 处于等待状态的线程 (WAITING)
        Thread testWait = new Thread(ThreadStateTest::testWait, "testWait");
        THREAD_LIST.add(testWait);

        // 处于超时等待中的线程(TIMED_WAITING)
        Thread testTimedWaiting = new Thread(() -> testWait(WAIT_TIME), "testTimedWaiting");
        THREAD_LIST.add(testTimedWaiting);

        // 执行结束的线程(TERMINATED)
        Thread testTerminated = new Thread("testTerminated");
        THREAD_LIST.add(testTerminated);

        THREAD_LIST.forEach(Thread::start);
        TimeUnit.SECONDS.sleep(2);
        THREAD_LIST.forEach(ThreadStateTest::printThreadState);
        printThreadState(testNewThread);
    }

    static void printThreadState(Thread thread) {
        System.out.printf("ThreadName: %s ThreadState: %s\n", thread.getName(), thread.getState());
    }

    static synchronized void testSynchronized() {
        while (true) {}
    }

    static void testWait() {
        testWait(0);
    }

    static void testWait(long timeout) {
        Object obj = new Object();
        synchronized(obj) {
            try {
                obj.wait(timeout);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

需要注意的是不要在单核心的CPU上面运行上面代码，testSynchronized方法会将一颗CPU核心跑到100%。

代码输出结果为

ThreadName: testSynchronized ThreadState: RUNNABLE
ThreadName: testWaitSynchronized ThreadState: BLOCKED
ThreadName: testWait ThreadState: WAITING
ThreadName: testTimedWaiting ThreadState: TIMED_WAITING
ThreadName: testTerminated ThreadState: TERMINATED
ThreadName: testNewThread ThreadState: NEW

我们还可以使用jstack命令将线程的堆栈信息打印出来，由于篇幅有限我们只看第一行就行

首先使用jps命令查找进程id

使用jstack命令将线程的堆栈信息打印出来

使用jstack命令打印堆栈信息

线程的命名

在构造线程的时候可以为线程起一个有特殊意义的名字，这也是比较好的一种做法，尤其在一个线程比较多的程序中，为线程赋予一个包含特殊意义的名字有助于问题的排查和线程的跟踪。

线程的默认命名
在下面的几个构造函数中，并没有提供为线程命名的参数，那么此时线程会有一个怎样的命名呢?

Thread()
Thread(Runnable target)
Thread(ThreadGroup group, Runnable target)

    public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }
    
    /* For autonumbering anonymous threads. */
    private static int threadInitNumber;
    private static synchronized int nextThreadNum() {
        return threadInitNumber++;
    }

如果没有为线程显式的指定一个名字，那么线程将会以"Thread-" 作为前缀与一个自增数字组合，这个自增数字在整个JVM生命周期中会不断自增。

命名线程
Thread提供了为线程命名的构造函数

Thread(Runnable target, String name)
Thread(ThreadGroup group, String name)
Thread(Runnable target, String name)
Thread(ThreadGroup group, Runnable target, String name)
Thread(ThreadGroup group, Runnable target, String name, long stackSize)

修改线程名字
当然了，我们还可以修改线程的名字

    public final synchronized void setName(String name) {
        checkAccess();
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name;
        if (threadStatus != 0) {
            setNativeName(name);
        }
    }

我们可以看到,如果线程状态不是0，也就是不是NEW状态，还要执行一个native方法来修改线程名字

public class ThreadSetNameTest {
    public static void main(String[] args) {
        
        // 测试线程未启动前修改线程名字
        Thread test_thread_1 = new Thread(LockSupport::park, "test_thread_1");
        test_thread_1.setName("test_thread_1_new");
        test_thread_1.start();

        // 测试启动后修改线程名字
        Thread test_thread_2 = new Thread(LockSupport::park, "test_thread_2");
        test_thread_2.start();
        // 确保线程状态不为NEW,才会执行下面setName方法
        while (test_thread_2.getState() == Thread.State.NEW) { }
        test_thread_2.setName("test_thread_2_new");

        // 打印线程名字
        System.out.println(test_thread_1.getName());
        System.out.println(test_thread_2.getName());
    }
}

输出结果为:

test_thread_1_new
test_thread_2_new

通过jstack命令查看线程的名，发现确实也被更改了
查看线程名字

什么是守护线程

守护线程是一类比较特殊的线程，一般用于处理一些后台的工作，比如JDK的垃圾回收线程。
而正常情况下(没有执行System.exit()) ，JVM进程如果没有一个非守护线程，就会退出。
我们可以验证一下

public class DaemonThreadTest {

    public static void main(String[] args) {
        Thread thread = new Thread(LockSupport::park, "testThread");
        // thread.setDaemon(true);
        thread.start();
        System.out.println(thread.isDaemon());
    }
}

程序输出结果为false

false

但是此时JVM进程并没有退出，我们再用jstack命令看一下线程的情况

可以看到main线程已经退出了，但是JVM依然没有结束。
当我们希望关闭某些线程的时候，或者退出JVM进程的时候，一些线程能够自动关闭，此时就可以考虑用守护线程为我们完成这样的工作。

Thread常用API

线程sleep

public static native void sleep(long millis) throws InterruptedException
public static void sleep(long millis, int nanos) throws InterruptedException

sleep是一个静态方法，有两个重载方法，其中一个需要传入毫秒数，另外一个既需要毫秒数也需要纳秒数
sleep方法会使当前线程进入指定毫秒数的休眠，暂停执行，虽然给定了一个休眠时间，但是最终要以系统的定时器和调度器的精度为准，休眠有一个非常重要的特性，那就是不会放弃monitor的所有权(不会释放synchronized锁)。

线程interrupt

线程interrupt，是一个非常重要的API，也是经常使用的方法，与线程中断相关的API有如下几个，

public void interrupt() # 将线程的中断标志位设置为true，不会停止线程
public static boolean interrupted() # 判断当前线程的中断表示为是否为ture，不会清楚中断标志位
public boolean isInterrupted() # 判断当前线程的中断标志位是否为true，并清楚中断标志位，重置为false

下面的方法调用会使得当前线程进入阻塞状态，而调用当前线程的interrupt方法，就可以中断阻塞，并将中断标志位清除(置为false)。

Object的wait方法
Object的wait(long)方法
Object的wait(long, int)方法
Thread的join()方法
Thread的join(long)方法
Thread的sleep(long)方法
Thread的sleep(long, int)方法
InterruptibleChannel的io操作
Selector的wakeup方法

    @Test
    void testSleepInterrupted() throws InterruptedException {
        Thread thread = new Thread(() -> {
            log.info("isInterrupted:{}", Thread.currentThread().isInterrupted());
            try {
                Thread.sleep(1000 * 60 * 10);
            } catch (InterruptedException e) {
                log.warn("thread is interrupted mes:{}", e.getMessage());
            }
            log.info("isInterrupted:{}", Thread.currentThread().isInterrupted());
        });

        thread.start();
        Thread.sleep(1000);
        // 对线程执行中断方法
        thread.interrupt();
        thread.join();
    }

2021-11-20 20:24:00.943 [Thread-1] INFO  c.e.thread.csdn.ThreadInterruptTest [] - isInterrupted:false
2021-11-20 20:24:01.942 [Thread-1] WARN  c.e.thread.csdn.ThreadInterruptTest [] - thread is interrupted mes:sleep interrupted
2021-11-20 20:24:01.945 [Thread-1] INFO  c.e.thread.csdn.ThreadInterruptTest [] - isInterrupted:false

    @Test
    void testWhileInterrupted() throws InterruptedException {
        boolean flag = true;
        Thread thread = new Thread(() -> {
            log.info("thread start isInterrupted:{}", Thread.currentThread().isInterrupted());
            while (flag) { }
            log.info("isInterrupted:{}", Thread.currentThread().isInterrupted());
        });

        thread.start();
        Thread.sleep(1000);
        // 对线程执行中断方法
        thread.interrupt();

        thread.join();
    }

2021-11-20 20:24:43.152 [Thread-1] INFO  c.e.thread.csdn.ThreadInterruptTest [] - thread start isInterrupted:false

    @Test
    void testWhileInterrupted2() throws InterruptedException {
        boolean flag = true;
        Thread thread = new Thread(() -> {
            log.info("thread start isInterrupted:{}", Thread.currentThread().isInterrupted());
            while (!Thread.currentThread().isInterrupted()) { }
            log.info("end isInterrupted:{}", Thread.currentThread().isInterrupted());
        });

        thread.start();
        Thread.sleep(1000);
        // 对线程执行中断方法
        thread.interrupt();

        thread.join();
    }

2021-11-20 20:25:59.896 [Thread-1] INFO  c.e.thread.csdn.ThreadInterruptTest [] - thread start isInterrupted:false
2021-11-20 20:26:00.897 [Thread-1] INFO  c.e.thread.csdn.ThreadInterruptTest [] - end isInterrupted:true

线程join

等待调用join方法的线程结束之后，程序再继续运行，一般用于等待异步线程执行完结果之后才能继续运行的场景。

如果关闭一个线程?

不推荐使用stop方法，这已经是一个废弃的方法了，并且该方法还不安全。
推荐使用isInterrupted的方式关闭。

三天饿九顿的萌新

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
10
评论
重学Java并发编程(Thread类)

文章目录重学Java并发编程(Thread类)如何使用Thread类创建一个线程线程的生命周期线程的命名什么是守护线程Thread常用API线程sleep线程interrupt线程join如果关闭一个线程?重学Java并发编程(Thread类)如何使用Thread类创建一个线程Java中创建线程是使用Thread类来实现的，并且使用start方法来启动一个线程，我们先来看一下start方法的实现 /** * 使该线程开始执行,Java虚拟机将会调用此线程的run方法 * C
复制链接

扫一扫