多线程

最新推荐文章于 2025-03-17 15:16:19 发布

熊小弟弟弟

最新推荐文章于 2025-03-17 15:16:19 发布

阅读量149

点赞数

本文链接：https://blog.youkuaiyun.com/wuzhangxiong123/article/details/108431843

版权

多线程定义
一个程序运行即一个进程，一个进程可以有多个线程，多线程并非多个线程并行在CPU中，而是多个线程分别占据CPU不同的时间段，交替执行，顺序与优先级有关。
什么是进程
电脑中时会有很多单独运行的程序，每个程序有一个独立的进程，而进程之间是相互独立存在的。比如下图中的QQ、酷狗播放器、电脑管家等等
在这里插入图片描述
什么是线程
进程想要执行任务就需要依赖线程。换句话说，就是进程中的最小执行单位就是线程，并且一个进程中至少有一个线程
核心级线程
核心级我程是和系统任务相关的线程，它负责处理不同进程之间的多个线程。允
许不同进程中的线程按照同一相对优先调度方法对线程进行调度，使它们有条不素地工
作，可以发挥多处理器的并发优势，以充分利用计算机的软/硬件资源。
用户级线程
在开发程序时，由于程序的需要而编写的线程即用户级线程，这些线程的创建、执
行和消亡都是在编写应用程序时进行控制的。对于用户级线程的切换，通常发生在一个
应用程序的诸多线程之间，如迅雷中的多线程下载就属于用户线程。
多线程可以改善用户体验。具有多个线程的进程能更好地表达和解决现实世界的具
体问题，多线程是计算机应用开发和程序设计的一项重要的实用技术。
线程和进程既有联系又有区别，具体如下：
一个进程中至少要有一个线程
资源分配给进程，同一进程的所有线程共享该进程的所有资源。
处理机分配给线程，即真正在处理机上运行的是线程。
多线程的优势
多线程有着广泛的应用，下载工具“迅雷”是一款典型的多线程应用程序，在这个
下载工具中，可以同时执行多个下载任务。这样不但能够加快下载的速度，减少等待时
间，而且还能够充分利用网络和系统资源。
多线程的好处如下。
多线程程序可以带来更好的用户体验，避免因程序执行过慢而导致出现计算机死机或者白屏的情况。
多线程程序可以最天限度地提高计算机系统的利用效率。
创建线程有4种方法
Callable和Future Thread Runnable
继承 Thread类
在这里插入图片描述
可以看到程序在交替执行，但是最终都会执行到98。
实现Runnable接口

依旧可以看到程序在交替执行，但是最终都会执行到98。
启动线程：
start()方法，使用之后处于等待CPU分配时间段的就绪状态，分配到之后开始运行为运行状态
获取当前线程方法是
Thread.currentThread().getName()
休眠时间 sleep
修改线程名setName 查看线程名getName
设置优先级 setpriority 查看优先级getpriority
isAlive测试线程是否处于活动状态
线程状态
在这里插入图片描述
更改优先级：setPriority(int类型数字，代表优先级高低，1最低，10最高) 一般默认都是5
NORM_PRIORITY=5

Thread.MAX_PRIORITY【最高优先级】

Thread.MIN_PRIORITY【最低优先级】

休眠方法：【静态】sleep(long类型，表示休眠时间，单位毫秒)

强制暂停：join()【加队，强制暂停其他线程，等调用此方法的线程执行完毕，才能继续执行，有重载带参的方法】

线程礼让：yield()【静态，暂停当前线程，允许其他相同优先级的线程获得运行机会，当前线程转为就绪状态，不转为堵塞状态，只提供一种可能，不保证一定礼让成功】

中断线程：interrupt()

线程检查：isAlive()【测试线程是否处于活动状态】
线程同步
使用是必须创建一个锁对象
同步方法:
通过在方法声明中加入synchronized关键字来声明同步方法:
同步方法的语法格式如下。
访问修饰符synchronized 返回类型方法名
或者
synchronized 访问修饰符返回类型方法名
synchronized 是同步关键字
访问修饰符是指public、private等。
同步代码块:
synchronized( ){
//需要同步访问的代码块
}
Lock接口的实现类：

ReentrantLock ， ReentrantReadWriteLock.ReadLock ， ReentrantReadWriteLock.WriteLock

1.2 Lock的简单使用

 Lock lock=new ReentrantLock()；
  lock.lock();
   try{
    }finally{
    lock.unlock();
    }

1
2
3
4
5
6
因为Lock是接口所以使用时要结合它的实现类，另外在finall语句块中释放锁的目的是保证获取到锁之后，最终能够被释放。

注意：最好不要把获取锁的过程写在try语句块中，因为如果在获取锁时发生了异常，异常抛出的同时也会导致锁无法被释放。
死锁
在这里插入图片描述
线程间通信：

Object类中有关于线程操作的方法，wait()和notify()。

wait()：挂起当前线程，并释放共享资源锁

notify()：随机使一个因调用该对象wait()方法挂起的线程解除阻塞，但需要等到获得锁才能执行。

可以在其子类中直接调用：super.wait()；、super.notify()；
线程安全
在这里插入图片描述

线程池
一. 线程池简介

线程池的概念：

   线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

线程池的工作机制

  2.1 在线程池的编程模式下，任务是提交给整个线程池，而不是直接提交给某个线程，线程池在拿到任务后，就在内部寻找是否有空闲的线程，如果有，则将任务交给某个空闲的线程。

  2.1 一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

使用线程池的原因：

 多线程运行时间，系统不断的启动和关闭新线程，成本非常高，会过渡消耗系统资源，以及过渡切换线程的危险，从而可能导致系统资源的崩溃。这时，线程池就是最好的选择了。

二. 四种常见的线程池详解

线程池的返回值ExecutorService简介：

  ExecutorService是Java提供的用于管理线程池的接口。该接口的两个作用：控制线程数量和重用线程

具体的4种常用的线程池实现如下：（返回值都是ExecutorService）

  2.1 Executors.newCacheThreadPool()：可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务

1 package com.study.test;
 2 
 3 import java.util.concurrent.ExecutorService;
 4 import java.util.concurrent.Executors;
 5 
 6 public class ThreadPoolExecutorTest {
 7     public static void main(String[] args) {
 8         //创建一个可缓存线程池
 9         ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
10         for (int i = 0; i < 10; i++) {
11             try {
12                 //sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程
13                 Thread.sleep(1000);
14             } catch (InterruptedException e) {
15                 e.printStackTrace();
16             }
17             cachedThreadPool.execute(new Runnable() {
18                 public void run() {
19                     //打印正在执行的缓存线程信息
20                     System.out.println(Thread.currentThread().getName()+"正在被执行");
21                 }
22             });
23         }
24     }
25 }

输出结果：

pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行

线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程
2.2 Executors.newFixedThreadPool(int n)：创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。


 1 package com.study.test;
 2 
 3 import java.util.concurrent.ExecutorService;
 4 import java.util.concurrent.Executors;
 5 
 6 public class ThreadPoolExecutorTest {
 7     public static void main(String[] args) {
 8         //创建一个可重用固定个数的线程池
 9         ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
10         for (int i = 0; i < 10; i++) {
11             fixedThreadPool.execute(new Runnable() {
12                 public void run() {
13                     try {
14                         //打印正在执行的缓存线程信息
15                         System.out.println(Thread.currentThread().getName()+"正在被执行");
16                         Thread.sleep(2000);
17                     } catch (InterruptedException e) {
18                         e.printStackTrace();
19                     }
20                 }
21             });
22         }
23     }
24 }

输出结果：

pool-1-thread-1正在被执行
pool-1-thread-2正在被执行
pool-1-thread-3正在被执行
pool-1-thread-1正在被执行
pool-1-thread-2正在被执行
pool-1-thread-3正在被执行
pool-1-thread-1正在被执行
pool-1-thread-2正在被执行
pool-1-thread-3正在被执行
pool-1-thread-1正在被执行

因为线程池大小为3，每个任务输出打印结果后sleep 2秒，所以每两秒打印3个结果。
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()
2.3 Executors.newScheduledThreadPool(int n)：创建一个定长线程池，支持定时及周期性任务执行

1 package com.study.test;
 2 
 3 import java.util.concurrent.Executors;
 4 import java.util.concurrent.ScheduledExecutorService;
 5 import java.util.concurrent.TimeUnit;
 6 
 7 public class ThreadPoolExecutorTest {
 8     public static void main(String[] args) {
 9         //创建一个定长线程池，支持定时及周期性任务执行——延迟执行
10         ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
11         //延迟1秒执行
12         scheduledThreadPool.schedule(new Runnable() {
13             public void run() {
14                 System.out.println("延迟1秒执行");
15             }
16         }, 1, TimeUnit.SECONDS);
17     }
18 }

输出结果：延迟1秒执行

         定期执行示例代码：

1 package com.study.test;
 2 
 3 import java.util.concurrent.Executors;
 4 import java.util.concurrent.ScheduledExecutorService;
 5 import java.util.concurrent.TimeUnit;
 6 
 7 public class ThreadPoolExecutorTest {
 8     public static void main(String[] args) {
 9         //创建一个定长线程池，支持定时及周期性任务执行——定期执行
10         ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
11         //延迟1秒后每3秒执行一次
12         scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
13             public void run() {
14                 System.out.println("延迟1秒后每3秒执行一次");
15             }
16         }, 1, 3, TimeUnit.SECONDS);
17     }
18 }

输出结果：

延迟1秒后每3秒执行一次
延迟1秒后每3秒执行一次
…

2.4 Executors.newSingleThreadExecutor()：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

1 package com.study.test;
 2 
 3 import java.util.concurrent.ExecutorService;
 4 import java.util.concurrent.Executors;
 5 
 6 public class TestThreadPoolExecutor {
 7     public static void main(String[] args) {
 8         //创建一个单线程化的线程池
 9         ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
10         for (int i = 0; i < 10; i++) {
11             final int index = i;
12             singleThreadExecutor.execute(new Runnable() {
13                 public void run() {
14                     try {
15                         //结果依次输出，相当于顺序执行各个任务
16                         System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);
17                         Thread.sleep(1000);
18                     } catch (InterruptedException e) {
19                         e.printStackTrace();
20                     }
21                 }
22             });
23         }
24     }
25 }

输出结果：

pool-1-thread-1正在被执行,打印的值是:0
pool-1-thread-1正在被执行,打印的值是:1
pool-1-thread-1正在被执行,打印的值是:2
pool-1-thread-1正在被执行,打印的值是:3
pool-1-thread-1正在被执行,打印的值是:4
pool-1-thread-1正在被执行,打印的值是:5
pool-1-thread-1正在被执行,打印的值是:6
pool-1-thread-1正在被执行,打印的值是:7
pool-1-thread-1正在被执行,打印的值是:8
pool-1-thread-1正在被执行,打印的值是:9

三. 缓冲队列BlockingQueue和自定义线程池ThreadPoolExecutor
在这里插入图片描述

缓冲队列BlockingQueue简介：

   BlockingQueue是双缓冲队列。BlockingQueue内部使用两条队列，允许两个线程同时向队列一个存储，一个取出操作。在保证并发安全的同时，提高了队列的存取效率。

常用的几种BlockingQueue：

ArrayBlockingQueue（int i）:规定大小的BlockingQueue，其构造必须指定大小。其所含的对象是FIFO顺序排序的。

LinkedBlockingQueue（）或者（int i）:大小不固定的BlockingQueue，若其构造时指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE来决定。其所含的对象是FIFO顺序排序的。

PriorityBlockingQueue（）或者（int i）:类似于LinkedBlockingQueue，但是其所含对象的排序不是FIFO，而是依据对象的自然顺序或者构造函数的Comparator决定。

SynchronizedQueue（）:特殊的BlockingQueue，对其的操作必须是放和取交替完成。

自定义线程池（ThreadPoolExecutor和BlockingQueue连用）：

自定义线程池，可以用ThreadPoolExecutor类创建，它有多个构造方法来创建线程池。

常见的构造函数：ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue)

1 package com.study.test;
 2 
 3 import java.util.concurrent.ArrayBlockingQueue;
 4 import java.util.concurrent.BlockingQueue;
 5 import java.util.concurrent.ThreadPoolExecutor;
 6 import java.util.concurrent.TimeUnit;
 7 
 8 class TempThread implements Runnable {
 9 
10     @Override
11     public void run() {
12         // 打印正在执行的缓存线程信息
13         System.out.println(Thread.currentThread().getName() + "正在被执行");
14         try {
15             // sleep一秒保证3个任务在分别在3个线程上执行
16             Thread.sleep(1000);
17         } catch (InterruptedException e) {
18             e.printStackTrace();
19         }
20     }
21 
22 }
23 
24 public class TestThreadPoolExecutor {
25     public static void main(String[] args) {
26         // 创建数组型缓冲等待队列
27         BlockingQueue<Runnable> bq = new ArrayBlockingQueue<Runnable>(10);
28         // ThreadPoolExecutor:创建自定义线程池，池中保存的线程数为3，允许最大的线程数为6
29         ThreadPoolExecutor tpe = new ThreadPoolExecutor(3, 6, 50, TimeUnit.MILLISECONDS, bq);
30 
31         // 创建3个任务
32         Runnable t1 = new TempThread();
33         Runnable t2 = new TempThread();
34         Runnable t3 = new TempThread();
35         // Runnable t4 = new TempThread();
36         // Runnable t5 = new TempThread();
37         // Runnable t6 = new TempThread();
38 
39         // 3个任务在分别在3个线程上执行
40         tpe.execute(t1);
41         tpe.execute(t2);
42         tpe.execute(t3);
43         // tpe.execute(t4);
44         // tpe.execute(t5);
45         // tpe.execute(t6);
46 
47         // 关闭自定义线程池
48         tpe.shutdown();
49     }
50 }