Java多线程

最新推荐文章于 2024-07-15 22:27:18 发布
最新推荐文章于 2024-07-15 22:27:18 发布
阅读量82 收藏
点赞数 1
分类专栏： 初级Java 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24090609/article/details/114273907
版权

多线程详解

定义

  • 程序：指令和数据的有序集合，静态的概念；
  • 进程：执行程序的一次执行过程，动态的概念，系统资源分配的单位
  • 线程：一个进程包含若干个线程，一个进程至少有一个线程，是CPU调度和执行的单位

三种创建方式

Thread

public class TestThread1 extends Thread{
	@override
	public void run() {
		//run方法线程体
		for (int i = 0; i < 200; i++) {
			system.out.println("我在看代码---"+i);
		}
	}
	public static void main(String[] args) {
		//main线程,，主线程
		//创建一个线程对象
		TestThread1 testThread1 = new TestThread1();
		//调用start()方法开启线程
		testThread1.start( );
		for (int i = 0; i < 1000; i++) {
			system.out.println("我在学习多线程--"+i);
		}
	}
}

Runnable

public class TestThread3 implements Runnable{
@override
	public void run() {
		for (int i = 0; i < 200;i++) {
			system. out.println("我在看代码-——"+i) ;
		}
	}
	public static void main(string[] args) { 
		//创建runnbale接口的实现类对象
		TestThread3 testThread3 = new TestThread3( );
		//创建线程对象,通过线程对象来开启我们的线程,代理
		Thread thread = new Thread (testThread3);
		thread.start();
		//new Thread (testThread3).start();
		for (int i = 0; i < 1000; i++) {
			system.out.println("我在学习多线程--"+i);}
		}
	}

Callable(重要)

  • 可以定义返回值，可以抛出异常
public class TestCallable implements Callable{
@override
	public Boolean call() {
		for (int i = 0; i < 200;i++) {
			system. out.println("我在看代码-——"+i) ;
		}
		return true;
	}
	public static void main(string[] args) { 
		//创建runnbale接口的实现类对象
		TestCallable testCallable = new TestCallable( );
		//创建执行服务：
		ExecutorService executorService = Executors.newFixedThreadPool(1);
		//提交执行
		Future<Boolean> future =executorService.submit(testCallable);	
		//获取结果	
		boolean result = future.get();
		executorService.shutdownNow();
		for (int i = 0; i < 1000; i++) {
			system.out.println("我在学习多线程--"+i);}
		}
	}

线程状态

  • NEW
    尚未启动的线程处于此状态。
  • RUNNABLE
    在Java虚拟机中执行的线程处于此状态。
  • BLOCKED
    被阻塞等待监视器锁定的线程处于此状态。
  • WAITING
    正在等待另一个线程执行特定动作的线程处于此状态。
  • TIMED_WAITING
    正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
  • TERMINATED
    已退出的线程处于此状态。
    在这里插入图片描述
    在这里插入图片描述
方法说明
setPriority(int newPriority)更改线程的优先级
static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠
void join()等待该线程终止
static void yield()暂停当前正在执行的线程对象，并执行其他线程
void interrupt()中断线程，别用这个方式
boolean isAlive()测试线程是否处于活动状态

线程停止

  • 最好不要使用stop(),destory()方法,因为他们直接停止线程,容易丢失数据操作,建议使用一个标志位来标记是否停止.
package thread;

//测试stop
//1.建议线程正常停止 -> 利用次数,不建议死循环
//2.建议使用标志位 ->设置一个标志位
//3.不要使用stop或者destory等过时或者JDK不建议使用的方法
public class TestStop implements Runnable{

    //1.设置一个标志位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println("run....Thread" + i++);
        }
    }

    //2.设置一个公开的方法停止线程,转换标志位
    public void stop () {
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main "+ i);
            if (i == 900) {
                //通用stop方法切换标志位.让线程停止
                testStop.stop();
                System.out.println("线程停止了");

            }
        }
    }

}

线程休眠

  • Thread.sleep(1000); //休眠一秒
  • 每一个对象都有一个锁,sleep不会释放锁;

线程礼让

  • Thread.yield()
  • 礼让线程，让当前正在执行的线程暂停，但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让cpu重新调度，礼让不一定成功!看CPU心情

线程强制执行

  • join();
  • Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞

线程优先级

  • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
  • 线程的优先级用数字表示，范围从1~10.
    Thread.MIN_PRIORITY= 1;
    Thread.MAX_PRIORITY = 10;
    Thread.NORM_PRIORITY = 5;使用以下方式改变或获取优先级
    getPriority() . setPriority(int xxx)
  • 性能导致 优先级低只是意味着获得调度的概率低,并不是低就不会先被调用了

线程同步机制

  • 由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题﹐为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized， 当一个线程获得对象的排它锁,独占资源﹐其他线程必须等待，使用后释放锁即可.存在以下问题:
  1. 一个线程持有锁会导致其他所有需要此锁的线程挂起;
  2. 在多线程竞争下﹐加锁﹐释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
  3. 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置﹐引起性能问题.
  • CopyOnWriteArrayList 线程安全,使用volatile

死锁

  • 产生死锁的四个必要条件:
    1．互斥条件:一个资源每次只能被一个进程使用。
    2．请求与保持条件:一个进程因请求资源而阻塞时，对已获得的资源保持不放。
    3．不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
    4．循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

Lock锁

  • 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
  • ReentrantLock类(可重入锁)实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
package thread.syn;

import java.util.concurrent.locks.ReentrantLock;

//测试Lock锁
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();

        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}

class TestLock2 implements Runnable {
    int ticketNums = 10;

    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (ticketNums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                } else {
                    break;
                }
            } finally {
                lock.unlock();
            }

        }
    }
}
  • synchronized 与Lock的对比
  1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁)synchronized是隐式锁，出了作用域自动释放
  2. Lock只有代码块锁，synchronized有代码块锁和方法锁
  3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
  4. 优先使用顺序: Lock >同步代码块（已经进入了方法体，分配了相应资源)>同步方法（在方法体之外)

线程协作

生产者消费者模式

  • 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库﹐消费者将仓库中产品取走消费．
  • .如果仓库中没有产品﹐则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止.
  • 如果仓库中放有产品﹐则消费者可以将产品取走消费﹐否则停止消费并等待，直到仓库中再次放入产品为止．
方法名作用
wait()表示线程一直等待,直到其他线程通知，与sleep不同，会释放锁
wait(long timeout)指定等待的毫秒数
notify()唤醒一个处于等待状态的线程
notifyAll()唤醒同一个对象上所有调用wait()方法的线程﹐优先级别高的线程优先调度

管程法

package thread.PC;

//测试:生产者消费者模型 -->利用缓冲区解决:管程法
//生产者,消费者,产品,缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer container =new SynContainer();
        new Productor(container).start();
        new Consumer(container).start();
    }
}

//生产者
class Productor extends Thread {
    SynContainer synContainer;

    public Productor(SynContainer synContainer) {
        this.synContainer = synContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            synContainer.push(new Chicken(i));
            System.out.println("生产了" + i + "只鸡");
        }
    }
}

//消费者
class Consumer extends Thread {
    SynContainer synContainer;

    public Consumer(SynContainer synContainer) {
        this.synContainer = synContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了-->" + synContainer.pop().id + "鸡");
        }
    }

}

//产品
class Chicken extends Thread {
    int id;//产品编号

    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer {
    //需要一个容器大小
    Chicken[] chickens =new Chicken[10];
    //容器计数器
    int count = 0;

    //生产者生产产品
    public synchronized void push (Chicken chicken) {
        //如果容器满了,就需要等待消费者消费
        if (count == chickens.length) {
            //通知消费者消费,生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满,我们就需要丢入产品
        chickens[count]  =  chicken;
        count++;
        //可以通知消费者消费了
        this.notifyAll();

    }

    //消费者消费产品
    public synchronized Chicken pop () {
        //判断能否消费
        if (count == 0) {
            //等待生产者生产,消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken = chickens[count];
        //吃完了,通知生产者生产
        this.notifyAll();
        return chicken;
    }

}

信号灯法

package thread.PC;

//测试:生产者消费者模型 -->信号灯法,标志位解决
public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生产者  演员
class Player extends Thread {
    TV tv;

    public Player(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2 == 0) {
                this.tv.play("唱歌");
            } else {
                this.tv.play("跳舞");
            }
        }
    }
}

//消费者  观众
class Watcher extends Thread {
    TV tv;

    public Watcher(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

//产品  节目
class TV {
    //演员表演,观众等待
    //观众观看,演员等待
    String voice; //表演的节目
    boolean flag = true;

    //表演
    public synchronized void play(String voice) {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了:" +voice);
        //通知观众观看
        this.notifyAll(); //通知换醒
        this.voice = voice;
        this.flag = !this.flag;
    }

    //观看
    public synchronized void watch() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了:" +voice);
        //通知演员表演
        this.notifyAll(); //通知换醒
        this.flag = !this.flag;
    }

}

线程池

  • 背景∶经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
  • 思路:提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
  • 好处:
  1. 提高响应速度（减少了创建新线程的时间)
  2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建)
  3. 便于线程管理(…)
    • corePoolSize:核心池的大小
    • maximumPoolSize:最大线程数
    • keepAliveTime:线程没有任务时最多保持多长时间后会终止
  • JDK 5.0起提供了线程池相关API: ExecutorService和Executors
  • ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
    • void execute(Runnable command)∶执行任务/命令，没有返回值，一般用来执行Runnable
    • Future submit(Callable task):执行任务，有返回值，一般用来执行Callable
    • void shutdown()∶关闭连接池
  • Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池
package thread.pool;

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

//测试线程池
public class TestPool {

    public static void main(String[] args) {
        //1.创建服务,创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //2.关闭连接
        service.shutdown();

    }

}

class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
QSHigh
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
java多线程
05-02
Java多线程是Java编程中的核心概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：通过实现`Runnable`接口和继承`Thread`类。 1. 实现Runnable接口 当一个类...
Java多线程读取大文件
12-22
【Java多线程读取大文件】是一种优化的文件处理策略，特别适用于处理大型文本文件。在传统的单线程I/O操作中，读取大文件可能导致内存溢出（OOM），尤其是在尝试一次性加载整个文件到内存时。为了避免这个问题，我们...
配置Java开发环境
Broken_x的博客
07-10 1618
Java开发环境配置
java集合工具类
药的博客
07-12 484
【代码】java集合工具类。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 581
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 313
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
基于Java技术的校园台球厅人员与设备管理系统
heye0910032的博客
07-12 557
本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。该系统利用MySQL数据库进行数据存储，实现了包括首页、个人中心、用户管理、会员账号管理、会员充值管理、球桌信息管理、会员预约管理、普通预约管理、留言反馈和系统管理等多功能集成。系统设计考虑了用户友好性和操作便捷性，旨在提高校园台球厅人员与设备管理的效率和质量。本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
最新发布
liangzai215的专栏
07-15 314
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
深入剖析 Java 中 Spring Bean 的生命周期
weixin_42545951的博客
07-12 636
在 Java 开发中，Spring 框架是广泛使用的企业级应用开发框架。理解 Spring Bean 的生命周期对于开发者来说至关重要，这也是面试中经常会被问到的重要知识点。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 406
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
从零手写实现 nginx-27-return 指令
07-14 540
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat。
秋招Java后端开发冲刺——MyBatisPlus总结
qq_50604294的博客
07-13 708
本文对MyBatisPlus进行了介绍，并对其特点、基本使用和扩展功能进行了总结概括。
uboot的功能
weixin_43732386的博客
07-13 47
uboot=裸机程序，uboot的核心功能是启动内核。
项目实战--XML文档解析工具
qq_40623672的博客
07-11 908
XML (eXtensible Markup Language)指可扩展标记语言，标准通用标记语言的子集，可以标记数据、定义数据类型，可以允许自定义标记语言进行数据承载，通常被用来传输和存储数据，定义也简单，遵循核心DTD（文档类型定义）语法约束。> < site > < name > CSDN博客网站 </ name > < url > https://blog.csdn.net/ </ url > < desc > 技术学习网站 </ desc > </ site >
Java：ThreadPoolExecutor线程池知识体系
彭世瑜的博客
07-15 256
ThreadPoolExecutor的构造方法。固定大小线程数的线程池。
【JavaEE】Spring AOP详解
m0_74105656的博客
07-10 1014
SpringAOP知识点的详细讲解
Java多线程.pdf
09-28
"这份资料详细介绍了Java多线程编程的相关知识，包括线程的创建、线程安全和锁机制，以及线程池的使用。" 在Java编程中，多线程技术是核心概念之一，它允许程序同时执行多个任务，提高了程序的效率和响应性。Java多...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值