【Java多线程】多线程和线程池

已于 2023-05-22 21:48:13 修改
阅读量104 收藏
点赞数
分类专栏： Java 文章标签： java
于 2023-05-09 22:11:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45463540/article/details/130589815
版权

多线程和线程池

线程创建

继承Thread

public class DemoThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(i+" "+Thread.currentThread().getName());
        }
    }
    public static void main(String[] args) {
        DemoThread t1 = new DemoThread();
        DemoThread t2 = new DemoThread();
        t1.start();
        t2.start();
    }
}

实现Runnable接口

public class DemoRunable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(i+" "+Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        Thread t = new Thread(new DemoThread(),"worker-1");
        Thread t2 = new Thread(new DemoThread(),"worker-2");
        t.start();
        t2.start();
    }
}

实现Callable接口

public class DemoCallable implements Callable {
    @Override
    public Integer  call() throws Exception {
        int i ,sum=0;
        for ( i=1; i <=50; i++) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            sum+=i;
            System.out.println(i+" "+Thread.currentThread().getName());
        }
        return sum;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> task = new FutureTask<Integer>(new DemoCallable());
        new Thread(task).start();
        System.out.println(task.get()); //获取call返回值
    }
}

买票实现

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

public class SellTicket implements Runnable {
    int t = 100;
    Lock lock = new ReentrantLock();
    @Override
    public void run() {

        while (t > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            lock.lock(); 
//            synchronized (this) {
                if (t > 0) {
                    System.out.println("已卖掉第" + t + "张票 " + Thread.currentThread().getName());
                    t--;
                } else {
                    return;
                }
//            }
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        SellTicket sellTicket = new SellTicket();
        Thread t1 = new Thread(sellTicket, "window1");
        Thread t2 = new Thread(sellTicket, "window2");
        Thread t3 = new Thread(sellTicket, "window3");
        Thread t4 = new Thread(sellTicket, "window4");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

线程池创建

package thread_prac;

import java.text.DateFormat;
import java.util.Date;
import java.util.concurrent.*;

public class DemoThreadPool {
    public static void main(String[] args) {
/**
* corePoolSize 线程池核心线程大小
* maximumPoolSize 线程池最大线程数量
* keepAliveTime 空闲线程存活时间
* unit 空间线程存活时间单位
* workQueue 工作队列
*  ①ArrayBlockingQueue 基于数组的有界阻塞队列，按FIFO排序。
*  ②LinkedBlockingQuene 基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。
*  ③SynchronousQuene 一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。
*  ④PriorityBlockingQueue 具有优先级的无界阻塞队列，优先级通过参数Comparator实现。
* threadFactory 线程工厂
* handler 拒绝策略 、
*  ①CallerRunsPolicy 该策略下，在调用者线程中直接执行被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务
*  ②AbortPolicy 该策略下，直接丢弃任务，并抛出RejectedExecutionException异常。
*  ③DiscardPolicy 该策略下，直接丢弃任务，什么都不做。
*  ④DiscardOldestPolicy 该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列
*/
        ExecutorService executorService = new ThreadPoolExecutor(2, 5, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 7; i++) {
            executorService.execute(new Worker());
        }
        executorService.shutdown();

//      singleThreadPool();
//      cacheThreadPool();
//      fixedThreadPool();
//      scheduleTheadPool();

    }


    public static void singleThreadPool(){
        /**
         * 只有一个线程的线程池
         * 所有任务都保存队列LinkedBlockingQueue中，核心线程数为1，线程空闲时间为0
         * 等待唯一的单线程来执行任务，并保证所有任务按照指定顺序(FIFO或优先级)执行
         */
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++) {
            executorService.execute(new Worker());
        }
        executorService.shutdown();
    }

    public static void cacheThreadPool(){
        /**
         * 当任务超过线程池的线程数则创建新线程 可缓存无界限线程池(Integer.MAX_VALUE)
         * 空闲线程超过60秒自动回收 核心线程数为0
         */
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i <100; i++) {
            executorService.execute(new Worker());
        }
        executorService.shutdown();
    }

    public static void fixedThreadPool(){
        /**
         * 创建指定大小的线程池 超出的线程会在LinkedBlockingQueue阻塞队列中等待
         * 核心线程数为可以指定 空闲线程为0
         */
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i <6; i++) {
            executorService.execute(new Worker());
        }
        executorService.shutdown();
    }

    public static void scheduleTheadPool(){
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
//        executorService.schedule(new Worker(),2,TimeUnit.SECONDS); //延迟2秒后执行任务
//        executorService.scheduleAtFixedRate(new Worker(),2,3,TimeUnit.SECONDS); //周期性执行任务 当前任务执行时间大于等于间隔时间，任务执行后立即执行下一次任务。相当于连续执行了。
        //每当上次任务执行完毕后，间隔一段时间执行。不管当前任务执行时间大于、等于还是小于间隔时间，执行效果都是一样的。
        executorService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                long start = new Date().getTime();
                System.out.println("scheduleWithFixedDelay 开始执行时间:" +
                        DateFormat.getTimeInstance().format(new Date()));
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                long end = new Date().getTime();
                System.out.println("scheduleWithFixedDelay执行花费时间=" + (end - start) / 1000 + "m");
                System.out.println("scheduleWithFixedDelay执行完成时间："
                        + DateFormat.getTimeInstance().format(new Date()));
                System.out.println("======================================");
            }
        }, 1, 2, TimeUnit.SECONDS);
    }
}

class Worker implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " > 开始办理业务... ");
        System.out.println(Thread.currentThread().getName() + " >> 正在办理" );
        System.out.println(Thread.currentThread().getName() + " >>> 办理结束 ");
    }
}

生产者和消费者模型

  • wait和notify
package thread_prac;

public class DemoWait {
    public static void main(String[] args) {
        Account account = new Account();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                try {
                    account.decrement();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"C1").start();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                try {
                    account.decrement();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"C2").start();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                try {
                    account.increment();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"P").start();
    }
}

class Account{
    public static int  money = 0;
    public synchronized void increment() throws InterruptedException {
        while (money!=0){ //若使用了if 则多个消费者或多个生产者同时运行会产生问题
            this.wait();
        }
        money++;
        System.out.println(Thread.currentThread().getName()+"=>"+money);
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        while (money==0){
            this.wait();
        }
        money--;
        System.out.println(Thread.currentThread().getName()+"=>"+money);
        this.notifyAll();
    }
}
  • await 和signal 这种是随机的
package thread_prac;

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

public class DemoAwait {
    public static void main(String[] args) {
        Account2 account = new Account2();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                try {
                    account.decrement();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"C1").start();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                try {
                    account.decrement();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"C2").start();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                try {
                    account.increment();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"P").start();
    }
}

class Account2 {
    public static int money = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while (money != 0) {
                condition.await();
            }
            money++;
            System.out.println(Thread.currentThread().getName() + "=>" + money);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (money == 0) {
                condition.await();
            }
            money--;
            System.out.println(Thread.currentThread().getName() + "=>" + money);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
  • Condition精准唤醒 A唤醒B, B唤醒C,C唤醒A
package thread_prac;

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

public class DemoOrderSignal {
    public static void main(String[] args) {
        Data  data = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.PrintA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.PrintB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.PrintC();
            }
        },"C").start();

    }
}
class Data{
    int num = 1;  //1A 2B 3C
    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();

    public void PrintA(){
        lock.lock();
        try {
        //业务，判断》执行》通知
            while (num!=1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>A");
            num = 2;
            condition2.signal(); //唤醒B
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void PrintB(){
        lock.lock();
        try {
            while (num!=2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>B");
            num = 3;
            condition3.signal(); //通知其他线程 我完成了
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void PrintC(){
        lock.lock();
        try {
            while (num!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>C");
            num =1;
            condition1.signal(); //通知其他线程 我完成了
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

输出结果

A=>A
B=>B
C=>C
A=>A
B=>B
C=>C
A=>A
B=>B
C=>C
A=>A
B=>B
C=>C
A=>A
B=>B
C=>C
A=>A
B=>B
C=>C
...
Geek喵
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程，对多线程，线程池进行封装，方便使用
05-16
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，我们可以通过实现Runnable接口或继承Thread类来创建线程。然而，直接使用线程可能存在一些问题，如资源管理...
Java多线程+线程池.docx
03-31
Java 多线程和线程池 Java 多线程是指在 Java 编程语言中，一个线程的动态执行过程。这个过程包括线程的创建、执行和销毁三个阶段。在 Java 中，创建线程有多种方式，包括通过实现 Runnable 接口、继承 Thread 类...
Java多线程案例之线程池
trong_ 的烂笔头
01-30 5462
介绍线程池的原理和简单实现, 进一步提高并发编程的效率.
Java 多线程：彻底搞懂线程池
热门推荐
孙强 Jimmy 的博客
07-09 18万+
熟悉Java多线程编程的同学都知道，当我们线程创建过多时，容易引发内存溢出，因此我们就有必要使用线程池的技术了。
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 17万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
java多线程和线程池
一直走，不要回头
07-23 6082
目录 零、java线程理解 0.1 两种线程模型 0.1.1 用户级线程 ULT 0.1.2 内核级线程 KLT——JAVA虚拟机使用的线程模型（KLT） 0.2 java线程与系统内核线程 0.3 线程池的意义 0.4 线程 0.4.1线程五种状态 0.4.2 高并发下，线程池如何保证线程安全 0.4.3 多线程的使用场景 0.4.4 多线程的创建方式 0.4.4 多线程的停止 0.4.5控制多线程的运行顺序——join方法 一、线程池基本概念和使用示例 1.1 基本...
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
qq_35716689的博客
03-25 17万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
【Java多线程进阶】线程池详解
我的主页
05-31 3618
本文讲解：Java 如何创建线程池，以及线程池底层的类，线程池的四个拒绝策略，模拟实现线程池。
JAVA多线程和线程池
itakyubi的博客
08-25 6547
目录 1、线程状态 (1) 新建状态 (2) 就绪状态 (3) 运行状态 (4) 阻塞状态 (5) 死亡状态 2、线程优先级 3、同步工具synchronized、wait、notify 4、创建线程 (1) 实现 Runnable 接口 (2) 继承 Thread 类 (3) 通过 Callable 和 Future 创建线程 5、三种创建方式的区别 6、线程池 (...
java 线程池实现多线程处理list数据
qq_37713521的博客
08-18 1469
引入CopyOnWriteArrayList，Semaphore解决，或者加锁解决问题；所有线程执行完毕后再进行后续业务的处理，引入awaitTermination()方法。需要注意的问题点，多线程处理List数据可能发生线程不安全，
JAVA多线程技术-线程池创建方式和原理
Aldeo
07-19 1692
Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。下面这张图完整描述了线程池的类体系结构。**Executor**一个接口，其定义了一个接收Runnable对象的方法executor，其方法签名为executor(Runnablecommand),一个可定时调度任务的接口。...
java线程池和多线程的使用详解
qq_42872720的博客
05-11 1322
ThreadPoolExecutor线程池位于 java.util.concurrent包下,是 Java 中用于实现线程池的一种基础类。
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
java简单实现多线程及线程池实例详解
08-27
线程池是java中的一个高级多线程技术，它可以有效地提高程序的执行效率和性能。下面是一个简单的示例： ```java public class threadPoolTest { public static void main(String[] args) { //创建一个具有固定...
Java多线程批量数据导入的方法详解
08-25
Java多线程批量数据导入的方法详解 在数据处理中，遇到大量数据导入时，为了提高处理的速度，可以选择使用多线程来批量处理这些处理。常见的场景有大文件导入数据库、数据同步等。在这些场景中，数据导入的过程可以...
J031_使用TCP协议支持与多个客户端同时通信
最新发布
lzn20161229的博客
08-03 199
使用TCP协议支持与多个客户端同时通信。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 616
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 531
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
weixin_55745942的博客
08-01 572
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
Java多线程：JDK5.0的Callable接口与线程池
"Java多线程-JDK5.0新增线程创建方式" 在Java编程中，多线程是处理并发任务的关键技术。随着JDK 5.0的发布，Java引入了两种新的线程创建方式，即实现Callable接口和使用线程池，以增强线程管理的灵活性和效率。 ##...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值