java多线程总结

最新推荐文章于 2024-03-10 23:38:03 发布

莫离瑜

最新推荐文章于 2024-03-10 23:38:03 发布

阅读量158

点赞数

分类专栏： java基础文章标签： java多线程

本文链接：https://blog.csdn.net/ding_ran/article/details/85161791

版权

java基础专栏收录该内容

3 篇文章

订阅专栏

多线程是java中核心知识点之一，面试也会经常被问到，笔者在此简单总结一下多线程的知识点，如有纰漏，还请海涵。

一、线程概念

说起线程的概念，一般都会结合进程来说：

进程：进程是运行中的应用程序被称为进程，拥有CPU资源。可以单独运行。

线程：线程是进程中的一段代码，本身没有CPU资源，不能单独运行。

线程包含在进程之中，一个进程之中可以有多个线程。

二、线程状态

关于Java中线程的生命周期，首先看一下下面这张较为经典的图：

这张图完美展现了线程的各个状态以及运行，线程一共有五个状态：

1.新建：当线程被创建时即进入新建状态（Thread t = new MyThread()）;

2.就绪：线程运行状态的唯一入口，当调用线程的start()时，线程进入就绪状态，此时还没有获得CPU资源，也没有被CPU调用(t.start();)；

3.运行：当CPU调用就绪状态的线程时，给该线程分配CPU资源，此时线程才真正进入运行状态,开始执行run方法中的代码；

4.阻塞：线程运行状态中可以主动或被动的进入线程阻塞状态，根据阻塞情况的不同，可以分为3种阻塞状态

①等待阻塞：当调用线程的wait()时，线程进入等待阻塞状态，会进入等待池中等待被notify()或者notifyall()。此时的线程若有同步锁会释放同步锁。可以调用其中的同步方法，其他线程可以访问。

②同步阻塞：当线程占用synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。

③其他阻塞：当调用线程的sleep()或者join()时,线程也会进入阻塞状态。等sleep时间过了之后重新进入就绪状态等待系统CPU的调用，CPU调用线程是随机的，也就是说当一个线程sleep()时间结束了之后，系统可能调用的是其他的线程，也可能还是这个线程。

5.死亡：当线程执行结束或者异常退出时，线程进入死亡状态。

三、线程的创建和启动

线程创建方式常用的有两种，不常用的有一种。常用的是继承Thread类或者实现Runable接口；不常用的是实现callable的future接口

1.继承Thread类，重写该类的run()方法。

如上所示，继承Thread类，通过重写run()方法定义了一个新的线程类MyThread，其中run()方法的方法体代表了线程需要完成的任务，称之为线程执行体。当创建此线程类对象时一个新的线程得以创建，并进入到线程新建状态。通过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不一定会马上得以执行，这取决于CPU调度时机。

2.实现Runable接口，并重写里面的run()方法。创建Runable接口实现类的实例，并将该实例作为Thread的target对象。

3.使用Callable和Future接口创建线程。具体是创建Callable接口的实现类，并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程。

public class ThreadTest {

public static void main(String[] args) {

Callable<Integer> myCallable = new MyCallable(); // 创建MyCallable对象
FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程
                thread.start();                      //线程进入到就绪状态
            }
        }

        System.out.println("主线程for循环执行完毕..");

        try {
            int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果
            System.out.println("sum = " + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

}
}

class MyCallable implements Callable<Integer> {
private int i = 0;

    // 与run()方法不同的是，call()方法具有返回值
    @Override
    public Integer call() {
        int sum = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return sum;
    }

}

需要注意的是call()方法是有返回值的。同时，看源码的话可以发现futureTask接口实际上也继承了Runable接口的。

上述主要讲解了三种常见的线程创建方式，对于线程的启动而言，都是调用线程对象的start()方法，需要特别注意的是：不能对同一线程对象两次调用start()方法。

四、线程各状态之间的转换（线程执行流程）

一个线程最初始的状态为新建状态，即Thread t1= new MyThread();Thread t2 = new HisThread(); 此时代表这个线程已经创建，已经存在；

当调用t1.start()/t2.start()方法时，线程进入就绪状态，等待被CPU调用；

当CPU随机调用一个线程，并给该线程分配系统资源时，线程进入运行状态，开始执行run()方法中的代码，这个过程中一旦遇到异常，或者run()方法执行完毕，线程直接进入死亡状态；

线程运行期间如果遇到t1.sleep()/t1.join()/t1.wait()时，线程进入阻塞状态。需要注意的是，sleep()方法是将当前线程进入阻塞状态，比如说在主进程中有一行代码是t1.sleep(),但现在CPU调用的是t2线程，那么当t2线程执行到t1.sleep()时，t2线程会进入阻塞状态。

线程运行期间如果遇到t1.yield(),那么t1线程就会放弃CPU资源，进入就绪状态，等待被CPU重新调用分配资源。