AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

java线程基本原理

2017-07-14 743
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 1、线程池简介：    多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。        假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。

1、线程池简介：
    多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。   
    假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。

    如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。
                一个线程池包括以下四个基本组成部分：
                1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；
                2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；
                3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；
                4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。
               
    线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。
    线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目，看一个例子：
    假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。

    代码实现中并没有实现任务接口，而是把Runnable对象加入到线程池管理器（ThreadPool），然后剩下的事情就由线程池管理器（ThreadPool）来完成了

 

[java] view plain copy
  1. package mine.util.thread;  
  2.   
  3. import java.util.LinkedList;  
  4. import java.util.List;  
  5.   
  6. /** 
  7.  * 线程池类，线程管理器：创建线程，执行任务，销毁线程，获取线程基本信息 
  8.  */  
  9. public final class ThreadPool {  
  10.     // 线程池中默认线程的个数为5  
  11.     private static int worker_num = 5;  
  12.     // 工作线程  
  13.     private WorkThread[] workThrads;  
  14.     // 未处理的任务  
  15.     private static volatile int finished_task = 0;  
  16.     // 任务队列，作为一个缓冲,List线程不安全  
  17.     private List<Runnable> taskQueue = new LinkedList<Runnable>();  
  18.     private static ThreadPool threadPool;  
  19.   
  20.     // 创建具有默认线程个数的线程池  
  21.     private ThreadPool() {  
  22.         this(5);  
  23.     }  
  24.   
  25.     // 创建线程池,worker_num为线程池中工作线程的个数  
  26.     private ThreadPool(int worker_num) {  
  27.         ThreadPool.worker_num = worker_num;  
  28.         workThrads = new WorkThread[worker_num];  
  29.         for (int i = 0; i < worker_num; i++) {  
  30.             workThrads[i] = new WorkThread();  
  31.             workThrads[i].start();// 开启线程池中的线程  
  32.         }  
  33.     }  
  34.   
  35.     // 单态模式，获得一个默认线程个数的线程池  
  36.     public static ThreadPool getThreadPool() {  
  37.         return getThreadPool(ThreadPool.worker_num);  
  38.     }  
  39.   
  40.     // 单态模式，获得一个指定线程个数的线程池,worker_num(>0)为线程池中工作线程的个数  
  41.     // worker_num<=0创建默认的工作线程个数  
  42.     public static ThreadPool getThreadPool(int worker_num1) {  
  43.         if (worker_num1 <= 0)  
  44.             worker_num1 = ThreadPool.worker_num;  
  45.         if (threadPool == null)  
  46.             threadPool = new ThreadPool(worker_num1);  
  47.         return threadPool;  
  48.     }  
  49.   
  50.     // 执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定  
  51.     public void execute(Runnable task) {  
  52.         synchronized (taskQueue) {  
  53.             taskQueue.add(task);  
  54.             taskQueue.notify();  
  55.         }  
  56.     }  
  57.   
  58.     // 批量执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定  
  59.     public void execute(Runnable[] task) {  
  60.         synchronized (taskQueue) {  
  61.             for (Runnable t : task)  
  62.                 taskQueue.add(t);  
  63.             taskQueue.notify();  
  64.         }  
  65.     }  
  66.   
  67.     // 批量执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定  
  68.     public void execute(List<Runnable> task) {  
  69.         synchronized (taskQueue) {  
  70.             for (Runnable t : task)  
  71.                 taskQueue.add(t);  
  72.             taskQueue.notify();  
  73.         }  
  74.     }  
  75.   
  76.     // 销毁线程池,该方法保证在所有任务都完成的情况下才销毁所有线程，否则等待任务完成才销毁  
  77.     public void destroy() {  
  78.         while (!taskQueue.isEmpty()) {// 如果还有任务没执行完成，就先睡会吧  
  79.             try {  
  80.                 Thread.sleep(10);  
  81.             } catch (InterruptedException e) {  
  82.                 e.printStackTrace();  
  83.             }  
  84.         }  
  85.         // 工作线程停止工作，且置为null  
  86.         for (int i = 0; i < worker_num; i++) {  
  87.             workThrads[i].stopWorker();  
  88.             workThrads[i] = null;  
  89.         }  
  90.         threadPool=null;  
  91.         taskQueue.clear();// 清空任务队列  
  92.     }  
  93.   
  94.     // 返回工作线程的个数  
  95.     public int getWorkThreadNumber() {  
  96.         return worker_num;  
  97.     }  
  98.   
  99.     // 返回已完成任务的个数,这里的已完成是只出了任务队列的任务个数，可能该任务并没有实际执行完成  
  100.     public int getFinishedTasknumber() {  
  101.         return finished_task;  
  102.     }  
  103.   
  104.     // 返回任务队列的长度，即还没处理的任务个数  
  105.     public int getWaitTasknumber() {  
  106.         return taskQueue.size();  
  107.     }  
  108.   
  109.     // 覆盖toString方法，返回线程池信息：工作线程个数和已完成任务个数  
  110.     @Override  
  111.     public String toString() {  
  112.         return "WorkThread number:" + worker_num + "  finished task number:"  
  113.                 + finished_task + "  wait task number:" + getWaitTasknumber();  
  114.     }  
  115.   
  116.     /** 
  117.      * 内部类，工作线程 
  118.      */  
  119.     private class WorkThread extends Thread {  
  120.         // 该工作线程是否有效，用于结束该工作线程  
  121.         private boolean isRunning = true;  
  122.   
  123.         /* 
  124.          * 关键所在啊，如果任务队列不空，则取出任务执行，若任务队列空，则等待 
  125.          */  
  126.         @Override  
  127.         public void run() {  
  128.             Runnable r = null;  
  129.             while (isRunning) {// 注意，若线程无效则自然结束run方法，该线程就没用了  
  130.                 synchronized (taskQueue) {  
  131.                     while (isRunning && taskQueue.isEmpty()) {// 队列为空  
  132.                         try {  
  133.                             taskQueue.wait(20);  
  134.                         } catch (InterruptedException e) {  
  135.                             e.printStackTrace();  
  136.                         }  
  137.                     }  
  138.                     if (!taskQueue.isEmpty())  
  139.                         r = taskQueue.remove(0);// 取出任务  
  140.                 }  
  141.                 if (r != null) {  
  142.                     r.run();// 执行任务  
  143.                 }  
  144.                 finished_task++;  
  145.                 r = null;  
  146.             }  
  147.         }  
  148.   
  149.         // 停止工作，让该线程自然执行完run方法，自然结束  
  150.         public void stopWorker() {  
  151.             isRunning = false;  
  152.         }  
  153.     }  
  154. }  

 

测试代码：

[java] view plain copy
  1. package mine.util.thread;  
  2.   
  3. //测试线程池  
  4. public class TestThreadPool {  
  5.     public static void main(String[] args) {  
  6.         // 创建3个线程的线程池  
  7.         ThreadPool t = ThreadPool.getThreadPool(3);  
  8.         t.execute(new Runnable[] { new Task(), new Task(), new Task() });  
  9.         t.execute(new Runnable[] { new Task(), new Task(), new Task() });  
  10.         System.out.println(t);  
  11.         t.destroy();// 所有线程都执行完成才destory  
  12.         System.out.println(t);  
  13.     }  
  14.   
  15.     // 任务类  
  16.     static class Task implements Runnable {  
  17.         private static volatile int i = 1;  
  18.   
  19.         @Override  
  20.         public void run() {// 执行任务  
  21.             System.out.println("任务 " + (i++) + " 完成");  
  22.         }  
  23.     }  
  24. }  


 

运行结果：

WorkThread number:3  finished task number:0  wait task number:6
任务 1 完成
任务 2 完成
任务 3 完成
任务 4 完成
任务 5 完成
任务 6 完成
WorkThread number:3  finished task number:6  wait task number:0

分析：由于并没有任务接口，传入的可以是自定义的任何任务，所以线程池并不能准确的判断该任务是否真正的已经完成（真正完成该任务是这个任务的run方法执行完毕），只能知道该任务已经出了任务队列，正在执行或者已经完成。

 

2、Java类库中提供的线程池简介：

     java提供的线程池更加强大，相信理解线程池的工作原理，看类库中的线程池就不会感到陌生了。

文章标签：
Java
调度
关键词：
Java线程
Java原理
线程原理
Java基本原理
ke_ry
目录
相关文章
众所周知
|
7天前
|
存储 Java 关系型数据库
高效连接之道：Java连接池原理与最佳实践
在Java开发中，数据库连接是应用与数据交互的关键环节。频繁创建和关闭连接会消耗大量资源，导致性能瓶颈。为此，Java连接池技术通过复用连接，实现高效、稳定的数据库连接管理。本文通过案例分析，深入探讨Java连接池的原理与最佳实践，包括连接池的基本操作、配置和使用方法，以及在电商应用中的具体应用示例。
众所周知
22 5
那年春天
|
9天前
|
监控 安全 Java
在 Java 中使用线程池监控以及动态调整线程池时需要注意什么？
【10月更文挑战第22天】在进行线程池的监控和动态调整时，要综合考虑多方面的因素，谨慎操作，以确保线程池能够高效、稳定地运行，满足业务的需求。
那年春天
80 38
运营研究坊
|
6天前
|
安全 Java
java 中 i++ 到底是否线程安全？
本文通过实例探讨了 `i++` 在多线程环境下的线程安全性问题。首先，使用 100 个线程分别执行 10000 次 `i++` 操作，发现最终结果小于预期的 1000000，证明 `i++` 是线程不安全的。接着，介绍了两种解决方法：使用 `synchronized` 关键字加锁和使用 `AtomicInteger` 类。其中，`AtomicInteger` 通过 `CAS` 操作实现了高效的线程安全。最后，通过分析字节码和源码，解释了 `i++` 为何线程不安全以及 `AtomicInteger` 如何保证线程安全。
运营研究坊
20 2
java 中 i++ 到底是否线程安全？
进步`于辰
|
10天前
|
Java 调度
[Java]线程生命周期与线程通信
本文详细探讨了线程生命周期与线程通信。文章首先分析了线程的五个基本状态及其转换过程，结合JDK1.8版本的特点进行了深入讲解。接着，通过多个实例介绍了线程通信的几种实现方式，包括使用`volatile`关键字、`Object`类的`wait()`和`notify()`方法、`CountDownLatch`、`ReentrantLock`结合`Condition`以及`LockSupport`等工具。全文旨在帮助读者理解线程管理的核心概念和技术细节。
进步`于辰
27 1
[Java]线程生命周期与线程通信
东方睿赢
|
2天前
|
Java 开发者
在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
东方睿赢
12 4
丰宝宝
|
2天前
|
消息中间件 供应链 Java
掌握Java多线程编程的艺术
【10月更文挑战第29天】 在当今软件开发领域，多线程编程已成为提升应用性能和响应速度的关键手段之一。本文旨在深入探讨Java多线程编程的核心技术、常见问题以及最佳实践，通过实际案例分析，帮助读者理解并掌握如何在Java应用中高效地使用多线程。不同于常规的技术总结，本文将结合作者多年的实践经验，以故事化的方式讲述多线程编程的魅力与挑战，旨在为读者提供一种全新的学习视角。
丰宝宝
19 3
大树营养快线
|
8天前
|
安全 Java
在 Java 中使用实现 Runnable 接口的方式创建线程
【10月更文挑战第22天】通过以上内容的介绍，相信你已经对在 Java 中如何使用实现 Runnable 接口的方式创建线程有了更深入的了解。在实际应用中，需要根据具体的需求和场景，合理选择线程创建方式，并注意线程安全、同步、通信等相关问题，以确保程序的正确性和稳定性。
大树营养快线
28 11
shuj
|
3天前
|
安全 Java 调度
Java中的多线程编程入门
【10月更文挑战第29天】在Java的世界中，多线程就像是一场精心编排的交响乐。每个线程都是乐团中的一个乐手，他们各自演奏着自己的部分，却又和谐地共同完成整场演出。本文将带你走进Java多线程的世界，让你从零基础到能够编写基本的多线程程序。
shuj
12 1
东方睿赢
|
5天前
|
存储 Java 关系型数据库
在Java开发中，数据库连接是应用与数据交互的关键环节。本文通过案例分析，深入探讨Java连接池的原理与最佳实践
在Java开发中，数据库连接是应用与数据交互的关键环节。本文通过案例分析，深入探讨Java连接池的原理与最佳实践，包括连接创建、分配、复用和释放等操作，并通过电商应用实例展示了如何选择合适的连接池库（如HikariCP）和配置参数，实现高效、稳定的数据库连接管理。
东方睿赢
16 2
萝卜带泥
|
7天前
|
缓存 Java 调度
Java中的多线程编程：从基础到实践
【10月更文挑战第24天】 本文旨在为读者提供一个关于Java多线程编程的全面指南。我们将从多线程的基本概念开始，逐步深入到Java中实现多线程的方法，包括继承Thread类、实现Runnable接口以及使用Executor框架。此外，我们还将探讨多线程编程中的常见问题和最佳实践，帮助读者在实际项目中更好地应用多线程技术。
萝卜带泥
15 3

热门文章

最新文章

  • 1
    深入java虚拟机学习 -- 类的加载机制(三)
  • 2
    Rhino 是一个完全使用Java语言编写的开源JavaScript实现。Rhino通常用于在Java程序中，为最终用户提供脚本化能力。它被作为J2SE 6上的默认Java脚本化引擎。
  • 3
    基于Java和MySQL实现的大学生学籍管理系统(毕业设计附完整项目代码)
  • 4
    Java类库中的一些常用的查找排序
  • 5
    通过java api提交自定义hadoop 作业
  • 6
    再转一篇关于Memcached在JAVA项目里应用的入门文章
  • 7
    JAVA DES
  • 8
    16.2. jps - Java Virtual Machine Process Status Tool
  • 9
    Java本地文件操作(六）文件的简单读写
  • 10
    JAVA SERVLET 属性范围样例
  • 1
    Android进程与线程
    49
  • 2
    Java并发编程：实现高效、线程安全的多线程应用
    58
  • 3
    python并发编程: Python使用线程池在Web服务中实现加速
    63
  • 4
    LInux下Posix的传统线程示例
    49
  • 5
    Springboot启动的时候初始化的线程池默认配置tomcat
    157
  • 6
    SpringBoot实现多线程定时任务动态定时任务配置文件配置定时任务
    604
  • 7
    Python开启线程和线程池的方法
    59
  • 8
    【C/C++ 线程池设计思路】 深入探索线程池设计：任务历史记录的高效管理策略
    170
  • 9
    【Qt 底层之事件驱动系统】深入理解 Qt 事件机制：主事件循环与工作线程的交互探究，包括 QML 的视角
    1310
  • 10
    【C++ 线程包裹类设计】跨平台C++线程包装类：属性设置与平台差异的全面探讨
    109

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 观察进程的并发性
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月