线程和线程池

最新推荐文章于 2024-03-16 14:11:46 发布

绵绵绵绵绵绵

最新推荐文章于 2024-03-16 14:11:46 发布

阅读量410

点赞数

文章标签： java 多线程

本文链接：https://blog.csdn.net/qq_41901372/article/details/108735509

版权

进程和线程

一、进程和线程

进程

在大多数操作系统中都可以创建多个进程（Process）。进程是一个程序运行的基本单位。当一个程序启动时，即会为程序执行的任务创建一个进程，并允许它们同时运行。当一个进程因IO或网络请求而被阻塞时，其它进程还可以继续运行，这样就增加了资源利用率。但是，按照这种方式创建每个进程要付出一定的代价：设置一个进程要占用相当一部分处理器时间和内存资源。而且，大多数操作系统不允许进程访问其他进程的内存空间。因此，进程间的通信很不方便，并且也不会将它自己提供给容易的编程模型。

线程

线程（Thread）也称为轻型进程（LWP）。因为线程只能在单个进程的作用域内活动，所以创建线程很简单。且线程允许协作和数据交换，在计算资源方面非常廉价。线程需要操作系统的支持，而JVM天然支持线程。
在Java中，JVM作为外部操作系统的一个进程而存在，而线程则作为JVM内部的一个个任务。

二、时间片与调度

并发与并行

并发：多个线程共用一个（份）CPU（核心或资源）（其实就是共用进程所占据的CPU资源），在不同时间片内轮流执行。
并行：不同的线程使用不同的CPU执行。
JVM作为应用程序，无法干涉操作系统的资源调度方式，因此不能确定JVM内部的线程究竟是并发的还是并行的。但无论是并发还是并行，都不会影响Java多线程代码的运行速度。

时间片与线程调度

时间片是线程占据CPU资源的一段时间。有以下两种主要的线程调度策略：
时间片轮转：所有线程轮流占据CPU资源，平均分配占据CPU的时间。
抢占式调度：根据线程优先级，优先级高的线程更有可能抢先占据CPU资源。优先级相同，则是随机的。这也是JVM的线程调度方式。

三、线程

创建和启动

（一）主线程

JVM会在一开始，在类加载到方法区后，便会创建和调用主线程（main）执行程序。而主线程默认执行main()方法，故Java程序都是从main方法开始执行的。在主线程的进行过程中，程序可以创建线程对象，执行自定义线程指定的代码。当没有创建其它线程时，程序从始至终都只有一个线程——main线程。
线程在Java中也是一个对象，创建了线程对象便创建了一个线程。线程只有启动后，JVM才会为其分配相应的资源（CPU、内存和磁盘等）。当然，新的线程在启动后，启动新线程的线程也不会等待新线程执行完毕，或终止自身的执行，而是两个线程并发或并行执行。
线程会在启动后拥有自己的虚拟机栈、本地方法栈和程序计数器；所有的线程共用同一个方法区和堆。启动后的main线程会执行main方法，其它线程会执行run方法。

（二）使用Thread类创建线程

可以定义一个类继承Thread类，并重写父类的run()方法，run方法中的代码便是线程要执行的代码（run方法需要抛异常或使用try-catch块包裹）。然后创建一个这个类的对象（便创建了一个线程），调用start()方法便启动了这个线程（而调用run方法只会调用当前线程执行）。

class MyThread extends Thread { // 定义一个类继承Thread
    @Override
    public void run() { /*要执行的代码和方法*/ }
}
class Test {
    main() {
        Thread t = new MyThread(); // 这里用了多态
        t.start(); // 调用了Thread 0线程执行run方法
        t.run(); // 如果这样写，则是调用了main线程执行run方法
    }
}

也可以使用匿名内部类和lambda表达式继承。当然，这样的方法太过麻烦，并且强行让一个类去继承Thread类，使得这个类失去了继承其它类的机会。故Java提供了Runnable接口。

（三）使用Runnable接口创建线程

使用Thread的构造方法传入一个Runnable接口的实现类对象，以生成一个Thread对象，并调用start()方法便启动了这个线程。

class MyThread implements Runnable {
    @Override
    public void run() { /*要执行的代码和方法*/ }
}
class Test {
    main() {
        Thread t = new Thread(new MyThread());
        t.start(); // 调用了Thread 0线程执行run方法
    }
}

Runnable接口可以把相同的任务交给不同的线程去执行，让线程和执行代码相对独立。同样地，也可以使用匿名内部类和lambda表达式实现。

class Test {
    main() {
        new Thread(new Runnable() { // 使用匿名内部类
            @Override
            public void run() { /*要执行的代码和方法*/ }
        }, "LambdaThread").start(); // 将线程命名为LambdaThread并启动
    }
}

名字

要获取线程的名字，可以使用Thread.currentThread().getName()方法。其中Thread.currentThread()能够获取当前进程对象。从main线程创建的线程的默认名字为Thread-num（num为线程序号，从0开始）。
如上例所述，可以使用Thread构造方法的第二个参数对线程进行命名。也可以使用线程对象的setName()方法在线程启动之前为线程命名。

分类

线程分为两类：前台线程（执行线程或用户线程）和后台线程（守护线程或精灵线程）。默认创建的新线程是前台线程。可以在线程启动前使用setDaemon(true)方法将线程设为后台线程。
前台线程地位较高，而后台线程为前台线程提供良好的运行环境和类加载环境等。
无论后台线程有没有执行完，当所有前台线程执行完毕后，JVM就会停止运行。

优先级

线程的优先级使得高优先级的线程更有可能抢先占据CPU资源，优先运行，但并不是一定能够抢到。线程的优先级默认为5，最低为1，最高为10。
可以通过getPriority()方法获取线程优先级，通过setPriority()方法设置线程优先级。

线程组

可以将线程组成一组，以便了解组内线程的各种情况，对组内线程进行操作，如查看运行数量、终结数量等。当然，线程组（java.lang.ThreadGroup）也是一个对象。JVM默认将main线程以及main线程创建的线程放入main线程组中。当然，子线程默认放入父线程的线程组中。可以通过Thread构造方法设置一个线程的线程组。

ThreadGroup tp = Thread.currentThread().getThreadGroup(); // 获取当前线程的线程组对象
tp.getName(); // 获取当前线程组的名字
tp.maxPriority(); // 获取线程组中线程最大优先级
ThreadGroup group = new ThreadGroup("group1"); // 新建名为group1的线程组
Thread t = new Thread(group, new Runnable() {
            @Override
            public void run() { /*要执行的代码和方法*/ }
        }, "Thread1"); // 新建线程Thread1加入线程组group1
int a = t.activeCount(); // 获取线程组当前的活跃线程数
Thread[] ts = new Thread[a];
t.enumerate(ts); // 将当前的活跃线程放入ts中

四、线程的状态

这是线程中较为重要的章节，主要描述了线程的各种状态和状态的转换。

状态的种类

在java.util.Thread中，线程主要有6种不同的状态：新建（New）、可运行（Runnable）、锁阻塞（Blocked）、无限期等待（Waiting）、有限期等待（Timed-waiting）和终止（Terminated）。其中的可运行的状态还可分为就绪（Runnable）和运行中（Running）两种；Timed-waiting、Waiting和Blocked是三种不同的等待/阻塞状态，此时线程不执行代码，也不参与CPU时间片的争夺。

状态		说明
新建 New		线程刚被创建，还没调用start方法；或者刚刚调用了start方法，但线程还未完全启动
可运行 Runnable	就绪 Runnable	线程尝试抢占CPU资源，但未抢占到
	运行 Running	线程抢占到了CPU资源正在运行
等待/ 阻塞	有限期等待 Timed-waiting	等待一段时间，待时间期限结束后恢复可运行状态
	无限期等待 Waiting	等待一段未知的时间，待其它线程将其唤醒进入可运行状态
	锁阻塞 Blocked	有线程正在执行并上了锁，需要等待解锁后才能进入就绪状态
终止 Terminated		线程的run方法运行结束，线程终止

线程的状态的对象（State）可以通过getState()方法获取。

状态的转换

（一）最简单的线程生命周期

最简单的一个线程的历程就是：线程在创建后通过start()方法被执行，通过多次抢到CPU执行权，“断断续续”把run方法执行完成，最终终止运行。

（二）暂停一下

当线程之间出现数据交换、因IO等原因需要暂停、执行某些原子操作时，一些线程就会被阻塞。
线程之间的转换主要是Runnable和三种阻塞状态之间的转换。线程之间的转换主要依赖各种方法的手动执行和JVM自动执行。以下是等待和运行状态之间转换的方法：

Thread.sleep(time)：该静态方法可以让当前执行的线程暂时休眠指定的time毫秒。线程会从Runnable状态进入Timed-waiting状态。
thread.join()：让当前线程从Runnable状态进入Waiting状态，等待thread线程执行结束后再恢复。
- thread.join(time)：让当前线程从Runnable状态进入Timed-waiting状态，让thread线程执行至多time毫秒后恢复。
thread.interrupt()：打断thread线程的Timed-waiting状态或Waiting状态，让其恢复为Runnable的就绪状态。

当某个正处于等待状态线程被打断后，会抛出InterruptedException异常。如果这部分代码被try-catch块包裹，则会跳到catch块，不会执行try块的后续代码，这点需要注意。

当线程处于等待状态时，会时刻监控着打断标识。打断标识默认为false；当标识置true时，系统会抛出异常并打断等待状态，然后将标识置回false。
当调用了某个线程对象的interrupt方法后，interrupt方法会调用interrupt0()的本地方法将打断标识置true。可以调用线程对象的isInterrupted()方法获取该线程的打断标识；可以调用Thread.interrupted()静态方法获取当前线程的打断标识，并将其置false。isInterrupted方法和Thread.interrupted方法都调用了isInterrupted(boolean)的本地方法，当参数为true时，会将打断标识置false；否则不改变打断标识的值。

如果在其它线程（如main线程）调用一个线程对象的interrupted()方法将该线程打断，随后再使用该线程对象的isInterrupted()方法查看打断标识，因为两个线程获得时间片的先后顺序不一，即：
有可能是①被main线程调用的interrupted()打断 -> ②打断标识置true、抛异常 -> ③main线程抢到时间片、执行isInterrupted()方法返回true -> ④打断标识置false
也可能是①被main线程调用的interrupted()打断 -> ②打断标识置true、抛异常 -> ③打断标识置false -> ④main线程抢到时间片、执行isInterrupted()方法返回false
所以返回的有可能是true，也有可能是false。

线程安全

在多线程环境中，如果有多个线程并发访问堆区中同一个对象中的数据（即对象的属性和方法），或访问方法区的同一项数据（即类的静态成员和静态方法），并进行了修改操作，那么这个数据可能会出现和预期结果不符的情况，即这个线程是不安全的。
为了避免这种情况，可以为操作添加锁，当执行这段操作的代码时，该线程的时间片即使被其它线程抢占，其它线程会因处于锁阻塞状态而让回时间片，相当于时间片不被抢占，使得该操作具有原子性。使用synchronized修饰符可以为代码块或方法添加锁，实现线程同步。具有synchronized的代码块被称为同步代码块。
锁也是一种对象，任何对象都可以充当锁。

public class Test {
    public static void main(String[] args) {
        Object o = new Object();
        List<Integer> list = new ArrayList<>();
        Thread t1 = new Thread("t1") {
            public void run() {
                synchronized (o) { // 这里的锁对象是o
                    for i in range(10) { // 借用Python的伪代码😂
                        list.add(i);
                        System.out.println(Thread.currentThread().getName() + ": " + i);
                    }
                }
            }
        };
        Thread t2 = new Thread("t2") {
            public void run() {
                synchronized (o) { // t2的锁对象和t1相同，都是o
                    for i in range(100, 110) { // 再次借用Python的伪代码
                        list.add(i);
                        System.out.println(Thread.currentThread().getName() + ": " + i);
                    }
                }
            }
        };
        t1.start();
        t2.start();
    }
}

当多个代码块或方法使用了同一个锁对象时，当这些代码的其中一个代码执行时，正在执行的代码会拿到锁对象；其它代码在抢占到CPU时间片后因没有锁对象而进入锁阻塞状态，将时间片让回。反之，若使用的锁对象不一样，则操作不具有原子性。
当为线程加锁时，线程的信息会被写入锁对象中。其它线程即使拿到锁，由于具有其它线程的信息，因此处于Blocked状态。当加锁的线程执行完毕后，会将锁对象的中的线程信息擦除。
为一个方法添加synchronized关键字，相当于方法体被synchronized修饰的代码块所包裹。若方法为非静态方法，则锁对象为this；否则为当前类的类对象。

锁会在代码块或方法执行完毕后释放。锁也可以通过锁对象的wait()方法释放：

synchronized (o) {
    for i in range(10) {
        list.add(i);
        if(i == 5) {
        	o.wait(); // 当i循环到5时，释放锁对象，当前线程进入线程等待池
        }
        System.out.println(Thread.currentThread().getName() + ": " + i);
    }
}

当持有锁的线程的锁对象被释放后，线程会进入线程等待池，同时进入Waiting状态。也可以使用有参的wait(long time)方法进入Time-waiting状态，时间结束或被提前唤醒则进入Blocked状态。可以通过锁对象的notify()方法从线程等待池中随机唤醒一个线程，使其有可能持有锁；也可以使用notifyAll()方法唤醒线程等待池中的全部线程。
这三个方法是Object定义的非静态方法。只有一个对象作为锁对象时，且在被synchronized修饰的代码块中才可以调用这三个方法。
join方法也可以实现线程安全，但具有局限性，只能让进程按特定的顺序被执行，且具有被打断的风险。

总结

在这里插入图片描述

线程池

传统线程中，一个线程只能运行一次run方法，且运行结束后就被回收了，不能重复利用。如果想运行多个任务，则多少个任务就需要多少个线程，十分不便。此外，线程在运行中随着调度来回切换，易导致资源崩溃。因此，JDK提供了线程池。

线程池（Thread Pool）是池化技术的一种。线程池能够重用线程，降低系统资源消耗，方便管控线程并发数，实现线程的延时和定时功能。

池化技术：不直接创建具体的资源，而是创建一个资源对应的池，在池中创建具体的资源。池会让空闲的资源执行任务。当任务执行完毕后，资源不会被销毁，而是停留在池中，等待下一次任务。池能够重用资源，降低系统资源消耗，方便管理。除了线程池以外，常见的池化技术还包括数据库连接池等。

线程池的本质就是一些空闲的线程和一个任务队列（即一系列实现了Runnable接口、重写了run方法的类对象）。线程池中的空闲的线程会主动执行队列中的任务。任务执行完毕后，核心线程不会被销毁，而是等待下一个任务的执行。只要不断往队列中添加任务，有限的线程就能够执行无穷的任务。

一个线程池

通过创建一个线程池对象从而获得一个线程池。线程池类ThreadPoolExecutor实现了ExecutorService接口。

/*
* 线程池执行器ThreadPoolExecutor的构造器每个参数的含义依次是：
* corePoolSize 核心线程数量
* maximumPoolSize 最大线程的数量
* keepAliveTime 线程池中除核心线程外的其他线程最长保留时间
* util 时间的单位
* workQueue 任务等待队列
*/
ExecutorService excutor = new ThreadPoolExecutor(3, 6, 2, 
                              TimeUnit.SECONDS, 
                              new SynchronousQueue<Runnable>()); // 获得一个3核心，至多6线程的线程池
excutor.execute(new Runnable() {
    public void run() { /******任务******/ }
}); // 为线程池添加一个任务
for (int i = 0; i < 20; i++) {
    excutor.execute(new Runnable() {
        public void run() { /******任务******/ }
    });
} // 为线程池添加20个任务
excutor.shutdown(); // 待所有线程空闲后，关闭线程池

可以向线程池提交任务，将任务添加到队列中。一旦存在空闲的线程，就会执行队列中的任务。非核心线程空闲后，待保留时间结束后即回收。核心线程不会被回收。收到shutdown()命令后，线程池会等待所有线程空闲后，才关闭线程池。

任务队列

不同的任务队列拥有不同的特性。

BlockingQueue：（继承了Queue的接口）双缓冲队列，内部使用两条队列，允许两个线程同时向队列一个存储，一个取出操作。在保证并发安全的同时，提高了队列的存取效率。
- ArrayBlockingQueue：采用数组实现，具有固定长度的队列。使用构造器时须指定长度。对象采用FIFO排序。
- LinkedBlockingQueue：采用双向链表实现，可指定大小，默认为Integer.MAX_VALUE。对象采用FIFO排序。
- PriorityBlockingQueue：对象依据自然排序或比较器排序的LinkedBlockingQueue。
- SynchronousQueue：是最快的任务队列。队列中只有一个元素，每次删除操作都要等待插入操作，每次插入操作都要等待删除操作。一旦有了插入线程和移除线程，那么很快由插入线程移交给移除线程。这个队列相当于一个通道，本身并不存储元素。

JDK提供的线程池

在实际项目中，一般在使用线程时均会使用线程池，而使用线程池则一般使用JDK提供的线程池。
Java通过java.util.current.Executors类提供四种线程池（静态方法，返回一个线程池对象）：

newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程；若所有线程均处于运行状态，则新建线程。该线程池创建的都是非核心线程，最大线程数为Integer.MAX_VALUE ，空闲线程存活时间为1分钟，采用最快的SynchronousQueue作为任务队列。可缓存线程池通常用于执行一些生存期很短的异步型任务。
newFixedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。所有线程都是核心线程，采用LinkedBlockingQueue作为任务队列。线程的数量最好根据CPU能够并行执行的线程数（可通过Runtime.getRuntime().availableProcessors()获取）进行配置。
newSingleThreadExecutor：创建一个单线程的线程池，它只会用唯一的核心线程来执行任务，保证所有任务按照指定任务队列的顺序执行。采用LinkedBlockingQueue作为任务队列。
newScheduledThreadPool：创建一个定长线程池，并支持线程进行定时和周期性任务执行。采用DelayedWorkQueue作为任务队列，并拥有自己单独的类ScheduledExecutorService（ExecutorService的子类）。

Runnable r = new Runnable() {
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}; // 定义一个任务
ExecutorService cachedExe = Executors.newCachedThreadPool(); // 缓存线程池
ExecutorService fixedExe = Executors.newFixedThreadPool(5); // 定长线程池，长度为5
ExecutorService singleExe = Executors.newSingleThreadExecutor(); // 单线程池
for (int i = 0; i < 10; i++) {
    cachedExe.execute(r);
}
for (int i = 0; i < 10; i++) {
    fixedExe.execute(r);
}
for (int i = 0; i < 10; i++) {
    singleExe.execute(r);
}
ScheduledExecutorService sexe = Executors.newScheduledThreadPool(4); // 定时线程池，长度为4
sexe.schedule(r, 3, TimeUnit.SECONDS); // 3秒后执行r任务
sexe.scheduleAtFixedRate(r, 3, 2, TimeUnit.SECONDS); // 3秒后执行r任务，随后每2秒执行一次

前三个循环可能的运行结果如下：

cachedExe	fixedExe	singleExe
pool-1-thread-1 pool-1-thread-2 pool-1-thread-3 pool-1-thread-4 pool-1-thread-5 pool-1-thread-6 pool-1-thread-4 pool-1-thread-5 pool-1-thread-7 pool-1-thread-6	pool-2-thread-1 pool-2-thread-2 pool-2-thread-3 pool-2-thread-3 pool-2-thread-4 pool-2-thread-2 pool-2-thread-1 pool-2-thread-2 pool-2-thread-4 pool-2-thread-5	pool-3-thread-1 pool-3-thread-1 pool-3-thread-1 pool-3-thread-1 pool-3-thread-1 pool-3-thread-1 pool-3-thread-1 pool-3-thread-1 pool-3-thread-1 pool-3-thread-1

可以看到，当池中的线程均忙时，cachedExe会随着任务的执行而不断创建新线程；fixedExe则最多使用5个线程；而singleExe则只有1个线程。

绵绵绵绵绵绵

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
线程和线程池

进程和线程一、进程和线程进程在大多数操作系统中都可以创建多个进程（Process）。进程是一个程序运行的基本单位。当一个程序启动时，即会为程序执行的任务创建一个进程，并允许它们同时运行。当一个进程因IO或网络请求而被阻塞时，其它进程还可以继续运行，这样就增加了资源利用率。但是，按照这种方式创建每个进程要付出一定的代价：设置一个进程要占用相当一部分处理器时间和内存资源。而且，大多数操作系统不允许进程访问其他进程的内存空间。因此，进程间的通信很不方便，并且也不会将它自己提供给容易的编程模型。线程
复制链接

扫一扫