多线程笔记

最新推荐文章于 2024-11-07 00:05:38 发布
最新推荐文章于 2024-11-07 00:05:38 发布
阅读量79 收藏
点赞数 2
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62270892/article/details/127791821
版权

文章目录

  • 一、多线程的入门了解
  • 二、多线程的创建方式
    • 1.继承Thread类
    • 2.实现Runable接口
    • 3.实现Callable接口
    • 4.线程池创建
  • 三、线程的生命周期
  • 四、线程安全   
    • 1.synchronized
    • 2.lock

一、多线程入门了解

程序：程序指的是为完成某种任务，用某种语言编写的一组指令的集合

线程：一个进程可以有多个线程，一个线程就是一个指令流

进程：进程指的是程序的一次执行过程

并发：一个 cpu 同时执行多个任务

并行：多个 cpu 同时执行多个任务

二、多线程的创建方式

1.继承Thread类

public class ThreadCreate1 {
    public static void main(String[] args) {
        //创建线程对象
        MyThread1 myThread1 = new MyThread1();
        myThread1.start();//用于开启一个线程，并且只能调用一次
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"打印"+i);
        }
    }
}

class MyThread1 extends Thread{

    //run方法里面存放的是线程任务
    @Override
    public void run(){
        for (int i = 0; i < 10; i++) {
            //getName()用于获取线程的名称
            System.out.println(getName()+"线程->"+i);
        }
    }
}

 2.实现Runable接

public class RunableTest1 {
    public static void main(String[] args) {
        Thread thread = new Thread(new Gui(),"线程一");
        Thread thread1 = new Thread(new Gui(),"线程二");
        thread.start();
        thread1.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"->"+i);
        }
    }
}

class Gui implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"->"+i);
        }
    }
}

口

3.实现Callable接口

public class CallableTest1 {
    public static void main(String[] args) {
        Tq tq = new Tq();
        //FutureTask可以用于接收Callable对象，还提供了一个get方法--用于拿去返回值
        FutureTask futureTask = new FutureTask(tq);
        FutureTask futureTask1 = new FutureTask(tq);
        //由于Future Task实现Runable接口，对此他也是Runable的一个实例对象
        Thread thread = new Thread(futureTask,"线程一");
        Thread thread1 = new Thread(futureTask1,"线程二");
        thread.start();
        thread1.start();
    }
}

class Tq implements Callable{

    //Callable方法用于执行线程任务，并且可以i返回结果，还会抛出一个异常
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"->"+i);
        }
        return null;
    }
}

4.线程池创建 

public class Model5 {
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(10);
service.execute(new ThreadTest());
service.execute(new ThreadTest2());
service.shutdown();
}
}
class ThreadTest implements Runnable{
@Override
public void run() {
for (int i = 0; i < 30; i++) {
if (i % 2 == 0){
System.out.println(Thread.currentThread().getName()+"----->"+i);
}
}
}
}
class ThreadTest2 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 30; i++) {
if (i % 2 != 0){
System.out.println(Thread.currentThread().getName()+"----->"+i);
}
}
}
}

三、线程的生命周期

 新建：Thread类及其子类被声明

就绪：新建的线程调用了start()方法，进入线程队列等待CPU资源

运行：就绪状态的线程得到了CPU的资源，执行run()方法

阻塞：在某些特殊情况下，被人为挂起或执行输入输出操作的时候，线程对象让出
自己的 cpu 并终止任务进入阻塞状态

死亡：线程对象完成了它的线程任务或者被强制退出、发生异常等

 四、线程安全

1.synchronized

如果我们要保证多线程的操作安全，那么我们可以通过 Synchronized 的同步代码块或
者方法从而保证线程的安全

①同步代码块

同步代码块就是通过 Synchronized 关键字将需要待同步的代码给放到指定代码块里面，
并使用同步锁去控制同步。

格式：

synchronized(同步监视器){

        代码

}

同步监视器：就是锁，任何一个对象都是锁，多个线程之间通信要使用同意一把锁

案例：

public class Model18 {
public static void main(String[] args) {
WindowSal sal = new WindowSal();
Thread thread1 = new Thread(sal,"窗口一");
Thread thread2 = new Thread(sal,"窗口二");
Thread thread3 = new Thread(sal,"窗口三");
thread1.start();
thread2.start();
thread3.start();
}
}
class WindowSal implements Runnable{
private int ticket = 1000;
@Override
public void run() {
while (true){
synchronized (this){
if (ticket > 0){
System.out.println(Thread.currentThread().getName()+"正在售卖第
"+(100-ticket+1)+"张票"+"还剩下："+(ticket-1)+"张票。");
ticket--;
}else {
break;
}
}
}
}
}

②同步方法 

同步方法就是用synchronized去修饰方法，把这个方法放到run方法里

public class Model18 {
public static void main(String[] args) {
WindowSal sal = new WindowSal();
Thread thread1 = new Thread(sal,"窗口一");
Thread thread2 = new Thread(sal,"窗口二");
Thread thread3 = new Thread(sal,"窗口三");
thread1.start();
thread2.start();
thread3.start();
}
}
class WindowSal implements Runnable{
private int ticket = 1000;
@Override
public void run() {
while (true){
sal();
}
}
private synchronized void sal(){
if (ticket > 0){
System.out.println(Thread.currentThread().getName()+"
正在售卖第"+(1000-ticket+1)+"张票"+"还剩下："+(ticket-1)+"张票。");
ticket--;
}else {
Thread.currentThread().stop();
}
}
}

 ③死锁

死锁：多个线程互相等待对方持有的锁，而在得到对方的锁之前都 不会释放自己的锁

案例：

class T1 extends Thread{
private static Object obj1 = new Object();
private static Object obj2 = new Object();
private int flag;
T1(String name,int flag){
super(name);
this.flag = flag;
}
@Override
public void run() {
if (flag == 1){
synchronized (obj1) {
System.out.println(getName()+"已持锁一");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName()+"正在尝试获取锁二");
synchronized (obj2) {
System.out.println(getName()+"已持锁二");
}
}
}else {
synchronized (obj2) {
System.out.println(getName()+"已持锁二");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName()+"正在尝试获取锁一");
synchronized (obj1) {
System.out.println(getName()+"已持锁一");
}
}
}
}
}
我们可以看到上述代码运行以后线程一持有锁一并去尝试获取锁二，而线程二持有锁二
并尝试去获取锁一，结果就造成两个线程相互等待对方释放锁并去抢占然后两个线程就会一
直处于等待的过程中。
1、死锁产生的原因
线程对所分配到的锁具有排它性，一个线程获取到锁以后，其它线程只能等待该线程释
放锁，然后才能去抢占。
public class Model2 {
public static void main(String[] args) {
T1 t1 = new T1("线程一",1);
T1 t2 = new T1("线程二",2);
t2.start();
t1.start();
}
}

 

2.lock

Lock 接口中规定的这些方法，分别可以用于加锁、释放锁等操作，具体如下所示：

⚫ void lock()：获得锁。如果锁不可用，则当前线程将被禁用以进行线程调度，并处 于休眠状态，直到获取锁。

⚫ void lockInterruptibly()：获取锁，如果可用并立即返回。如果锁不可用，那么当前 线程将被禁用以进行线程调度，并且处于休眠状态，和 lock()方法不同的是在锁的 获取中可以中断当前线程。 ⚫ boolean tryLock()：只有在调用时才可以获得锁。如果可用，则获取锁，并立即返回 值为 true；如果锁不可用，则此方法将立即返回值为 false 。

⚫ boolean tryLock(long time, TimeUnit unit)：超时获取锁，当前线程在一下三种情况 下会返回：1. 当前线程在超时时间内获得了锁；2.当前线程在超时时间内被中断； 3.超时时间结束，返回 false。

⚫ void unlock()：释放锁。

我们在操作 Lock 锁需要注意的是 Lock 锁需要手动释放，如果发生了异常锁也不会被 释放，需要我们手动释放，对此我们在使用 Lock 锁时就需要将代码放在放在 try-finally 异 常处理机制中。

 案例：

public class Model1 {
 public static void main(String[] args) {
 ThLock th1 = new ThLock("线程一");
 ThLock th2 = new ThLock("线程二");
 th1.start();
 th2.start();
 }
}
class ThLock extends Thread{
 ThLock(String name){
 super(name);
 }
 private static ReentrantLock lock1 = new ReentrantLock();
 @Override
 public void run() {
 lock1.lock();
 try{
 if (lock1.isHeldByCurrentThread()){
 System.out.println(getName()+"获取到锁资源 lock1");
 }
 sleep(1000);
 }catch (Exception e){
 e.printStackTrace();
 } finally {
 System.out.println(getName()+"释放锁资源 lock1");
 lock1.unlock();
 }
 }
}

m0_62270892
关注
Java多线程笔记
03-11
Java多线程笔记 Java多线程笔记是 Java 编程语言中关于多线程编程的笔记，涵盖了线程基础知识、线程优先级、线程状态、守护线程、构造线程、线程中断等多方面的内容。 获取简单 main 程序中的线程 在 Java 中，...
马士兵多线程笔记.zip
02-21
以下是对马士兵多线程笔记的详细解析。 1. **多线程基础**：多线程是指一个应用程序中同时执行多个线程（即任务）的能力。这种并发执行可以提高系统资源的利用率，提升程序的响应速度和执行效率，特别是在多核...
java多线程笔记
12-10
Java线程的知识点总结。doc
java中的多线程笔记
07-08
此外，多线程编程中还有一些关键概念和工具，比如线程同步和互斥机制，用于解决并发访问共享资源时可能出现的数据竞争问题。Java 提供了以下机制来保证线程安全： 1. `synchronized` 关键字：用于实现互斥访问，确保...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 584
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1074
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
qq_36400213的博客
11-04 735
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 272
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
java_方法重写/覆盖(override)
最新发布
HHppGo的博客
11-07 229
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
信息学科平台系统开发：基于Spring Boot的最佳实践
2401_85761762的博客
11-02 986
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。本系统具有易操作、易管理、交互性好的特点，在操作上是非常简单的，因此在操作上具有很高的可行性。（2）该完整内容全面，管理方便可以及时的全面的处理各种错误，异常，这样避免了很多因用户的马虎操作而出现的失误，其操作方便，用户界面友好，能够上网的人都可以很好的进行操作。
【Java知识】Java基础-对象排序的实现
wendao76的专栏
11-04 246
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
在 C# 中，如何实现观察者模式？
Leo的博客
11-06 218
观察者模式是一种设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当该主题对象的状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。这个模式常用于事件处理系统、通知系统等场景。
并发编程的基础：深入理解内存屏障（Memory Barriers）
2401_86353562的博客
11-06 686
内存屏障是一种基础语言，在不同的计算机架构下有不同的实现细节。本文主要在x86_64处理器下，通过Linux及其内核代码来分析和使用内存屏障对大多数应用层开发者来说，“内存屏障”（memory Barrier）是一种陌生，甚至有些诡异的技术。实际上，他机制常被用在操作系统内核中，用于实现同步、驱动程序利用它，能够实现高效的无锁数据结构，提高多线程程序的性能表现。本文首先探讨了内存屏障的必要性，之后介绍如何利用内存屏障实现一个无锁唤醒振荡器（队列），用于在多个线程间进行高效的数据交换。
Java学习Day54：初遇萍萍(权限控制)
weixin_51721783的博客
10-29 1302
web.xml：在health_backend工程的web.xml文件中配置用于整合Spring Security框架的过滤器DelegatingFilterProxy。
大数据新视界 -- 大数据大厂之 Impala 性能优化：解锁大数据分析的速度密码（上）（1/30）
【青云交】荣登原力全国前三，作者周榜前四，苏州均榜首，全网领军人物前列。
11-03 968
本文围绕 Impala 性能优化展开，阐述其对大数据分析效率和企业决策的关键意义，剖析数据规模与复杂度、查询优化等挑战。介绍数据存储（分区、压缩）和查询（索引、语句重塑）优化策略，并通过电商和金融案例展示效果。对比 Impala 与 Hive、Spark SQL 的优劣，强调 Impala 在 OLAP 查询的优势。还介绍了可视化工具对优化的助力。鼓励读者分享 Impala 使用中的优化经验，同时预告下一篇将深入探讨数据存储分区相关内容。
Qt自定义控件：汽车速度表
weixin_44788175的博客
11-02 352
从外到内进行绘制，初始化画布，画渐变色外圈，画刻度，写刻度文字，画指针，画扇形，画内圈渐变色，画黑色内圈，写当前值。这里难点使用正弦和余弦计算绘制刻度字。
GEMM优化（待更新）
qq_62704693的博客
11-03 745
来源参考：深入浅出GPU优化系列：GEMM优化（一） - 知乎深入浅出GPU优化系列：GEMM优化（二） - 知乎深入浅出GPU优化系列：GEMM优化（三） - 知乎。
Tomcat 启动卡住，日志显示 At least one JAR was scanned for TLDs yet contained no TLDs.
jiangshanwe
11-06 189
Tomcat 启动后，控制台输出卡在了：因为应用一直没有成功，并且控制台输出上述信息后就停止了，就理所应当的以为卡住的原因就是它，然后疯狂的百度/谷歌/GPT关键字，各种方法都试过了，但是都没有效果，还是卡着不动。使用获取当前 Java 进程的堆栈信息，发现是应用本身卡在了 *** 连接上，和 Tomcat 最后卡住的日志无任何关系。日志和问题，有时候并不是因果。程序没有反应，jstack 往往是最有力的工具。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值