73 java多线程_5 _线程池

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量142 收藏
点赞数
分类专栏： # 多线程与并发编程 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang_luwei/article/details/107490047
版权

文章目录

线程池概念

  1. 问题：

    • 线程是宝贵的内存资源、单个线程约占1MB空间，过多分配易造成内存溢出。
    • 频繁的创建及销毁线程会增加虚拟机回收频率、资源开销，造成程序性能下降。

  2. 线程池：

    • 线程容器，可设定线程分配的数量上限。
    • 将预先创建的线程对象存入池中，并重用线程池中的线程对象。
    • 避免频繁的创建和销毁。

线程池原理

将任务提交给线程池，由线程池分配线程、运行任务，并在当前任务结束后复用线程

在这里插入图片描述

创建线程池，线程池API

常用的线程池接口和类(所在包java. util. concurrent) ：

  1. Executor：线程池的顶级接口。
  2. ExecutorService：线程池接口，可通过submit (Runnable task) 提交任务代码。
  3. Executors工厂类：通过此类可以获得一个线程池。
  4. 通过newFixedThreadPool (int nThreads) 获取固定数量的线程池。参数:指定线程池中线程的数量。
  5. 通过newCachedThreadPool() 获得动态数量的线程池，如不够则创建新的，没有上限
package com.wlw.thread.threaddemo02;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 线程池的创建
 * （1）Executor：线程池的根接口 -----> execute()执行
 * （2）ExecutorService：包含了管理线程池的一些方法，submit，shutdown
 *          子类 ThreadPoolExecutor
*                   子类 ScheduledThreadPoolExecutor
 * （3）Executors：创建线程池的工具类
 *          （3.1）创建固定线程个数线程池
 *          （3.2）创建缓存（动态数量）线程池，由任务的多少决定
 *          （3.3）创建单线程池
 *          （3.4）创建调度线程池，调度：周期、定时执行
 *
 */
public class ThreadPoolDemo01 {
    public static void main(String[] args) {
        //1.1创建固定线程个数线程池
        //ExecutorService executorService = Executors.newFixedThreadPool(4);
        //1.2创建缓存（动态数量）线程池，由任务的多少决定
        ExecutorService executorService = Executors.newCachedThreadPool();
        //1.3创建单线程池
        //ExecutorService es = Executors.newSingleThreadExecutor();
        //1.4创建调度线程池
        //Executors.newScheduledThreadPool(4);


        //2.创建任务
        Runnable runnable = new Runnable() {
            private int ticket = 100;
            @Override
            public void run() {
                while (true){
                    if(ticket <= 0){
                        break;
                    }
                    System.out.println(Thread.currentThread().getName()+"卖出了，第"+ticket+"张票");
                    ticket--;
                }
            }
        };

        //3.提交任务(提交多次，分配多个线程)
        for (int i = 0; i < 4; i++) {
            executorService.submit(runnable);
        }

        //4.关闭线程池
        executorService.shutdown();//等提交的任务全部执行完，关闭线程池，但不接受新任务。
        //executorService.shutdownNow();//立即停止，不等待
    }
}

Callable接口

线程创建的三种方式：
1. 通过继承Thread，重写run方法
2. 实现Runnable接口
3. 实现Callable接口
- jdk5加入，与Runnable接口类似，实现之后代表一个线程任务
- Callable具有泛型返回值、可以声明异常。

  public interface Callable<V>{
      public V call() throws Exception;
  }

Callable的基本使用

注意：需要将Callable对象转换成可执行任务FutureTask（FutureTask 实现了Runnable接口），再传给线程

package com.wlw.thread.threaddemo02;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * 演示Callable接口的使用
 * Callable接口与Runnable接口的区别：
 * （1）Callable接口中call方法具有泛型返回值，Runnable接口中的run方法没有返回值
 * （2）Callable接口中call方法有声明异常，Runnable接口中的run方法没有声明异常
 */
public class CallableDemo {
    public static void main(String[] args) throws Exception {
        //功能需求：使用Callable实现1~100的和
        //1.创建Callable对象
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName()+"开始计算：");
                int sum = 0;
                for (int i = 0; i <= 100; i++) {
                    sum = sum + i;
                }
                return sum;
            }
        };

        //2.将Callable对象转换成可执行任务（FutureTask 实现了Runnable接口）
        FutureTask<Integer> task = new FutureTask<>(callable);

        //3.创建线程对象，将任务传给线程
        Thread thread = new Thread(task);

        //4.启动线程
        thread.start();

        //5.获取结果(get() 方法要等call() 方法执行完毕，才能返回)
        Integer integer = task.get();
        System.out.println(integer);
    }
}
/*
执行结果：
Thread-0开始计算：
5050
*/

Callable结合线程池的使用

注意：Callable对象是可以直接传给线程池的（不需要转换成FutureTask）

​ 线程池.submit （线程池的提交）有返回值，为future : 表示将要执行完任务的结果

package com.wlw.thread.threaddemo02;

import java.util.concurrent.*;

/**
 * Callable结合线程池的使用
 * Callable对象是可以直接传给线程池的（不需要转换成FutureTask）
 * 实现计算1~100的和
 */
public class ThreadPool_Callable_Demo {
    public static void main(String[] args) throws Exception {
        //1.创建线程池
        ExecutorService es = Executors.newFixedThreadPool(1);

        //2.提交任务 es.submit 的返回值为future : 表示将要执行完任务的结果
        Future<Integer> future = es.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName() + "开始计算");
                int sum = 0;
                for (int i = 0; i <= 100; i++) {
                    sum = sum + i;
                }
                return sum;
            }
        });

        //3.获取结果
        System.out.println(future.get());

        //4.关闭线程池
        es.shutdown();
    }
}

Future接口

  1. Future：表示将要完成任务的结果
  2. 表示ExecutorServ ice. submit ()所返回的状态结果，就是call()的返回值
  3. 方法：V get() 以阻塞形式等待Future中的异步处理结果（call()的返回值）

需求：使用两个线程，并发计算150，51100的和，再进行汇总

package com.wlw.thread.threaddemo02;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * Future接口的使用
 * 需求：使用两个线程，并发计算1~50，51~100的和，再进行汇总
 */
public class FutureDemo {
    public static void main(String[] args) throws Exception{
        
        //1.创建线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        
        //2.提交任务
        Future<Integer> future1 = es.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName()+"计算开始");
                int sum = 0;
                for (int i = 0; i <= 50; i++) {
                    sum += i;
                }
                System.out.println("1~50 计算完毕");
                return sum;
            }
        });
        Future<Integer> future2 = es.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName()+"计算开始");
                int sum = 0;
                for (int i = 51; i <= 100; i++) {
                    sum += i;
                }
                System.out.println("51~100 计算完毕");
                return sum;
            }
        });

        //3.获取结果(get() 方法要等call() 方法执行完毕，才能返回)
        System.out.println(future1.get()+future2.get());

        //4.关闭线程池
        es.shutdown();
    }
}
/*
执行结果：
pool-1-thread-1计算开始
pool-1-thread-2计算开始
51~100 计算完毕
1~50 计算完毕
5050
*/

线程同步和异步

线程同步

  • 形容一次方法调用，同步一旦开始，调用者必须等待该方法返回，才能继续

在这里插入图片描述

线程异步

  • 形容一次方法调用，异步一旦开始，像是一次消息传递，调用者告知之后立刻返回。
  • 二者竞争时间片，并发执行

在这里插入图片描述

Lock接口（与synchronized）

  1. 实现线程同步的接口
  2. JDK5加入，与 synchronized 比较， 显示定义，结构更灵活。
  3. 提供更多实用性方法，功能更强大、性能更优越。
  4. 常用方法:
    • void lock() //获取锁，如锁被占用，则等待。
    • boolean tryLock() //尝 试获取锁(成功返回true。失败返回false,不阻塞)
    • void unlock() //释放锁

Lock接口的实现类：ReentrantLock

重入锁：ReentrantLock：Lock接口的实现类，与synchronized一样具有互斥锁功能（但比synchronized更强大）

例子1：

package com.wlw.thread.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * ReentrantLock的使用
 * 重入锁
 */
public class MyList {

    //创建锁
    private Lock lock =  new ReentrantLock();
    private String[] str = {"A","B","","",""};
   int count = 2;

   public void add(String value){
       try {
           lock.lock(); //上锁
           str[count] = value;
           try {
               Thread.sleep(1000);//主动休眠1秒
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           count++;
           System.out.println(Thread.currentThread().getName()+"存入了"+value);

       }finally {
           lock.unlock();//解锁
       }

   }

    public String[] getStr() {
        return str;
    }
}

package com.wlw.thread.lock;

import java.util.Arrays;

public class TestList {
    public static void main(String[] args) throws Exception {

        MyList list = new MyList();

        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                list.add("Hello");
            }
        };
        Runnable runnable2 = new Runnable() {
            @Override
            public void run() {
                list.add("World");
            }
        };

        //创建线程并启动
        Thread t1 = new Thread(runnable1);
        Thread t2 = new Thread(runnable2);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(Arrays.toString(list.getStr()));
    }
}
/*
Thread-0存入了Hello
Thread-1存入了World
[A, B, Hello, World, ]
*/

例子2：

package com.wlw.thread.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Ticket implements Runnable{

    private int ticket = 100;
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            lock.lock();
            try {
                if(ticket <= 0){
                    break;
                }
                System.out.println(Thread.currentThread().getName()+"卖了第"+ticket+"张票");
                ticket--;
            } finally {
                lock.unlock();
            }

        }
    }
}

package com.wlw.thread.lock;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestTicket {
    public static void main(String[] args) {

        //创建实现类对象
        Ticket ticket = new Ticket();
        //创建线程池
        ExecutorService es = Executors.newFixedThreadPool(4);
        //提交任务
        for (int i = 0; i < 4; i++) {
            es.submit(ticket);
        }

        //关闭线程池
        es.shutdown();
    }
}

ReadWriteLock接口：ReentrantReadWriteLock

  1. 读写锁：ReentrantReadWriteLock：

    • 一种支持一写多读的同步锁，读写分离，可分别分配读锁、写锁。
    • 支持多次分配读锁，使多个读操作可以并发执行。

  2. 互斥规则:

    • 写-写:互斥，阻塞。
    • 读-写:互斥，读阻塞写、写阻塞读。
    • 读-读:不互斥、不阻塞。
    • 在读操作远远高于写操作的环境中，可在保障线程安全的情况下，提高运行效率。
package com.wlw.thread.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
/**
 * 读写锁的演示
 * ReentrantReadWriteLock
 *
 */
public class ReadWriteDemo {
    //创建读写锁
    private ReentrantReadWriteLock rrl= new ReentrantReadWriteLock();
    //获取读锁
    private ReadLock readLock = rrl.readLock();
    //获取写锁
    private WriteLock writeLock = rrl.writeLock();

    //重入锁
    private Lock lock = new ReentrantLock();

    private  String value;

    public String getValue(){
        readLock.lock();//读锁,来上锁
        //lock.lock();
        try {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("读取了,"+value);
            return this.value;
        } finally {
            readLock.unlock();
            //lock.unlock();
        }
    }

    public void setValue(String value){
        writeLock.lock();//写锁，上锁
        //lock.lock();
        try {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("写入了，"+value);
            this.value = value;
        } finally {
            writeLock.unlock();
            //lock.unlock();
        }
    }
}

package com.wlw.thread.lock;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestReadWrite {
    public static void main(String[] args) {
        //创建对象
        ReadWriteDemo readWriteDemo = new ReadWriteDemo();
        //创建线程池
        ExecutorService es = Executors.newFixedThreadPool(20);

        Runnable read = new Runnable() {
            @Override
            public void run() {
                readWriteDemo.getValue();
            }
        };
        Runnable write = new Runnable() {
            @Override
            public void run() {
                readWriteDemo.setValue("张三"+new Random().nextInt(100));
            }
        };

        long start = System.currentTimeMillis();

        //提交2次写
        for (int i = 0; i < 2; i++) {
            es.submit(write);
        }

        //提交18次读
        for (int i = 0; i < 18; i++) {
            es.submit(read);
        }

        es.shutdown();//关闭
        while (!es.isTerminated()){//判断所有线程是否都运行完毕，否则空转
        }

        long end = System.currentTimeMillis();
        System.out.println("用时："+(end - start));
    }
}
/*
读写锁与重入锁 两者用时比较:
用时：3006 vs  用时：20013
*/
悬浮海
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
用两个线程来求1-100之间的和
qq_45753477的博客
11-03 2078
用两个线程来求1-100之间的和 package com.hpeu.jdk5; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; // 用两个线程来求1-100之间的和 // 要想实现此功能，需...
java多线程07_线程池
安德的博客
03-19 377
1.线程池的概念 在前面的章节中，我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题： 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为系统启动一个新线程的成本是比较高的，它涉及到与操作系统的交互，频繁创建线程和销毁线程都需要时间。 在这种情况下，使用线程池可以很好的提供性能，尤其是当程序中需要创建大量生...
lock
weixin_33713503的博客
06-01 98
2019独角兽企业重金招聘Python工程师标准>>> ...
高级多线程笔记
LONGSESON的博客
04-27 135
高级多线程 线程池概念 问题： 线程是宝贵的内存资源、单个线程约占1MB空间，过多分配易造成内存溢出。 频繁的创建及销毁线程会增加虚拟机回收频率、资源开销，造成程序性能下降。 线程池： 线程容器，可设定线程分配的数量上限。将预先创建的线程对象存入池中，并重用线程池中的线程对象。避免频繁的创建和销毁。 创建线程池 常用的线程池接口和类(所在包java.util.concurrent): Executor:线程池的顶级接口。 ExecutorService:线程池接口，可通过submit(Runnable t
java 多线程协作_JAVA多线程 用两个线协作程完成1---100的加法，线程1完成1--50，线程完成51--100，运算结果却不正确...
weixin_34861702的博客
02-24 314
代码如下：packagethreaddemo;/*两个线程同时完成一个任务*/publicclassTestThreadextendsThread{publicstaticvoidmain(Stringargv[]){ThreadDatadata=newThreadData();newMyThread2(...代码如下：package threaddemo;/*两个线程同时完成一个任务*/publ...
Day19-20多线程
Syntactic_tang的博客
12-29 185
多线程 第一节 进程和 线程 1.1 进程的介绍 是一个程序的运行状态和资源占用（内存，CPU）的描述 进程是程序的一个动态过程,它指的是从代码加载到执行完毕的一个完成过程 进程的特点： a.独立性：不同的进程之间是独立的，相互之间资源不共享（举例：两个正在上课的教室有各自的财产，相互之间不共享） b.动态性：进程在系统中不是静止不动的，而是在系统中一直活动的 c.并发性：多...
Java 多线程（6）----线程池（上）
指点
05-03 767
前言 在前面的系列文章中，我们介绍了一下 Java 中多线程的一些主要的知识点和多线程并发程序的设计和处理思想。包括线程的介绍、生命周期、线程的运行控制。之后介绍了如何确保 Java 多线程并发程序的正确性，即通过锁（ReentrantLock 、synchronized ）的思想来实现多线程执行顺序的控制等。如果你对这些还不熟悉，建议看一下前面的文章。接下来我们来看一下 Java 多线程中另一...
java_thread_cn.rar_Java 线程池_java thread books_java线程_线程池_线程池调度
09-14
Java线程池是Java并发编程中的重要组成部分，它在多线程编程中扮演着至关重要的角色，有效地管理和调度了大量的并发任务。线程池通过预先创建并维护一组可重用线程，来提升程序的性能和效率，避免了频繁地创建和销毁...
tcp_thread_java.zip_Java 线程池_java TCP线程
09-14
Java线程池是一种高效管理线程资源的工具，它能够帮助开发者有效地控制并发执行的线程数量，提高系统性能，并确保程序的稳定性和可维护性。在Java中，线程池的实现主要依赖于`java.util.concurrent`包中的`...
java_Thread.rar_java 多线程_java多线程
09-21
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提高系统资源的利用率和程序的响应速度。在Java中，通过实现Runnable接口或者继承Thread类可以创建并运行多线程。本资料"java_Thread.rar"提供...
clientThread.rar_java 多线程_java 聊天
09-19
下面我们将深入探讨与这个项目相关的Java多线程和聊天应用的知识点。 1. **Java多线程**：在Java中，多线程通过创建线程对象来实现。主要有两种方式，一是继承`Thread`类，二是实现`Runnable`接口。`Thread`类是...
QQ_java多线程_
10-04
本项目"QQ_java多线程_"聚焦于利用Java的多线程特性实现一个类似QQ的通信系统，涵盖客户端和服务端的交互。 在Java中，多线程的创建主要有两种方式：通过继承`Thread`类和实现`Runnable`接口。在这个项目中，服务端...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1153
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 416
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 453
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java内存模型
weixin_44267758的博客
07-19 796
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 782
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 153
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
java算法day19
TOMOT77的博客
07-20 329
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
Java多线程：JDK5.0的Callable接口与线程池
"Java多线程-JDK5.0新增线程创建方式" 在Java编程中，多线程是处理并发任务的关键技术。随着JDK 5.0的发布，Java引入了两种新的线程创建方式，即实现Callable接口和使用线程池，以增强线程管理的灵活性和效率。 ##...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悬浮海

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值