Java多线程02

已于 2023-08-22 10:42:04 修改
阅读量66 收藏
点赞数 1
文章标签： java 学习 开发语言
于 2023-08-15 20:55:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56923228/article/details/132305005
版权

目录

1.死锁以及如何避免死锁

 2.线程通信

3.线程的状态

4. 线程池

4.1 如何创建线程池

4.1.1固定长度线程池

4.1.2单一线程池

 4.1.3可变线程池

4.1.4延迟线程池

4.2原生模式创建线程池

5. 补充（实现Callable接口创建线程 ）

1.死锁以及如何避免死锁

①死锁

  • 当线程A持有独占锁a，并尝试去获取独占锁b的同时，线程B持有独占锁b，并尝试获取独占锁a的情况下，就会发生AB两个线程由于互相持有对方需要的锁，而发生的阻塞现象，称之为死锁。
  • 一个线程可以同时拥有多个对象的锁标记，当线程阻塞时，不会释放已经拥有的锁标记，因此可能会造成死锁。

②如何避免死锁

  • 尽量使用tryLock(long timeout, TimeUnit unit)的方法（ReentrantLock, ReentrantReadWriteLock）,设置超时时间，超时可以退出防止死锁。
  • 尽量使用Java.util.concurrent下的并发类 代替自己手写锁。
  • 尽量降低锁的使用力度，尽量不要几个功能用同一把锁。
  • 尽量减少同步的代码块的嵌套。
public class BoyTask extends Thread{
    @Override
    public void run() {
        synchronized (LockObject.lockA){
            System.out.println("男孩获得画板");
            synchronized (LockObject.lockB){
                System.out.println("男孩获得画笔");
                System.out.println("男孩可以画画了");
            }
        }
    }
}

public class GirlTask extends Thread{
    @Override
    public void run() {
        synchronized (LockObject.lockB){
            System.out.println("女孩获得画笔");
            synchronized (LockObject.lockA){
                System.out.println("女孩获得画板");
                System.out.println("女孩可以画画了");
            }
        }
    }
}

public class LockObject {
    public static Object lockA = new Object();
    public static Object lockB = new Object();
}

public class Test07 {
    public static void main(String[] args) {
        BoyTask boyTask = new BoyTask();
        GirlTask girlTask = new GirlTask();
        boyTask.start();
        girlTask.start();
    }
}

 2.线程通信

sleep（）和wait（）的区别：

  • 来自不同的类：wait来自于Object类中，sleep来自Thread中。
  • 作用位置不同：wait必须放在同步代码块中，而sleep可以放在任意位置。
  • 是否会释放锁资源：wait会释放锁资源，sleep不会释放锁资源。
  • 用法：wait需要notify或notifyAll唤醒，而sleep到时间自动唤醒。

notify（）和notifyAll（）的区别：

  • notify随机唤醒等待对队列中的一个线程，notifyAll会唤醒等待队列中的所有线程。
  • notifyAll（）调用后，会将全部想成由等待池移到锁池，然后参与锁的竞争，竞争成功后则继续执行，如果不成功则留在锁池中等待被释放后再次参与竞争。而notify（）只会唤醒一个线程，具体唤醒哪一个线程一虚拟机控制。

public class BankCard {
    private int balance;
    //当flag为true时表示卡中有钱，为false时表示卡中没钱
    private boolean flag;
    //存钱
    public synchronized void save(int money){
        if (flag){
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        balance+=money;
        System.out.println(Thread.currentThread().getName()+"往卡中存了"+money+"元，卡中剩余"+balance+"元");
        flag=true;
        notify();

    }
    //取钱
    public synchronized void take(int money){
        if(flag==false){
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        balance-=money;
        System.out.println(Thread.currentThread().getName()+"从卡中取了"+money+"元，卡中剩余"+balance+"元");
        flag=false;
        notify();
    }
}

public class BankCard {
    private int balance;
    //当flag为true时表示卡中有钱，为false时表示卡中没钱
    private boolean flag;
    //存钱
    public synchronized void save(int money){
        if (flag){
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        balance+=money;
        System.out.println(Thread.currentThread().getName()+"往卡中存了"+money+"元，卡中剩余"+balance+"元");
        flag=true;
        notify();

    }
    //取钱
    public synchronized void take(int money){
        if(flag==false){
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        balance-=money;
        System.out.println(Thread.currentThread().getName()+"从卡中取了"+money+"元，卡中剩余"+balance+"元");
        flag=false;
        notify();
    }
}


public class SaveTask implements Runnable{
    private BankCard bankCard;
    public SaveTask(BankCard bc){
        bankCard=bc;
    }
    @Override
    public void run() {
        for (int i = 0; i <5; i++) {
            bankCard.save(798);
        }
    }
}


public class TakeTask implements Runnable{
    private BankCard bankCard;
    public TakeTask(BankCard bc){
        bankCard=bc;
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            bankCard.take(798);
        }
    }
}


public class Test08 {
    public static void main(String[] args) {
        BankCard bankCard = new BankCard();
        SaveTask saveTask = new SaveTask(bankCard);
        TakeTask takeTask = new TakeTask(bankCard);
        Thread t1 = new Thread(saveTask,"father");
        Thread t2 = new Thread(takeTask,"son");
        t1.start();
        t2.start();
    }
}

3.线程的状态

  1. 新建（New）：当线程对象被创建但尚未启动时处于新建状态。

  2. 可运行/就绪（Runnable）：线程对象调用了status（）方法后，线程处于可运行状态。在可运行状态下，线程可能正在执行，也可能正在等待系统资源（如处理器时间片）。

  3. 运行（Running）：线程获得了处理器时间片正在执行其任务。

  4. 阻塞（Blocked）：线程被阻塞并暂时停止执行，通常是因为等待某个操作的完成（如等待I/O操作、等待获取锁、等待某个条件满足等）。

  5. 等待（Waiting）：线程等待某个特定条件的发生，需要其他线程显式地唤醒（如通过wait（）方法）。

  6. 超时等待（Timed Waiting）：线程等待一段特定时间，超过时间后会自动唤醒。

  7. 终止（Terminated）：线程执行完毕或出现异常导致终止，不再可运行。

4. 线程池

4.1 如何创建线程池

(1)线程池的种类:

  • 固定长度的线程池

  • 单一线程池

  • 可变线程池

  • 延迟线程池

(2)线程池中参数的意思:

  • core: 核心线程数
  • max: 最大线程池数
  • long: 等待时长
  • unit: 等待单位
  • BlockQueue:等待队列对象。

(3)Executor: 它是线程池的根接口:

  • void execute(Runnable command):执行Runnable类型的任务。

 (4) ExecutorService: Executor的子接口。

  • void shutdown():关闭线程池。需要等任务执行完毕。
  • shutdownNow(); 立即关闭线程池。 不会再接受新的任务。
  • isShutdown(): 判断是否执行了关闭。
  • isTerminated(): 判断线程池是否终止。表示线程池中的任务都执行完毕，线程池关闭。
  • submit(Callable<T> task);提交任务，可以提交Callable。
  • submit(Runnable task): 提交任务，可以提交Runnable。

  (5)Executors: 线程池的工具类，该类提供了创建线程池的一些静态方法。

以下是通过通过Executors工具类创建线程池： 

4.1.1固定长度线程池

public class Test09 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 20; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~");
                }
            });
        }
        executorService.shutdown();
//        executorService.shutdownNow();
    }
}

4.1.2单一线程池

class Test10{
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~");
                }
            });
        }
    }
}

 4.1.3可变线程池

class Test11{
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 20; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~");
                }
            });
        }
        executorService.shutdown();
    }
}

4.1.4延迟线程池

class Test12{
    public static void main(String[] args) {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~");
                }
            },5,TimeUnit.SECONDS);
        }
        executorService.shutdown();
    }
}

4.2原生模式创建线程池

class Test13{
    public static void main(String[] args) {
        //capacity:5  最多有五个任务在等待
        BlockingQueue<Runnable> workQueye=new ArrayBlockingQueue<>(5);
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS, workQueye);
        for (int i = 0; i < 20; i++) {
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~~~");
                }
            });
        }
    }
}

5. 补充（实现Callable接口创建线程 ）

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //①创建线程对象
        MyCallable myCallable = new MyCallable();
        //把线程任务封装到FuntureTask类中，该类可以获取线程任务执行后的结果.
        FutureTask<Integer> integerFutureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(integerFutureTask);
        thread.start();
        System.out.println(integerFutureTask.get());

        //②使用线程池来执行任务
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<Integer> submit = executorService.submit(new MyCallable());
        System.out.println(submit.get());
        executorService.shutdown();
    }
}

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 0; i < 100; i++) {
            sum+=i;
        }
        return sum;
    }
}

cccy001
关注
Java多线程学习Java多线程学习Java多线程学习Java多线程学习.txt
05-15
Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
万字图解Java多线程
热门推荐
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java多线程读取文件
Mr-Bean的博客
08-16 2472
package com.qwx.test; import java.io.*; /** * @ClassName: ReadFile * @Description: java类作用描述 * @Author: qiaowenxuan * @CreateDate: 2021/8/16$ 18:36$ * @Version: 1.0 */ public class ReadFile { public static void main(String[] args) { Fil
java多线程使用教程
鹏鹏2077
04-25 5474
本教程介绍了Java多线程的基本知识和使用方法，包括创建线程、实现Runnable接口、继承Thread类、线程同步、线程间通信和线程池等。多线程技术可以提高程序的并发处理能力和响应速度，但同时也带来了线程安全和同步等问题，需要合理使用同步机制来保证线程安全。使用Java提供的Lock接口可以实现更加灵活和精细的线程同步。线程间通信可以使用wait()、notify()和notifyAll()方法来实现。线程池机制可以重用线程，提高了线程的利用率和效率。掌握了这些知识，可以使用Java实现高效、安全、可靠的
编程必备：JAVA多线程详解
拾一二的博客
06-14 8632
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java多线程与并发
lydms的博客
06-21 1万+
假设线程A已经拥有了某个对象（不是类）的锁，而其它线程B、C想要调用这个对象的某个 synchronized方法（或者块），由于B、C线程在进入对象的 synchronized方法（或者块）之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。假设线程A调用了某个对象的wat（）方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。
【Java系列】深入解析Java多线程
颜淡慕潇
05-09 2万+
Java多线程是提高程序并发性和响应能力的重要手段，需要掌握多线程的实现方式、同步机制、线程之间的通信机制等，以确保多线程程序的正确性和稳定性。
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
Java多线程详解
坏蛋阿土的博客
11-06 6625
线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
JAVA多线程处理for循环
子衿的博客
12-28 9063
public static void main(String[] args) { long start = System.currentTimeMillis(); List<Integer> list = new ArrayList(); for (int i = 0; i < 1000; i++) { list.add(i); } //定义线程数量为20，可根据服务器配置适当调整大小
Java多线程之synchronized
qq_35716085的博客
07-20 6329
synchronized具有同步功能，是一种互斥锁，锁的是对象。如果既想保证共享变量的可见性和有序性，又想保证原子性，那么synchronized关键字是一个不错的选择。synchronized的缺点：1.synchronized底层是由jvm实现，因此不能手动控制锁的释放，不如lock锁灵活，synchronized修饰的方法一旦出现异常，jvm保证锁会被释放（lock锁需要在finally中释放）。2.synchronized是非公平锁，不保证公平性。
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
Java多线程编程实战指南(核心篇)
07-17
Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化，即在一块芯片上集成多个处理器内核（Core），多核处理器（Multicore Processor）离我们越来越近了――如今...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 95
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
刷题---顺序表算法题
weixin_63997543的博客
11-11 249
顺序算法题----力扣刷题
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 196
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
JAVA-01-变量
LJH_laura_li的博客
11-08 451
在方法、构造函数或块内部定义的变量。
Spring的XML配置：从“啊这...“到“啊，就这...“ --手写Spring第六篇了
mkii_hong的博客
11-11 624
Spring通过【资源】和【资源加载】帮我们找到这些配置文件然后通过大厨解析配置最后把"菜"（Bean）放到"厨房"（容器）里本文由 https://github.com/hongweihao/small-spring/tree/6_resource_load 赞注完成本文完 | 求赞求关注求转发!
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值